Keep batch write tests with orchestration

Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com>

Copilot-Session: d7dc302d-e6f2-41e9-a2c8-ed598de47067

Author: zwick

pkg/github/projects_batch_test.go

@@ -4,6 +4,7 @@ import (
 	"context"
 	"encoding/json"
 	"fmt"
+	"io"
 	"math"
 	"net/http"
 	"strings"
@@ -57,6 +58,55 @@ func projectIDMatcher(owner string, projectNumber int, projectNodeID string) git
 	)
 }
 
+// mutationAwareTransport routes GraphQL requests to a fixed query-matcher
+// transport (e.g. githubv4mock.NewMockedHTTPClient's Transport) for ordinary
+// queries/lookups, and to a sequenced, call-counted responder for mutation
+// requests, so end-to-end tests can assert on aliased-mutation call counts and
+// per-call variables without needing to hand-construct the exact minified
+// mutation query text that reflect.StructOf produces.
+type mutationAwareTransport struct {
+	t               *testing.T
+	queries         http.RoundTripper
+	mutationRespond func(callIndex int, req capturedGraphQLRequest) (status int, body string)
+	queryCalls      []capturedGraphQLRequest
+	mutationCalls   []capturedGraphQLRequest
+}
+
+func (m *mutationAwareTransport) RoundTrip(req *http.Request) (*http.Response, error) {
+	raw, err := io.ReadAll(req.Body)
+	if err != nil {
+		return nil, err
+	}
+	_ = req.Body.Close()
+
+	var parsed struct {
+		Query     string         `json:"query"`
+		Variables map[string]any `json:"variables"`
+	}
+	if err := json.Unmarshal(raw, &parsed); err != nil {
+		return nil, err
+	}
+
+	if !strings.HasPrefix(strings.TrimSpace(parsed.Query), "mutation") {
+		m.queryCalls = append(m.queryCalls, capturedGraphQLRequest{Query: parsed.Query, Variables: parsed.Variables})
+		req.Body = io.NopCloser(strings.NewReader(string(raw)))
+		return m.queries.RoundTrip(req)
+	}
+
+	captured := capturedGraphQLRequest{Query: parsed.Query, Variables: parsed.Variables}
+	idx := len(m.mutationCalls)
+	m.mutationCalls = append(m.mutationCalls, captured)
+	if m.mutationRespond == nil {
+		m.t.Fatalf("unexpected mutation call #%d (query: %s)", idx, parsed.Query)
+	}
+	status, body := m.mutationRespond(idx, captured)
+	return &http.Response{
+		StatusCode: status,
+		Body:       io.NopCloser(strings.NewReader(body)),
+		Header:     make(http.Header),
+	}, nil
+}
+
 func Test_UpdateProjectItemsBatch_TopLevelGuards(t *testing.T) {
 	tooMany := make([]any, maxProjectItemsPerBatch+1)
 	validItem := map[string]any{"node_id": "PVTI_item1"}
@@ -1076,3 +1126,160 @@ func Test_ResolveItemNodeIDsByNumericID_DeduplicatesOrgAndUserLookups(t *testing
 		})
 	}
 }
+
+func Test_ExecuteBatchWrites_AllAliasGraphQLErrorContinues(t *testing.T) {
+	transport := &sequencedGraphQLTransport{
+		t: t,
+		responses: []func(capturedGraphQLRequest) (int, string){
+			func(_ capturedGraphQLRequest) (int, string) {
+				return http.StatusOK, mutationErrorResponse(t, map[string]any{}, "all aliases failed")
+			},
+			func(_ capturedGraphQLRequest) (int, string) {
+				return http.StatusOK, mutationDataResponse(t, map[int]struct{ NodeID, FullDatabaseID string }{
+					0: {NodeID: "PVTI_item20", FullDatabaseID: "1020"},
+				})
+			},
+		},
+	}
+	items, results := batchItemsOfSize(21)
+
+	executeTestBatchWrites(t.Context(), newTestGQLClient(transport), items, results)
+
+	assert.Len(t, transport.calls, 2)
+	for i := range 20 {
+		assert.Equal(t, batchItemUnknown, results[i].Status)
+	}
+	assert.Equal(t, batchItemSucceeded, results[20].Status)
+}
+
+func Test_ExecuteBatchWrites_PartialGraphQLErrorPreservesSuccess(t *testing.T) {
+	transport := &sequencedGraphQLTransport{
+		t: t,
+		responses: []func(capturedGraphQLRequest) (int, string){
+			func(_ capturedGraphQLRequest) (int, string) {
+				return http.StatusOK, mutationErrorResponse(t, map[string]any{
+					"item0": map[string]any{
+						"projectV2Item": map[string]any{"id": "PVTI_item0", "fullDatabaseId": "1000"},
+					},
+					"item1": nil,
+				}, "item1 failed")
+			},
+		},
+	}
+	items, results := batchItemsOfSize(2)
+
+	executeTestBatchWrites(t.Context(), newTestGQLClient(transport), items, results)
+
+	assert.Equal(t, batchItemSucceeded, results[0].Status)
+	assert.Equal(t, items[0].ref, results[0].Ref)
+	assert.Equal(t, batchItemUnknown, results[1].Status)
+	assert.Equal(t, items[1].ref, results[1].Ref)
+}
+
+func Test_ExecuteBatchWrites_AmbiguousSuccessResponseAborts(t *testing.T) {
+	tests := []struct {
+		name               string
+		body               string
+		confirmedSuccesses int
+	}{
+		{
+			name: "null data",
+			body: `{"data":null}`,
+		},
+		{
+			name: "missing data",
+			body: `{}`,
+		},
+		{
+			name: "partial data without errors",
+			body: mutationDataResponse(t, map[int]struct{ NodeID, FullDatabaseID string }{
+				0: {NodeID: "PVTI_item0", FullDatabaseID: "1000"},
+			}),
+			confirmedSuccesses: 1,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			transport := &sequencedGraphQLTransport{
+				t: t,
+				responses: []func(capturedGraphQLRequest) (int, string){
+					func(_ capturedGraphQLRequest) (int, string) {
+						return http.StatusOK, tt.body
+					},
+					func(_ capturedGraphQLRequest) (int, string) {
+						return http.StatusOK, mutationDataResponse(t, map[int]struct{ NodeID, FullDatabaseID string }{
+							0: {NodeID: "PVTI_item20", FullDatabaseID: "1020"},
+						})
+					},
+				},
+			}
+			items, results := batchItemsOfSize(21)
+
+			executeTestBatchWrites(t.Context(), newTestGQLClient(transport), items, results)
+
+			assert.Len(t, transport.calls, 1)
+			for i, result := range results {
+				if i < tt.confirmedSuccesses {
+					assert.Equal(t, batchItemSucceeded, result.Status)
+					continue
+				}
+				assert.Equal(t, batchItemUnknown, result.Status)
+			}
+		})
+	}
+}
+
+func Test_ExecuteBatchWrites_TransportTimeoutAborts(t *testing.T) {
+	transport := &errorGraphQLTransport{err: context.DeadlineExceeded}
+	items, results := batchItemsOfSize(21)
+
+	executeTestBatchWrites(t.Context(), newTestGQLClient(transport), items, results)
+
+	assert.Equal(t, 1, transport.calls)
+	for _, result := range results {
+		assert.Equal(t, batchItemUnknown, result.Status)
+	}
+}
+
+func Test_ExecuteBatchWrites_CanceledContextSkipsWrites(t *testing.T) {
+	ctx, cancel := context.WithCancel(t.Context())
+	cancel()
+	transport := &sequencedGraphQLTransport{t: t}
+	items, results := batchItemsOfSize(21)
+
+	executeTestBatchWrites(ctx, newTestGQLClient(transport), items, results)
+
+	assert.Empty(t, transport.calls)
+	for _, result := range results {
+		assert.Equal(t, batchItemUnknown, result.Status)
+	}
+}
+
+func executeTestBatchWrites(ctx context.Context, gqlClient *githubv4.Client, items []resolvedBatchItem, results []batchItemResult) {
+	executeBatchWrites(
+		ctx,
+		batchWriteOperation{
+			gqlClient: gqlClient,
+			kind:      batchMutationUpdate,
+			projectID: githubv4.ID("PVT_project"),
+			fieldID:   githubv4.ID("PVTF_field"),
+			value:     githubv4.ProjectV2FieldValue{Text: githubv4.NewString("value")},
+		},
+		items,
+		results,
+	)
+}
+
+func batchItemsOfSize(n int) ([]resolvedBatchItem, []batchItemResult) {
+	items := make([]resolvedBatchItem, n)
+	for i := range n {
+		nodeID := fmt.Sprintf("PVTI_item%d", i)
+		items[i] = resolvedBatchItem{
+			index:  i,
+			ref:    map[string]any{"node_id": nodeID},
+			nodeID: nodeID,
+		}
+	}
+	return items, make([]batchItemResult, n)
+}