test(sdk): cover Runs, streaming client, InsecureSkipVerify, patch JSON

Adds tests for gaps found by coverage audit:
- ScheduledSessionAPI.Runs (project-scoped, verifies path and response)
- streamingClient initialization (DisableCompression=true)
- WithInsecureSkipVerify applies to both httpClient and streamingClient
- ScheduledSessionPatch JSON round-trip (all 11 fields, omitempty semantics)

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: jsell-rh

components/ambient-sdk/go-sdk/client/extensions_test.go

@@ -412,3 +412,188 @@ func TestClientProjectAccessor(t *testing.T) {
 		t.Errorf("expected project %q, got %q", testProject, c.Project())
 	}
 }
+
+// ---------------------------------------------------------------------------
+// ScheduledSession Runs
+// ---------------------------------------------------------------------------
+
+func TestScheduledSessionRuns(t *testing.T) {
+	want := &types.SessionList{
+		ListMeta: types.ListMeta{Kind: "SessionList", Page: 1, Size: 10, Total: 2},
+		Items: []types.Session{
+			{ObjectReference: types.ObjectReference{ID: "sess-run-1"}, Name: "run-1"},
+			{ObjectReference: types.ObjectReference{ID: "sess-run-2"}, Name: "run-2"},
+		},
+	}
+
+	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		if r.Method != http.MethodGet {
+			t.Errorf("expected GET, got %s", r.Method)
+		}
+		if !strings.HasSuffix(r.URL.Path, "/scheduled-sessions/ss-runs/runs") {
+			t.Errorf("unexpected path: %s", r.URL.Path)
+		}
+		if !strings.Contains(r.URL.Path, "/projects/proj-a/") {
+			t.Errorf("expected project in path: %s", r.URL.Path)
+		}
+		w.Header().Set("Content-Type", "application/json")
+		w.WriteHeader(http.StatusOK)
+		_, _ = w.Write(marshalJSON(t, want))
+	}))
+	defer srv.Close()
+
+	c := newTestClient(t, srv)
+	got, err := c.ScheduledSessions().Runs(context.Background(), "proj-a", "ss-runs", &types.ListOptions{})
+	if err != nil {
+		t.Fatalf("Runs: %v", err)
+	}
+	if len(got.Items) != 2 {
+		t.Errorf("expected 2 runs, got %d", len(got.Items))
+	}
+	if got.Items[0].ID != "sess-run-1" {
+		t.Errorf("unexpected first run: %+v", got.Items[0])
+	}
+}
+
+// ---------------------------------------------------------------------------
+// streamingClient initialization
+// ---------------------------------------------------------------------------
+
+func TestNewClient_StreamingClientCreated(t *testing.T) {
+	c, err := NewClient("http://localhost:8080", testToken, testProject)
+	if err != nil {
+		t.Fatalf("NewClient: %v", err)
+	}
+	if c.streamingClient == nil {
+		t.Fatal("expected streamingClient to be initialized")
+	}
+	tr, ok := c.streamingClient.Transport.(*http.Transport)
+	if !ok {
+		t.Fatal("expected streamingClient transport to be *http.Transport")
+	}
+	if !tr.DisableCompression {
+		t.Error("expected streamingClient transport to have DisableCompression=true")
+	}
+}
+
+// ---------------------------------------------------------------------------
+// WithInsecureSkipVerify applies to both clients
+// ---------------------------------------------------------------------------
+
+func TestWithInsecureSkipVerify_BothClients(t *testing.T) {
+	c, err := NewClient("http://localhost:8080", testToken, testProject, WithInsecureSkipVerify())
+	if err != nil {
+		t.Fatalf("NewClient: %v", err)
+	}
+	if !c.insecureSkipVerify {
+		t.Error("expected insecureSkipVerify=true")
+	}
+
+	checkInsecure := func(name string, hc *http.Client) {
+		t.Helper()
+		tr, ok := hc.Transport.(*http.Transport)
+		if !ok || tr == nil {
+			t.Fatalf("%s: expected *http.Transport, got %T", name, hc.Transport)
+		}
+		if tr.TLSClientConfig == nil {
+			t.Fatalf("%s: expected TLSClientConfig to be set", name)
+		}
+		if !tr.TLSClientConfig.InsecureSkipVerify {
+			t.Errorf("%s: expected InsecureSkipVerify=true", name)
+		}
+	}
+	checkInsecure("httpClient", c.httpClient)
+	checkInsecure("streamingClient", c.streamingClient)
+}
+
+// ---------------------------------------------------------------------------
+// ScheduledSessionPatch JSON round-trip
+// ---------------------------------------------------------------------------
+
+func TestScheduledSessionPatch_JSONRoundTrip(t *testing.T) {
+	enabled := true
+	timeout := int32(3600)
+	inactivity := int32(300)
+	stopOnRun := false
+
+	patch := types.ScheduledSessionPatch{
+		AgentID:           strPtr("agent-1"),
+		Description:       strPtr("nightly build"),
+		Enabled:           &enabled,
+		InactivityTimeout: &inactivity,
+		Name:              strPtr("nightly"),
+		RunnerType:        strPtr("claude"),
+		Schedule:          strPtr("0 2 * * *"),
+		SessionPrompt:     strPtr("run tests"),
+		StopOnRunFinished: &stopOnRun,
+		Timeout:           &timeout,
+		Timezone:          strPtr("UTC"),
+	}
+
+	b, err := json.Marshal(patch)
+	if err != nil {
+		t.Fatalf("marshal: %v", err)
+	}
+
+	var m map[string]any
+	if err := json.Unmarshal(b, &m); err != nil {
+		t.Fatalf("unmarshal to map: %v", err)
+	}
+
+	expectedKeys := []string{
+		"agent_id", "description", "enabled", "inactivity_timeout",
+		"name", "runner_type", "schedule", "session_prompt",
+		"stop_on_run_finished", "timeout", "timezone",
+	}
+	for _, k := range expectedKeys {
+		if _, ok := m[k]; !ok {
+			t.Errorf("missing key %q in marshaled JSON", k)
+		}
+	}
+	if len(m) != len(expectedKeys) {
+		t.Errorf("expected %d keys, got %d: %v", len(expectedKeys), len(m), m)
+	}
+
+	// Verify false bool is NOT omitted (pointer semantics)
+	if m["stop_on_run_finished"] != false {
+		t.Errorf("expected stop_on_run_finished=false, got %v", m["stop_on_run_finished"])
+	}
+
+	// Round-trip back to struct
+	var decoded types.ScheduledSessionPatch
+	if err := json.Unmarshal(b, &decoded); err != nil {
+		t.Fatalf("unmarshal to struct: %v", err)
+	}
+	if *decoded.AgentID != "agent-1" {
+		t.Errorf("agent_id mismatch: %v", decoded.AgentID)
+	}
+	if *decoded.Timeout != 3600 {
+		t.Errorf("timeout mismatch: %v", decoded.Timeout)
+	}
+}
+
+// Omitted fields should not appear in JSON
+func TestScheduledSessionPatch_OmitEmpty(t *testing.T) {
+	patch := types.ScheduledSessionPatch{
+		Name: strPtr("only-name"),
+	}
+
+	b, err := json.Marshal(patch)
+	if err != nil {
+		t.Fatalf("marshal: %v", err)
+	}
+
+	var m map[string]any
+	if err := json.Unmarshal(b, &m); err != nil {
+		t.Fatalf("unmarshal: %v", err)
+	}
+
+	if len(m) != 1 {
+		t.Errorf("expected 1 key (name only), got %d: %v", len(m), m)
+	}
+	if m["name"] != "only-name" {
+		t.Errorf("expected name=only-name, got %v", m["name"])
+	}
+}
+
+func strPtr(s string) *string { return &s }