package api import ( "bytes" "context" "crypto/ed25519" "crypto/sha256" "droboticflow/internal/config" "droboticflow/internal/domain" "droboticflow/internal/store" "encoding/base64" "encoding/json" "errors" "fmt" "net/http" "net/http/httptest" "os" "strings" "testing" "time" ) func closureTestSigningKey() ed25519.PrivateKey { return ed25519.NewKeyFromSeed(bytes.Repeat([]byte{7}, 32)) } func closureSignedReleaseMap(t *testing.T, id, version string) map[string]any { t.Helper() artifacts := map[string]string{} digests := map[string]string{} for _, p := range objectSyncClientPlatforms { artifacts[p] = "https://downloads.example/" + version + "/" + p digests[p] = strings.Repeat("a", 64) } r := map[string]any{"manifestVersion": 2, "id": id, "version": version, "kind": "signed", "protocolVersion": "v2", "minimumServerVersion": "1.0.5", "minimumStateSchema": 5, "maximumStateSchema": 5, "channel": "canary", "rolloutPercent": 5, "paused": false, "artifacts": artifacts, "sha256": digests} closureSignReleaseMap(t, r) return r } func closureSignReleaseMap(t *testing.T, value map[string]any) { t.Helper() raw, e := json.Marshal(value) if e != nil { t.Fatal(e) } var r domain.ObjectSyncClientReleaseRecord if e = json.Unmarshal(raw, &r); e != nil { t.Fatal(e) } payload, e := objectSyncReleasePayload(r) if e != nil { t.Fatal(e) } value["signature"] = base64.StdEncoding.EncodeToString(ed25519.Sign(closureTestSigningKey(), payload)) } func activateClosureTestToken(t *testing.T, h http.Handler, body []byte) { t.Helper() var auth struct { Token string `json:"accessToken"` Activation string `json:"activationId"` } if err := json.Unmarshal(body, &auth); err != nil { t.Fatal(err) } r := httptest.NewRequest(http.MethodPost, "/api/external/object-sync/auth/activate", strings.NewReader(fmt.Sprintf(`{"activationId":%q}`, auth.Activation))) r.Header.Set("Content-Type", "application/json") r.Header.Set("Authorization", "Bearer "+auth.Token) r.Header.Set("Idempotency-Key", "activate-"+auth.Activation) w := httptest.NewRecorder() h.ServeHTTP(w, r) if w.Code != 200 { t.Fatalf("activation failed: %d %s", w.Code, w.Body.String()) } } func TestClosureForeignLeaseNotMutated(t *testing.T) { h, s := objectSyncTestHandler(t, true) l, ok, e := s.AcquireObjectSyncLease(t.Context(), domain.ObjectSyncLeaseRecord{OrganizationID: "foreign", ResourceHash: "foreign-resource", OwnerSessionID: "foreign-session", OwnerItemID: "foreign-item"}, time.Minute) if e != nil || !ok { t.Fatal(e) } w := objectSyncRequest(t, h, "POST", "/api/object-sync/leases/"+l.ID+"/force-release", map[string]any{}, "foreign-lease") if w.Code != 404 { t.Fatal(w.Code) } owned, e := s.RenewObjectSyncLease(t.Context(), l.ID, l.OwnerSessionID, l.OwnerItemID, l.FencingToken, time.Minute) if e != nil || !owned { t.Fatal("denied request mutated foreign lease") } } func TestClosureRetryableContentionReevaluatesSameKey(t *testing.T) { s, _, session, request := cancellationRaceFixture(t, domain.ObjectSyncSessionPlanned) space, _ := s.GetObjectSyncSpace(t.Context(), session.SyncSpaceID) item := domain.ObjectSyncItemRecord{ID: "contended", OrganizationID: session.OrganizationID, SessionID: session.ID, TargetKey: "file", RelativePath: "file", Status: domain.ObjectSyncItemPlanned, Action: "create"} s.UpsertObjectSyncItems(t.Context(), []domain.ObjectSyncItemRecord{item}) holder, ok, e := s.AcquireObjectSyncLease(t.Context(), domain.ObjectSyncLeaseRecord{OrganizationID: session.OrganizationID, ResourceHash: objectSyncLeaseResourceHash(*space, item.TargetKey), OwnerSessionID: "other", OwnerItemID: "other"}, time.Minute) if e != nil || !ok { t.Fatal(e) } first := request("items/contended/reserve", map[string]any{}, "same") if first.Code != 409 { t.Fatal(first.Code) } s.ReleaseObjectSyncLease(t.Context(), holder.ID, holder.OwnerSessionID, holder.OwnerItemID, holder.FencingToken) second := request("items/contended/reserve", map[string]any{}, "same") if second.Code != 200 || second.Header().Get("Idempotency-Replayed") != "" { t.Fatalf("contention remained cached: %d %s", second.Code, second.Body.String()) } } type closureAuditFailureStore struct { *store.MemoryStore calls int } func (s *closureAuditFailureStore) ListObjectSyncAuditRange(_ context.Context, _, _, _ string, _ domain.ObjectSyncListQuery) (domain.ObjectSyncAuditPage, error) { s.calls++ if s.calls > 1 { return domain.ObjectSyncAuditPage{}, errors.New("second page unavailable") } return domain.ObjectSyncAuditPage{Items: []domain.ObjectSyncAuditEvent{{ID: "first", Action: "fixture"}}, NextCursor: "next"}, nil } func TestClosureAuditExportIsAllOrError(t *testing.T) { for _, format := range []string{"csv", "ndjson"} { t.Run(format, func(t *testing.T) { s := &closureAuditFailureStore{MemoryStore: store.NewMemoryStore()} h := newBusinessTestHandlerWithConfig(s, nil, config.AppConfig{ObjectSyncEnabled: true}) w := objectSyncRequest(t, h, "GET", "/api/object-sync/audit-events/export?format="+format, nil, "") if w.Code != 503 || w.Header().Get("Content-Disposition") != "" || strings.Contains(w.Body.String(), `"id":"first"`) { t.Fatalf("partial export accepted: %d %s", w.Code, w.Body.String()) } }) } } func closureBearer(t *testing.T, h http.Handler, method, path, token string, payload any, key string) *httptest.ResponseRecorder { t.Helper() var b bytes.Buffer if payload != nil { if e := json.NewEncoder(&b).Encode(payload); e != nil { t.Fatal(e) } } r := httptest.NewRequest(method, path, &b) r.Header.Set("Content-Type", "application/json") r.Header.Set("Authorization", "Bearer "+token) if key != "" { r.Header.Set("Idempotency-Key", key) } w := httptest.NewRecorder() h.ServeHTTP(w, r) return w } func TestClosurePendingAuthPreservesOldTokenUntilActivation(t *testing.T) { h, s := objectSyncTestHandler(t, true) hash, e := hashObjectSyncSecret("fixture-secret") if e != nil { t.Fatal(e) } c := domain.ObjectSyncCredentialRecord{ID: "cred", OrganizationID: domain.DefaultOrganizationID, AccessKeyID: "key", SecretHash: hash, Enabled: true, TokenBindings: []domain.ObjectSyncCredentialTokenBinding{{DeviceID: "device", TokenHash: sessionTokenHash("old-token")}}} s.UpsertObjectSyncCredential(t.Context(), c) s.UpsertObjectSyncDevice(t.Context(), domain.ObjectSyncDeviceRecord{ID: "device", OrganizationID: c.OrganizationID, Status: "active"}) prepare := objectSyncRequest(t, h, "POST", "/api/external/object-sync/auth/token", map[string]any{"accessKeyId": "key", "secret": "fixture-secret", "deviceId": "device", "recoverDevice": true}, "auth-prepare") if prepare.Code != 200 { t.Fatal(prepare.Code, prepare.Body.String()) } var auth struct { AccessToken string `json:"accessToken"` ActivationID string `json:"activationId"` } json.Unmarshal(prepare.Body.Bytes(), &auth) if w := closureBearer(t, h, "GET", "/api/external/object-sync/capabilities", "old-token", nil, ""); w.Code != 200 { t.Fatal("prepare revoked old token", w.Code, w.Body.String()) } if w := closureBearer(t, h, "GET", "/api/external/object-sync/sessions", auth.AccessToken, nil, ""); w.Code != 403 { t.Fatal("pending token granted transfer access", w.Code) } for range 2 { if w := closureBearer(t, h, "POST", "/api/external/object-sync/auth/activate", auth.AccessToken, map[string]any{"activationId": auth.ActivationID}, "activate-"+auth.ActivationID); w.Code != 200 { t.Fatal("activation not replayable", w.Code, w.Body.String()) } } if w := closureBearer(t, h, "GET", "/api/external/object-sync/capabilities", "old-token", nil, ""); w.Code != 401 { t.Fatal("old token remains active", w.Code) } w := closureBearer(t, h, "GET", "/api/external/object-sync/capabilities", auth.AccessToken, nil, "") if w.Code != 200 || !strings.Contains(w.Body.String(), `"credentialActivated":true`) { t.Fatal(w.Code, w.Body.String()) } missing := objectSyncRequest(t, h, "POST", "/api/external/object-sync/auth/token", map[string]any{"accessKeyId": "key", "secret": "fixture-secret", "deviceId": "misspelled", "recoverDevice": true}, "missing-device") if missing.Code != 404 { t.Fatal("unknown recovery identity accepted", missing.Code) } d, _ := s.GetObjectSyncDevice(t.Context(), "misspelled") if d != nil { t.Fatal("recovery silently created new device") } } func TestClosurePreviewCannotReserveFile(t *testing.T) { s, _, session, request := cancellationRaceFixture(t, domain.ObjectSyncSessionPlanned) session.Preview = true s.UpsertObjectSyncSession(t.Context(), session) item := domain.ObjectSyncItemRecord{ID: "preview-item", OrganizationID: session.OrganizationID, SessionID: session.ID, TargetKey: "file", RelativePath: "file", Status: domain.ObjectSyncItemPlanned, Action: "create"} s.UpsertObjectSyncItems(t.Context(), []domain.ObjectSyncItemRecord{item}) w := request("items/preview-item/reserve", map[string]any{}, "reserve-preview") if w.Code != 409 { t.Fatal("preview entered upload", w.Code, w.Body.String()) } } func TestClosureSignedPolicyAndMonotonicUpdates(t *testing.T) { h, s := objectSyncTestHandler(t, true) value := closureSignedReleaseMap(t, "current-v2", "1.0.5") w := objectSyncRequest(t, h, "POST", "/api/object-sync/client-releases", value, "register-v2") if w.Code != 200 { t.Fatal(w.Code, w.Body.String()) } var original domain.ObjectSyncClientReleaseRecord json.Unmarshal(w.Body.Bytes(), &original) original.StageChangedAt = time.Now().Add(-25 * time.Hour).UTC().Format(time.RFC3339Nano) s.UpdateObjectSyncRollout(t.Context(), original, 1) policy := map[string]any{"channel": "pilot", "rolloutPercent": 20, "paused": false, "expectedRevision": 2} w = objectSyncRequest(t, h, "PUT", "/api/object-sync/client-releases/current-v2/rollout", policy, "promote-v2") if w.Code != 200 { t.Fatal(w.Code, w.Body.String()) } var advanced domain.ObjectSyncClientReleaseRecord json.Unmarshal(w.Body.Bytes(), &advanced) before, _ := objectSyncReleasePayload(original) after, _ := objectSyncReleasePayload(advanced) if !bytes.Equal(before, after) || original.Signature != advanced.Signature { t.Fatal("policy changed signed bytes") } w = objectSyncRequest(t, h, "PUT", "/api/object-sync/client-releases/current-v2/rollout", policy, "stale-v2") if w.Code != 409 { t.Fatal("stale revision accepted", w.Code) } w = objectSyncRequest(t, h, "POST", "/api/object-sync/client-releases", value, "register-again") if w.Code != 200 || !strings.Contains(w.Body.String(), `"channel":"pilot"`) { t.Fatal("registration reset rollout", w.Code, w.Body.String()) } value["id"] = "different-id" closureSignReleaseMap(t, value) w = objectSyncRequest(t, h, "POST", "/api/object-sync/client-releases", value, "duplicate-version") if w.Code != 409 { t.Fatal("version bypass accepted", w.Code, w.Body.String()) } c := domain.ObjectSyncCredentialRecord{ID: "updates", OrganizationID: domain.DefaultOrganizationID, Enabled: true, TokenBindings: []domain.ObjectSyncCredentialTokenBinding{{DeviceID: "update-device", TokenHash: sessionTokenHash("update-token")}}} s.UpsertObjectSyncCredential(t.Context(), c) s.UpsertObjectSyncDevice(t.Context(), domain.ObjectSyncDeviceRecord{ID: "update-device", OrganizationID: c.OrganizationID, Status: "active", Platform: "linux", Architecture: "x86_64"}) advanced.Channel = "stable" advanced.RolloutPercent = 100 s.UpdateObjectSyncRollout(t.Context(), advanced, advanced.Revision) for _, tc := range []struct { current string want bool }{{"1.0.4", true}, {"1.0.5", false}, {"1.0.6", false}, {"1.0.5-rc.1", true}} { w = closureBearer(t, h, "GET", "/api/external/object-sync/client-updates?currentVersion="+tc.current, "update-token", nil, "") if w.Code != 200 || !strings.Contains(w.Body.String(), fmt.Sprintf(`"updateAvailable":%t`, tc.want)) { t.Fatal(tc, w.Code, w.Body.String()) } } } // Fixture generated by the real Rust drosync-sign-manifest using RFC8032's // public test key. Ampersands exercise cross-language canonical JSON encoding. func TestClosureRustSignerGoVerifier(t *testing.T) { raw, e := os.ReadFile("testdata/drosync-release-v2-rust.json") if e != nil { t.Fatal(e) } var r domain.ObjectSyncClientReleaseRecord if e = json.Unmarshal(raw, &r); e != nil { t.Fatal(e) } s := server{objectSyncUpdateSigningPublicKey: "11qYAYKxCrfVS/7TyWQHOg7hcvPapiMlrwIaaPcHURo="} if e = s.verifyObjectSyncRelease(r); e != nil { t.Fatal("Rust fixture rejected by Go", e) } r.Channel = "stable" r.RolloutPercent = 100 r.Paused = true if e = s.verifyObjectSyncRelease(r); e != nil { t.Fatal("policy invalidated signed artifact", e) } r.Artifacts["linux-arm64"] += "tampered" if e = s.verifyObjectSyncRelease(r); e == nil { t.Fatal("tampered artifact accepted") } } func TestClosureWorkflowResultsRetryAndManifestIntegrity(t *testing.T) { h, s := objectSyncTestHandler(t, true) ctx := t.Context() org := domain.DefaultOrganizationID browser := &resumableObjectSyncBrowser{fakeObjectStorageBrowser: newFakeObjectStorageBrowser()} original := storageConnectionBrowserResolver storageConnectionBrowserResolver = func(context.Context, *domain.StorageConnectionRecord) (objectStorageBrowser, func(), error) { return browser, func() {}, nil } t.Cleanup(func() { storageConnectionBrowserResolver = original }) s.UpsertObjectSyncSpace(ctx, domain.ObjectSyncSpaceRecord{ID: "space", OrganizationID: org, ConnectionID: "bos-connection", Bucket: "robot-data"}) s.UpsertObjectSyncReconcile(ctx, domain.ObjectSyncReconcileRecord{ID: "reconcile", OrganizationID: org, Status: "failed", Error: "BOS unavailable"}) s.UpsertObjectSyncRelease(ctx, domain.ObjectSyncReleaseRecord{ID: "release", OrganizationID: org, SyncSpaceID: "space", Status: "failed", Error: "BOS unavailable"}) for _, kind := range []string{"reconciles", "releases"} { id := strings.TrimSuffix(kind, "s") if kind == "reconciles" { id = "reconcile" } get := objectSyncRequest(t, h, "GET", "/api/object-sync/"+kind+"/"+id, nil, "") if get.Code != 200 || !strings.Contains(get.Body.String(), "BOS unavailable") { t.Fatal("lost asynchronous error", kind, get.Code, get.Body.String()) } retry := objectSyncRequest(t, h, "POST", "/api/object-sync/"+kind+"/"+id+"/retry", map[string]any{}, "retry-"+id) if retry.Code != 202 || !strings.Contains(retry.Body.String(), `"status":"pending"`) { t.Fatal(kind, retry.Code, retry.Body.String()) } } w := objectSyncRequest(t, h, "GET", "/api/object-sync/releases/release/manifest", nil, "") if w.Code != 409 { t.Fatal("pending manifest accepted", w.Code) } content := []byte("{\"path\":\"capture/data.mcap\"}\n") digest := fmt.Sprintf("%x", sha256.Sum256(content)) key := ".drosync-internal/releases/manifest.ndjson" object := "robot-data|" + key browser.objects[object] = domain.ObjectStorageObjectSummary{Bucket: "robot-data", Key: key, SizeBytes: int64(len(content))} browser.content[object] = content r, _ := s.GetObjectSyncRelease(ctx, "release") r.Status = "published" r.ManifestKey = key r.ManifestSHA256 = digest r.ObjectCount = 1 s.UpsertObjectSyncRelease(ctx, *r) w = objectSyncRequest(t, h, "GET", "/api/object-sync/releases/release/manifest", nil, "") if w.Code != 200 || !bytes.Equal(w.Body.Bytes(), content) || w.Header().Get("X-Content-SHA256") != digest { t.Fatal("verified manifest failed", w.Code, w.Body.String()) } browser.content[object] = []byte("truncated") w = objectSyncRequest(t, h, "GET", "/api/object-sync/releases/release/manifest", nil, "") if w.Code != 502 || w.Header().Get("Content-Disposition") != "" { t.Fatal("partial manifest returned success", w.Code, w.Body.String()) } r.OrganizationID = "foreign" s.UpsertObjectSyncRelease(ctx, *r) for _, path := range []string{"/api/object-sync/releases/release", "/api/object-sync/releases/release/manifest"} { w = objectSyncRequest(t, h, "GET", path, nil, "") if w.Code != 404 { t.Fatal("foreign result exposed", path, w.Code) } } }