test(mount): drop synthetic Results injection; assert POST /fs/file == 0

The TestBulkMigrationReducesHTTPCalls proof rewrote the mock /fs/bulk
response to include synthetic Results revisions — which the real server
does not return — so reconcileBulkWrite skipped its fallback ReadFile
calls only in the test. That masked production traffic and the
reviewer flagged it correctly (P2 on PR #63).

Drop the injection. Track POST vs GET separately on /fs/file:
 - assert 1 POST /fs/bulk           (batching works)
 - assert 0 POST /fs/file           (no per-file writes — the load-bearing guarantee)
 - log GET /fs/file count           (revision read-back, expected until server returns per-file revisions)

Test now passes against the real server's response shape.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: khaliqgant

internal/mountsync/syncer_test.go

@@ -660,11 +660,31 @@ func TestBulkMigrationReducesHTTPCalls(t *testing.T) {
 	workspaceID := "ws_mount_bulk_http_volume"
 	handler := newMountsyncAPIHandler(t, store)
 
+	// NOTE on what this test proves:
+	//
+	// The relayfile server's /fs/bulk response today only carries
+	// {written, errorCount, errors, correlationId} — it does NOT return
+	// per-file revisions. That means after a bulk write, the Syncer's
+	// reconcileBulkWrite() falls back to a per-file GET /fs/file to learn
+	// the new revision for If-Match on the next cycle. So in production
+	// the post-bulk traffic looks like: 1 POST /fs/bulk + N GET /fs/file.
+	//
+	// The migration's guarantee is: **zero per-file WRITES (POST /fs/file)
+	// after the first batch.** That is what this test asserts. It counts
+	// POST and GET separately on /fs/file so GET-based revision read-back
+	// does not trigger a false failure. An earlier version of this test
+	// mocked synthetic `Results` into the bulk response, which masked the
+	// GET fallback and reviewers flagged it as non-representative.
+	//
+	// When /fs/bulk grows per-file revision output on the server, the GET
+	// fallback goes away and this test can tighten to "zero total requests
+	// on /fs/file" by removing the PostCount filter below.
 	var requestCounts sync.Map
 	var requestsMu sync.Mutex
 	requests := make([]string, 0)
 	var fsFileRequestsMu sync.Mutex
 	fsFileRequests := make([]string, 0)
+	var fsFilePostCount atomic.Int32
 	counterFor := func(path string) *atomic.Int32 {
 		counter, _ := requestCounts.LoadOrStore(path, &atomic.Int32{})
 		return counter.(*atomic.Int32)
@@ -679,53 +699,14 @@ func TestBulkMigrationReducesHTTPCalls(t *testing.T) {
 			fsFileRequestsMu.Lock()
 			fsFileRequests = append(fsFileRequests, r.Method+" "+r.URL.String())
 			fsFileRequestsMu.Unlock()
-		}
-
-		var body []byte
-		if strings.HasSuffix(r.URL.Path, "/fs/bulk") && r.Method == http.MethodPost {
-			var err error
-			body, err = io.ReadAll(r.Body)
-			if err != nil {
-				t.Fatalf("read bulk request body failed: %v", err)
+			if r.Method == http.MethodPost {
+				fsFilePostCount.Add(1)
 			}
-			r.Body = io.NopCloser(bytes.NewReader(body))
 		}
 
 		recorder := httptest.NewRecorder()
 		handler.ServeHTTP(recorder, r)
 
-		if strings.HasSuffix(r.URL.Path, "/fs/bulk") && r.Method == http.MethodPost && recorder.Code == http.StatusAccepted {
-			var payload struct {
-				Files []BulkWriteFile `json:"files"`
-			}
-			if err := json.Unmarshal(body, &payload); err != nil {
-				t.Fatalf("unmarshal bulk request body failed: %v", err)
-			}
-
-			var response BulkWriteResponse
-			if err := json.Unmarshal(recorder.Body.Bytes(), &response); err != nil {
-				t.Fatalf("unmarshal bulk response failed: %v", err)
-			}
-
-			response.Results = make([]BulkWriteResult, 0, len(payload.Files))
-			for _, file := range payload.Files {
-				stored, err := store.ReadFile(workspaceID, normalizeRemotePath(file.Path))
-				if err != nil {
-					t.Fatalf("read stored bulk result for %s failed: %v", file.Path, err)
-				}
-				response.Results = append(response.Results, BulkWriteResult{
-					Path:        stored.Path,
-					Revision:    stored.Revision,
-					ContentType: stored.ContentType,
-				})
-			}
-
-			recorder.Body.Reset()
-			if err := json.NewEncoder(recorder.Body).Encode(response); err != nil {
-				t.Fatalf("encode augmented bulk response failed: %v", err)
-			}
-		}
-
 		for key, values := range recorder.Header() {
 			for _, value := range values {
 				w.Header().Add(key, value)
@@ -772,10 +753,15 @@ func TestBulkMigrationReducesHTTPCalls(t *testing.T) {
 		t.Fatalf("expected exactly one bulk request to %s, got %d", bulkPath, got)
 	}
 
-	filePath := fmt.Sprintf("/v1/workspaces/%s/fs/file", workspaceID)
-	if got := counterFor(filePath).Load(); got != 0 {
-		t.Fatalf("expected zero per-file requests to %s, got %d: %v (all requests: %v)", filePath, got, fsFileRequests, requests)
+	// The migration's load-bearing guarantee: no per-file POSTs (writes)
+	// to /fs/file. GETs on /fs/file from the post-bulk revision read-back
+	// are expected until the server returns per-file revisions in the
+	// bulk response — they're tracked in fsFileRequests for visibility
+	// but don't fail the test.
+	if got := fsFilePostCount.Load(); got != 0 {
+		t.Fatalf("expected zero POST /fs/file requests (per-file writes) after bulk migration, got %d: %v", got, fsFileRequests)
 	}
+	t.Logf("bulk migration verified: 1 POST /fs/bulk, 0 POST /fs/file, %d GET /fs/file (revision read-back)", len(fsFileRequests))
 }
 
 func TestBulkWrite_ChunkAtThreshold(t *testing.T) {