package api import ( "bytes" "context" "encoding/json" "net/http" "net/http/httptest" "strconv" "strings" "testing" "time" "droboticflow/internal/config" "droboticflow/internal/domain" "droboticflow/internal/store" ) func objectSyncTestHandler(t *testing.T, enabled bool) (http.Handler, *store.MemoryStore) { t.Helper() dataStore := store.NewMemoryStore() if err := dataStore.UpsertStorageConnection(t.Context(), domain.StorageConnectionRecord{ ID: "bos-connection", OrganizationID: domain.DefaultOrganizationID, Name: "BOS", Provider: domain.StorageProviderBOS, Endpoint: "https://bj.bcebos.com", AccessKeyID: "masked-in-api", SecretAccessKey: "masked-in-api", }); err != nil { t.Fatal(err) } return NewHandlerWithConfig(dataStore, nil, config.AppConfig{ ObjectSyncEnabled: enabled, WorkspaceMountPath: "/workspace", }), dataStore } func objectSyncRequest(t *testing.T, handler http.Handler, method, target string, payload any, idempotencyKey string) *httptest.ResponseRecorder { t.Helper() var body bytes.Buffer if payload != nil { if err := json.NewEncoder(&body).Encode(payload); err != nil { t.Fatal(err) } } request := httptest.NewRequest(method, target, &body) request.Header.Set("Content-Type", "application/json") if idempotencyKey != "" { request.Header.Set("Idempotency-Key", idempotencyKey) } writer := httptest.NewRecorder() handler.ServeHTTP(writer, request) return writer } func TestObjectSyncFeatureFlagBlocksAllRoutes(t *testing.T) { handler, _ := objectSyncTestHandler(t, false) writer := objectSyncRequest(t, handler, http.MethodGet, "/api/object-sync/spaces", nil, "") if writer.Code != http.StatusServiceUnavailable { t.Fatalf("status = %d, want %d; body=%s", writer.Code, http.StatusServiceUnavailable, writer.Body.String()) } var response objectSyncAPIError if err := json.Unmarshal(writer.Body.Bytes(), &response); err != nil { t.Fatal(err) } if response.Code != "object_sync_disabled" || response.RequestID == "" { t.Fatalf("unexpected error envelope: %#v", response) } } func TestExternalObjectSyncUsesDeviceCredentialWithoutSharedAPIToken(t *testing.T) { dataStore := store.NewMemoryStore() handler := NewHandlerWithConfig(dataStore, nil, config.AppConfig{ APIToken: "shared-platform-token", RequireSessionAuth: true, ObjectSyncEnabled: true, }) writer := objectSyncRequest(t, handler, http.MethodGet, "/api/external/object-sync/capabilities", nil, "") if writer.Code != http.StatusUnauthorized { t.Fatalf("status = %d, want %d; body=%s", writer.Code, http.StatusUnauthorized, writer.Body.String()) } var response objectSyncAPIError if err := json.Unmarshal(writer.Body.Bytes(), &response); err != nil { t.Fatal(err) } if response.Code != "credential_required" { t.Fatalf("external object sync was blocked by the shared API token gate: %#v", response) } } func TestObjectSyncScopedCredentialPlansSpaceButRestrictsManifestPaths(t *testing.T) { scope := domain.ObjectSyncCredentialScope{ AllowedRelativePrefixes: []string{"camera one"}, Actions: []string{"plan", "create"}, } if !objectSyncScopeAllowsAction(scope, "plan") { t.Fatal("a prefix-scoped credential must be able to create a Space session") } if !objectSyncScopeAllows(scope, "create", "camera one/frame.mcap") { t.Fatal("an in-prefix manifest path was denied") } if objectSyncScopeAllows(scope, "create", "camera two/frame.mcap") { t.Fatal("an out-of-prefix manifest path was allowed") } } func TestObjectSyncSpaceStartsBlockedAndCannotBypassCapabilityGate(t *testing.T) { handler, _ := objectSyncTestHandler(t, true) create := objectSyncRequest(t, handler, http.MethodPost, "/api/object-sync/spaces", map[string]any{ "name": "Robot uploads", "connectionId": "bos-connection", "bucket": "robot-data", "rootPrefix": "incoming", }, "space-create") if create.Code != http.StatusCreated { t.Fatalf("status = %d; body=%s", create.Code, create.Body.String()) } var space domain.ObjectSyncSpaceRecord if err := json.Unmarshal(create.Body.Bytes(), &space); err != nil { t.Fatal(err) } if space.Enabled || space.Mode != "blocked" || space.Capability.State != domain.ObjectSyncCapabilityUnverified { t.Fatalf("space bypassed initial gate: %#v", space) } enable := objectSyncRequest(t, handler, http.MethodPut, "/api/object-sync/spaces/"+space.ID, map[string]any{ "enabled": true, }, "space-enable") if enable.Code != http.StatusConflict { t.Fatalf("status = %d, want conflict; body=%s", enable.Code, enable.Body.String()) } } func TestObjectSyncDriftStateCannotBeClearedBySettingsUpdate(t *testing.T) { handler, dataStore := objectSyncTestHandler(t, true) target, _ := store.AsObjectSyncStore(dataStore) policy := domain.DefaultObjectSyncSpacePolicy() policy.AllowConditionalUpdate = true policy.AllowForceOverwrite = true space := domain.ObjectSyncSpaceRecord{ ID: "space-drifted", OrganizationID: domain.DefaultOrganizationID, ConnectionID: "bos-connection", Bucket: "robot-data", Enabled: false, Mode: "blocked", Policy: policy, Capability: domain.ObjectSyncCapabilityRecord{ State: domain.ObjectSyncCapabilityDrifted, ConditionalCreate: true, ConditionalUpdate: true, ConditionalMultipart: true, ExclusivePrefixConfirmed: true, }, CreatedAt: "2026-07-28T08:00:00Z", UpdatedAt: "2026-07-28T08:00:00Z", } if err := target.UpsertObjectSyncSpace(t.Context(), space); err != nil { t.Fatal(err) } writer := objectSyncRequest(t, handler, http.MethodPut, "/api/object-sync/spaces/"+space.ID, map[string]any{ "name": "renamed but still drifted", "enabled": true, }, "drift-settings-update") if writer.Code != http.StatusConflict { t.Fatalf("status = %d; body=%s", writer.Code, writer.Body.String()) } stored, err := target.GetObjectSyncSpace(t.Context(), space.ID) if err != nil || stored == nil { t.Fatalf("stored space: %#v, %v", stored, err) } if stored.Capability.State != domain.ObjectSyncCapabilityDrifted || stored.Enabled { t.Fatalf("drift gate was bypassed: %#v", stored) } } func TestObjectSyncWritesRequireIdempotencyKey(t *testing.T) { handler, _ := objectSyncTestHandler(t, true) writer := objectSyncRequest(t, handler, http.MethodPost, "/api/object-sync/spaces", map[string]any{ "name": "Robot uploads", "connectionId": "bos-connection", "bucket": "robot-data", }, "") if writer.Code != http.StatusBadRequest { t.Fatalf("status = %d; body=%s", writer.Code, writer.Body.String()) } var response objectSyncAPIError if err := json.Unmarshal(writer.Body.Bytes(), &response); err != nil { t.Fatal(err) } if response.Code != "idempotency_key_required" { t.Fatalf("code = %q", response.Code) } } func TestObjectSyncIdempotencyReplaysCompletedResponse(t *testing.T) { handler, _ := objectSyncTestHandler(t, true) payload := map[string]any{ "name": "Robot uploads", "connectionId": "bos-connection", "bucket": "robot-data", } first := objectSyncRequest(t, handler, http.MethodPost, "/api/object-sync/spaces", payload, "replay-space") second := objectSyncRequest(t, handler, http.MethodPost, "/api/object-sync/spaces", payload, "replay-space") if first.Code != http.StatusCreated || second.Code != first.Code { t.Fatalf("statuses = %d, %d; first=%s second=%s", first.Code, second.Code, first.Body.String(), second.Body.String()) } if first.Body.String() != second.Body.String() { t.Fatalf("replayed response changed:\nfirst=%s\nsecond=%s", first.Body.String(), second.Body.String()) } if second.Header().Get("Idempotency-Replayed") != "true" { t.Fatalf("missing replay header: %#v", second.Header()) } } func TestObjectSyncIdempotencyRejectsKeyReuseWithDifferentPayload(t *testing.T) { handler, _ := objectSyncTestHandler(t, true) first := objectSyncRequest(t, handler, http.MethodPost, "/api/object-sync/spaces", map[string]any{ "name": "Robot uploads", "connectionId": "bos-connection", "bucket": "robot-data", }, "reused-space-key") if first.Code != http.StatusCreated { t.Fatalf("first status = %d; body=%s", first.Code, first.Body.String()) } second := objectSyncRequest(t, handler, http.MethodPost, "/api/object-sync/spaces", map[string]any{ "name": "Different uploads", "connectionId": "bos-connection", "bucket": "robot-data", }, "reused-space-key") if second.Code != http.StatusConflict { t.Fatalf("second status = %d; body=%s", second.Code, second.Body.String()) } var response objectSyncAPIError if err := json.Unmarshal(second.Body.Bytes(), &response); err != nil { t.Fatal(err) } if response.Code != "idempotency_key_reused" { t.Fatalf("code = %q", response.Code) } } func TestObjectSyncClientReleaseArtifactsAreImmutable(t *testing.T) { handler, dataStore := objectSyncTestHandler(t, true) target, _ := store.AsObjectSyncStore(dataStore) release := map[string]any{ "id": "drosync-1.0.0", "version": "1.0.0", "channel": "canary", "protocolVersion": "v1", "rolloutPercent": 5, "paused": false, "artifacts": map[string]string{"linux-x86_64": "https://downloads.example/drosync.deb"}, "sha256": map[string]string{"linux-x86_64": strings.Repeat("a", 64)}, "signature": "signed-manifest", } created := objectSyncRequest(t, handler, http.MethodPost, "/api/object-sync/client-releases", release, "release-create") if created.Code != http.StatusOK { t.Fatalf("status = %d; body=%s", created.Code, created.Body.String()) } items, err := target.ListObjectSyncClientReleases(t.Context()) if err != nil || len(items) != 1 { t.Fatalf("stored releases = %#v, %v", items, err) } items[0].StageChangedAt = time.Now().UTC().Add(-25 * time.Hour).Format(time.RFC3339Nano) if err := target.UpsertObjectSyncClientRelease(t.Context(), items[0]); err != nil { t.Fatal(err) } release["channel"] = "pilot" release["rolloutPercent"] = 20 advanced := objectSyncRequest(t, handler, http.MethodPost, "/api/object-sync/client-releases", release, "release-pilot") if advanced.Code != http.StatusOK { t.Fatalf("advance status = %d; body=%s", advanced.Code, advanced.Body.String()) } release["artifacts"] = map[string]string{"linux-x86_64": "https://attacker.example/replaced.deb"} rejected := objectSyncRequest(t, handler, http.MethodPost, "/api/object-sync/client-releases", release, "release-mutate") if rejected.Code != http.StatusConflict { t.Fatalf("mutation status = %d; body=%s", rejected.Code, rejected.Body.String()) } } func TestObjectSyncClientReleasePromotionRequiresObservationWindow(t *testing.T) { handler, _ := objectSyncTestHandler(t, true) release := map[string]any{ "id": "drosync-2.0.0", "version": "2.0.0", "channel": "canary", "protocolVersion": "v1", "rolloutPercent": 5, "paused": false, "artifacts": map[string]string{"linux-x86_64": "https://downloads.example/drosync.deb"}, "sha256": map[string]string{"linux-x86_64": strings.Repeat("b", 64)}, "signature": "signed-manifest", } created := objectSyncRequest(t, handler, http.MethodPost, "/api/object-sync/client-releases", release, "release-observe-create") if created.Code != http.StatusOK { t.Fatalf("create status = %d; body=%s", created.Code, created.Body.String()) } release["channel"] = "pilot" release["rolloutPercent"] = 20 promoted := objectSyncRequest(t, handler, http.MethodPost, "/api/object-sync/client-releases", release, "release-observe-promote") if promoted.Code != http.StatusConflict { t.Fatalf("promotion status = %d; body=%s", promoted.Code, promoted.Body.String()) } var response objectSyncAPIError if err := json.Unmarshal(promoted.Body.Bytes(), &response); err != nil { t.Fatal(err) } if response.Code != "rollout_observation_incomplete" { t.Fatalf("code = %q", response.Code) } } func TestObjectSyncPreviewReleaseIsDownloadOnly(t *testing.T) { handler, _ := objectSyncTestHandler(t, true) artifacts := map[string]string{} digests := map[string]string{} for _, platform := range objectSyncClientPlatforms { artifacts[platform] = "bos://bos-connection/robot-data/.drosync-internal/client-releases/" + platform digests[platform] = strings.Repeat("d", 64) } release := map[string]any{ "id": "drosync-preview-1.0.0-poc", "version": "1.0.0-poc", "kind": "preview", "channel": "preview", "protocolVersion": "v1", "rolloutPercent": 100, "paused": false, "artifacts": artifacts, "sha256": digests, "signature": "", } created := objectSyncRequest(t, handler, http.MethodPost, "/api/object-sync/client-releases", release, "preview-create") if created.Code != http.StatusOK { t.Fatalf("status = %d; body=%s", created.Code, created.Body.String()) } if strings.Contains(created.Body.String(), "bos://") || !strings.Contains(created.Body.String(), "/api/object-sync/client-releases/drosync-preview-1.0.0-poc/artifacts/macos-arm64") { t.Fatalf("preview response did not expose guarded download routes: %s", created.Body.String()) } item := domain.ObjectSyncClientReleaseRecord{ Kind: objectSyncReleasePreview, ProtocolVersion: domain.ObjectSyncProtocolVersion, RolloutPercent: 100, } if objectSyncClientReleaseCanAutoUpdate(item) { t.Fatal("preview releases must never enter automatic updates") } item.Kind = objectSyncReleaseSigned if !objectSyncClientReleaseCanAutoUpdate(item) { t.Fatal("active signed release should remain eligible for automatic updates") } } func TestObjectSyncPreviewReleaseRequiresEveryPlatform(t *testing.T) { handler, _ := objectSyncTestHandler(t, true) release := map[string]any{ "id": "drosync-preview-incomplete", "version": "1.0.0-poc", "kind": "preview", "channel": "preview", "protocolVersion": "v1", "rolloutPercent": 100, "paused": false, "artifacts": map[string]string{ "macos-arm64": "bos://bos-connection/robot-data/client.pkg", }, "sha256": map[string]string{ "macos-arm64": strings.Repeat("e", 64), }, "signature": "", } response := objectSyncRequest(t, handler, http.MethodPost, "/api/object-sync/client-releases", release, "preview-incomplete") if response.Code != http.StatusBadRequest { t.Fatalf("status = %d; body=%s", response.Code, response.Body.String()) } } func TestObjectSyncDeviceApprovalRoutesAreRemoved(t *testing.T) { handler, _ := objectSyncTestHandler(t, true) writer := objectSyncRequest(t, handler, http.MethodPost, "/api/external/object-sync/device-authorizations", map[string]any{ "deviceId": "device-01", "deviceName": "capture-station", "platform": "linux", "architecture": "x86_64", "clientVersion": "1.0.0", }, "pair-device") if writer.Code != http.StatusGone { t.Fatalf("status = %d; body=%s", writer.Code, writer.Body.String()) } var response objectSyncAPIError if err := json.Unmarshal(writer.Body.Bytes(), &response); err != nil { t.Fatal(err) } if response.Code != "device_approval_removed" { t.Fatalf("unexpected response: %#v", response) } lookup := objectSyncRequest(t, handler, http.MethodGet, "/api/object-sync/device-authorizations/by-code?userCode=ABCDEF", nil, "removed-lookup") if lookup.Code != http.StatusGone { t.Fatalf("lookup status = %d; body=%s", lookup.Code, lookup.Body.String()) } } func TestObjectSyncRemovedPairingStillUsesDistributedRateLimit(t *testing.T) { handler, _ := objectSyncTestHandler(t, true) for index := 0; index < 30; index++ { writer := objectSyncRequest(t, handler, http.MethodPost, "/api/external/object-sync/device-authorizations", map[string]any{ "deviceId": "rate-device", "deviceName": "rate-test", "platform": "linux", "architecture": "x86_64", }, "rate-pair-"+strconv.Itoa(index)) if writer.Code != http.StatusGone { t.Fatalf("request %d status = %d; body=%s", index+1, writer.Code, writer.Body.String()) } } blocked := objectSyncRequest(t, handler, http.MethodPost, "/api/external/object-sync/device-authorizations", map[string]any{ "deviceId": "rate-device", "deviceName": "rate-test", "platform": "linux", "architecture": "x86_64", }, "rate-pair-blocked") if blocked.Code != http.StatusTooManyRequests { t.Fatalf("status = %d, want %d; body=%s", blocked.Code, http.StatusTooManyRequests, blocked.Body.String()) } if blocked.Header().Get("Retry-After") == "" || blocked.Header().Get("RateLimit-Remaining") != "0" { t.Fatalf("missing rate limit headers: %#v", blocked.Header()) } } func TestObjectSyncAccessKeySecretLifecycle(t *testing.T) { handler, dataStore := objectSyncTestHandler(t, true) spaceResponse := objectSyncRequest(t, handler, http.MethodPost, "/api/object-sync/spaces", map[string]any{ "name": "Scoped key space", "connectionId": "bos-connection", "bucket": "robot-data", "rootPrefix": "acceptance/keys", }, "key-space-create") if spaceResponse.Code != http.StatusCreated { t.Fatalf("space status = %d; body=%s", spaceResponse.Code, spaceResponse.Body.String()) } var space domain.ObjectSyncSpaceRecord if err := json.Unmarshal(spaceResponse.Body.Bytes(), &space); err != nil { t.Fatal(err) } created := objectSyncRequest(t, handler, http.MethodPost, "/api/object-sync/credentials", map[string]any{ "name": "capture station key", "scopes": []map[string]any{{ "syncSpaceId": space.ID, "allowedRelativePrefixes": []string{"camera one"}, "actions": []string{"plan", "create"}, }}, }, "credential-create") if created.Code != http.StatusCreated { t.Fatalf("credential status = %d; body=%s", created.Code, created.Body.String()) } var issued struct { Credential domain.ObjectSyncCredentialRecord `json:"credential"` Secret string `json:"secret"` } if err := json.Unmarshal(created.Body.Bytes(), &issued); err != nil { t.Fatal(err) } if !strings.HasPrefix(issued.Credential.AccessKeyID, "dsk_") || !strings.HasPrefix(issued.Secret, "dss_") { t.Fatalf("unexpected issued key: %#v", issued) } if issued.Credential.SecretHash != "" || issued.Credential.TokenHash != "" || len(issued.Credential.TokenHashes) != 0 { t.Fatalf("credential response leaked hashes: %#v", issued.Credential) } target, _ := store.AsObjectSyncStore(dataStore) storedCredential, err := target.GetObjectSyncCredential(t.Context(), issued.Credential.ID) if err != nil || storedCredential == nil { t.Fatalf("stored credential = %#v, %v", storedCredential, err) } if !strings.HasPrefix(storedCredential.SecretHash, "$argon2id$") || strings.Contains(storedCredential.SecretHash, issued.Secret) { t.Fatalf("credential Secret was not stored as an Argon2id hash: %#v", storedCredential) } wrong := objectSyncRequest(t, handler, http.MethodPost, "/api/external/object-sync/auth/token", map[string]any{ "accessKeyId": issued.Credential.AccessKeyID, "secret": "dss_wrong", "deviceId": "device-key-test", }, "credential-auth-wrong") if wrong.Code != http.StatusUnauthorized { t.Fatalf("wrong secret status = %d; body=%s", wrong.Code, wrong.Body.String()) } authenticated := objectSyncRequest(t, handler, http.MethodPost, "/api/external/object-sync/auth/token", map[string]any{ "accessKeyId": issued.Credential.AccessKeyID, "secret": issued.Secret, "deviceId": "device-key-test", "deviceName": "acceptance mac", "platform": "macos", "architecture": "arm64", "clientVersion": "1.0.0", }, "credential-auth-correct") if authenticated.Code != http.StatusOK { t.Fatalf("auth status = %d; body=%s", authenticated.Code, authenticated.Body.String()) } var tokenResponse struct { AccessToken string `json:"accessToken"` } if err := json.Unmarshal(authenticated.Body.Bytes(), &tokenResponse); err != nil { t.Fatal(err) } if tokenResponse.AccessToken == "" { t.Fatal("access token was not returned") } request := httptest.NewRequest(http.MethodGet, "/api/external/object-sync/capabilities", nil) request.Header.Set("Idempotency-Key", "credential-capabilities") request.Header.Set(objectSyncCredentialHeader, tokenResponse.AccessToken) capabilities := httptest.NewRecorder() handler.ServeHTTP(capabilities, request) if capabilities.Code != http.StatusOK { t.Fatalf("capabilities status = %d; body=%s", capabilities.Code, capabilities.Body.String()) } storedSpace, err := target.GetObjectSyncSpace(t.Context(), space.ID) if err != nil || storedSpace == nil { t.Fatalf("stored space = %#v, %v", storedSpace, err) } storedSpace.Enabled = true storedSpace.Mode = "create_only" storedSpace.Capability.State = domain.ObjectSyncCapabilityCreateOnly storedSpace.Capability.ConditionalCreate = true if err := target.UpsertObjectSyncSpace(t.Context(), *storedSpace); err != nil { t.Fatal(err) } secondDeviceAuth := objectSyncRequest(t, handler, http.MethodPost, "/api/external/object-sync/auth/token", map[string]any{ "accessKeyId": issued.Credential.AccessKeyID, "secret": issued.Secret, "deviceId": "device-key-test-two", "deviceName": "second acceptance mac", "platform": "macos", "architecture": "arm64", "clientVersion": "1.0.0", }, "credential-auth-second-device") if secondDeviceAuth.Code != http.StatusOK { t.Fatalf("second device auth status = %d; body=%s", secondDeviceAuth.Code, secondDeviceAuth.Body.String()) } var secondTokenResponse struct { AccessToken string `json:"accessToken"` } if err := json.Unmarshal(secondDeviceAuth.Body.Bytes(), &secondTokenResponse); err != nil { t.Fatal(err) } secondSessionRequest := httptest.NewRequest( http.MethodPost, "/api/external/object-sync/sessions", strings.NewReader(`{"syncSpaceId":"`+space.ID+`","mappingId":"second-device","clientVersion":"1.0.0","protocolVersion":"v1"}`), ) secondSessionRequest.Header.Set("Content-Type", "application/json") secondSessionRequest.Header.Set("Idempotency-Key", "second-device-session") secondSessionRequest.Header.Set(objectSyncCredentialHeader, secondTokenResponse.AccessToken) secondSessionResponse := httptest.NewRecorder() handler.ServeHTTP(secondSessionResponse, secondSessionRequest) if secondSessionResponse.Code != http.StatusCreated { t.Fatalf("second device session status = %d; body=%s", secondSessionResponse.Code, secondSessionResponse.Body.String()) } var secondSession domain.ObjectSyncSessionRecord if err := json.Unmarshal(secondSessionResponse.Body.Bytes(), &secondSession); err != nil { t.Fatal(err) } if secondSession.DeviceID != "device-key-test-two" { t.Fatalf("bearer token was associated with the wrong device: %#v", secondSession) } listed := objectSyncRequest(t, handler, http.MethodGet, "/api/object-sync/credentials", nil, "credential-list") if listed.Code != http.StatusOK { t.Fatalf("list status = %d; body=%s", listed.Code, listed.Body.String()) } if strings.Contains(listed.Body.String(), issued.Secret) || strings.Contains(listed.Body.String(), "$argon2id$") { t.Fatalf("credential list leaked a secret or hash: %s", listed.Body.String()) } rotated := objectSyncRequest(t, handler, http.MethodPost, "/api/object-sync/credentials/"+issued.Credential.ID+"/rotate", map[string]any{}, "credential-rotate") if rotated.Code != http.StatusOK { t.Fatalf("rotate status = %d; body=%s", rotated.Code, rotated.Body.String()) } var rotatedResponse struct { Secret string `json:"secret"` } if err := json.Unmarshal(rotated.Body.Bytes(), &rotatedResponse); err != nil { t.Fatal(err) } if rotatedResponse.Secret == "" || rotatedResponse.Secret == issued.Secret { t.Fatalf("rotation did not return a new secret: %#v", rotatedResponse) } oldTokenRequest := httptest.NewRequest(http.MethodGet, "/api/external/object-sync/capabilities", nil) oldTokenRequest.Header.Set("Idempotency-Key", "credential-old-token") oldTokenRequest.Header.Set(objectSyncCredentialHeader, tokenResponse.AccessToken) oldTokenResponse := httptest.NewRecorder() handler.ServeHTTP(oldTokenResponse, oldTokenRequest) if oldTokenResponse.Code != http.StatusUnauthorized { t.Fatalf("old bearer token remained valid after rotation: %d; body=%s", oldTokenResponse.Code, oldTokenResponse.Body.String()) } } func TestObjectSyncDataOperatorOnlySeesAssignedSpacesAndSessions(t *testing.T) { dataStore := store.NewMemoryStore() handler := NewHandlerWithConfig(dataStore, nil, config.AppConfig{ RequireSessionAuth: true, ObjectSyncEnabled: true, }) rootCookie := bootstrapSuperAdminSession(t, handler) organization := adminCreateOrganization(t, handler, rootCookie, "Drosync tenant", "drosync-tenant") operatorA := adminCreateUser(t, handler, rootCookie, organization.ID, "Operator A", "drosync-a@example.com", domain.UserRoleDataOperator, "operator-a-password") operatorB := adminCreateUser(t, handler, rootCookie, organization.ID, "Operator B", "drosync-b@example.com", domain.UserRoleDataOperator, "operator-b-password") target, _ := store.AsObjectSyncStore(dataStore) now := nowISO() if err := target.UpsertObjectSyncClientRelease(t.Context(), domain.ObjectSyncClientReleaseRecord{ ID: "drosync-stable-download", Version: "1.0.0", Channel: "stable", ProtocolVersion: domain.ObjectSyncProtocolVersion, Artifacts: map[string]string{"macos-arm64": "https://downloads.example/drosync.pkg"}, SHA256: map[string]string{"macos-arm64": strings.Repeat("c", 64)}, Signature: "signed-manifest", RolloutPercent: 100, CreatedAt: now, StageChangedAt: now, }); err != nil { t.Fatal(err) } for _, space := range []domain.ObjectSyncSpaceRecord{ { ID: "space-assigned-a", OrganizationID: organization.ID, OperatorUserIDs: []string{operatorA.ID}, Name: "A only", ConnectionID: "connection-a", Bucket: "bucket-a", RootPrefix: "a", Mode: "create_only", Policy: domain.DefaultObjectSyncSpacePolicy(), CreatedAt: now, UpdatedAt: now, }, { ID: "space-assigned-b", OrganizationID: organization.ID, OperatorUserIDs: []string{operatorB.ID}, Name: "B only", ConnectionID: "connection-b", Bucket: "bucket-b", RootPrefix: "b", Mode: "create_only", Policy: domain.DefaultObjectSyncSpacePolicy(), CreatedAt: now, UpdatedAt: now, }, } { if err := target.UpsertObjectSyncSpace(t.Context(), space); err != nil { t.Fatal(err) } sessionCreatedAt := now if space.ID == "space-assigned-b" { sessionCreatedAt = time.Now().UTC().Add(time.Hour).Format(time.RFC3339Nano) } if err := target.UpsertObjectSyncSession(t.Context(), domain.ObjectSyncSessionRecord{ ID: "session-" + space.ID, OrganizationID: organization.ID, SyncSpaceID: space.ID, Status: domain.ObjectSyncSessionCompleted, CreatedAt: sessionCreatedAt, UpdatedAt: sessionCreatedAt, }); err != nil { t.Fatal(err) } } operatorCookie := loginSession(t, handler, operatorA.Email, "operator-a-password") spacesResponse := serveJSONWithCookie(handler, http.MethodGet, "/api/object-sync/spaces", nil, operatorCookie) if spacesResponse.Code != http.StatusOK { t.Fatalf("spaces status = %d; body=%s", spacesResponse.Code, spacesResponse.Body.String()) } if !strings.Contains(spacesResponse.Body.String(), "space-assigned-a") || strings.Contains(spacesResponse.Body.String(), "space-assigned-b") { t.Fatalf("space assignment was not enforced: %s", spacesResponse.Body.String()) } sessionsResponse := serveJSONWithCookie(handler, http.MethodGet, "/api/object-sync/sessions?limit=1", nil, operatorCookie) if sessionsResponse.Code != http.StatusOK { t.Fatalf("sessions status = %d; body=%s", sessionsResponse.Code, sessionsResponse.Body.String()) } if !strings.Contains(sessionsResponse.Body.String(), "session-space-assigned-a") || strings.Contains(sessionsResponse.Body.String(), "session-space-assigned-b") { t.Fatalf("session assignment was not inherited from the space: %s", sessionsResponse.Body.String()) } clientReleasesResponse := serveJSONWithCookie(handler, http.MethodGet, "/api/object-sync/client-releases", nil, operatorCookie) if clientReleasesResponse.Code != http.StatusOK { t.Fatalf("client releases status = %d; body=%s", clientReleasesResponse.Code, clientReleasesResponse.Body.String()) } if !strings.Contains(clientReleasesResponse.Body.String(), "drosync-stable-download") { t.Fatalf("stable client release was not available to data operator: %s", clientReleasesResponse.Body.String()) } } type resumableObjectSyncBrowser struct { *fakeObjectStorageBrowser initiateCalls int } func (browser *resumableObjectSyncBrowser) PutObjectConditional(ctx context.Context, bucket, key string, payload []byte, contentType, _, _ string, _ map[string]string) (domain.ObjectStorageObjectSummary, error) { return browser.PutObject(ctx, bucket, key, payload, contentType) } func (browser *resumableObjectSyncBrowser) PublishMultipartCopyConditional(_ context.Context, bucket, _, targetKey string, sizeBytes int64, _, _, _ string, _ map[string]string) (domain.ObjectStorageObjectSummary, error) { return domain.ObjectStorageObjectSummary{Bucket: bucket, Key: targetKey, SizeBytes: sizeBytes}, nil } func (browser *resumableObjectSyncBrowser) GetBucketVersioning(context.Context, string) (string, error) { return "", nil } func (browser *resumableObjectSyncBrowser) PresignPutObjectBound(ctx context.Context, bucket, key, contentType, _ string, _ int64, _ map[string]string, expires int) (domain.ObjectStoragePresignedUploadResult, error) { return browser.PresignPutObject(ctx, bucket, key, contentType, expires) } func (browser *resumableObjectSyncBrowser) InitiateMultipartUploadBound(ctx context.Context, bucket, key, contentType string, _ map[string]string, expires int) (domain.ObjectStorageMultipartUploadCreateResult, error) { browser.initiateCalls++ return browser.InitiateMultipartUpload(ctx, bucket, key, contentType, expires) } func (browser *resumableObjectSyncBrowser) PresignMultipartUploadPartBound(ctx context.Context, bucket, key, uploadID string, partNumber int, _ string, _ int64, expires int) (domain.ObjectStorageMultipartUploadPartURLResult, error) { return browser.PresignMultipartUploadPart(ctx, bucket, key, uploadID, partNumber, expires) } func (browser *resumableObjectSyncBrowser) CompleteMultipartUploadBound(ctx context.Context, bucket, key, uploadID string, parts []domain.ObjectStorageMultipartUploadPart, _ map[string]string) (domain.ObjectStorageObjectSummary, error) { return browser.CompleteMultipartUpload(ctx, bucket, key, uploadID, parts) } func TestObjectSyncMultipartInitiateResumesAndCheckpointsParts(t *testing.T) { handler, dataStore := objectSyncTestHandler(t, true) target, _ := store.AsObjectSyncStore(dataStore) browser := &resumableObjectSyncBrowser{fakeObjectStorageBrowser: newFakeObjectStorageBrowser()} originalResolver := storageConnectionBrowserResolver storageConnectionBrowserResolver = func(context.Context, *domain.StorageConnectionRecord) (objectStorageBrowser, func(), error) { return browser, func() {}, nil } t.Cleanup(func() { storageConnectionBrowserResolver = originalResolver }) now := nowISO() token := "multipart-device-token" space := domain.ObjectSyncSpaceRecord{ ID: "space-multipart-resume", OrganizationID: domain.DefaultOrganizationID, Name: "Multipart resume", ConnectionID: "bos-connection", Bucket: "datastorage", RootPrefix: "resume", Mode: "create_only", Enabled: true, Policy: domain.DefaultObjectSyncSpacePolicy(), Capability: domain.ObjectSyncCapabilityRecord{ State: domain.ObjectSyncCapabilityCreateOnly, ConditionalCreate: true, }, CreatedAt: now, UpdatedAt: now, } credential := domain.ObjectSyncCredentialRecord{ ID: "credential-multipart-resume", OrganizationID: domain.DefaultOrganizationID, DeviceID: "device-multipart-resume", Name: "multipart test", Enabled: true, TokenHash: sessionTokenHash(token), Scopes: []domain.ObjectSyncCredentialScope{{ SyncSpaceID: space.ID, AllowedRelativePrefixes: []string{""}, Actions: []string{"plan", "create", "keep_both"}, }}, CreatedAt: now, UpdatedAt: now, } device := domain.ObjectSyncDeviceRecord{ ID: credential.DeviceID, OrganizationID: domain.DefaultOrganizationID, Name: "multipart device", Status: "active", CreatedAt: now, UpdatedAt: now, } session := domain.ObjectSyncSessionRecord{ ID: "session-multipart-resume", OrganizationID: domain.DefaultOrganizationID, SyncSpaceID: space.ID, CredentialID: credential.ID, DeviceID: device.ID, Status: domain.ObjectSyncSessionRunning, PolicySnapshot: space.Policy, CreatedAt: now, UpdatedAt: now, } item := domain.ObjectSyncItemRecord{ ID: "item-multipart-resume", OrganizationID: domain.DefaultOrganizationID, SessionID: session.ID, RelativePath: "large.bin", TargetKey: "resume/large.bin", SizeBytes: 600 * 1024 * 1024, SHA256: strings.Repeat("a", 64), Status: domain.ObjectSyncItemReserved, StagingKey: ".drosync-internal/staging/resume/large.bin", CreatedAt: now, UpdatedAt: now, } if err := target.UpsertObjectSyncSpace(t.Context(), space); err != nil { t.Fatal(err) } if err := target.UpsertObjectSyncCredential(t.Context(), credential); err != nil { t.Fatal(err) } if err := target.UpsertObjectSyncDevice(t.Context(), device); err != nil { t.Fatal(err) } if err := target.UpsertObjectSyncSession(t.Context(), session); err != nil { t.Fatal(err) } if err := target.UpsertObjectSyncItems(t.Context(), []domain.ObjectSyncItemRecord{item}); err != nil { t.Fatal(err) } request := func(path string, payload any, idempotencyKey string) *httptest.ResponseRecorder { var body bytes.Buffer if payload != nil { if err := json.NewEncoder(&body).Encode(payload); err != nil { t.Fatal(err) } } httpRequest := httptest.NewRequest(http.MethodPost, path, &body) httpRequest.Header.Set("Content-Type", "application/json") httpRequest.Header.Set("Idempotency-Key", idempotencyKey) httpRequest.Header.Set(objectSyncCredentialHeader, token) response := httptest.NewRecorder() handler.ServeHTTP(response, httpRequest) return response } initiated := request("/api/external/object-sync/items/"+item.ID+"/uploads/multipart", map[string]any{}, "multipart-initiate-first") if initiated.Code != http.StatusCreated { t.Fatalf("initiate status = %d; body=%s", initiated.Code, initiated.Body.String()) } var first struct { UploadID string `json:"uploadId"` } if err := json.Unmarshal(initiated.Body.Bytes(), &first); err != nil { t.Fatal(err) } if first.UploadID == "" || browser.initiateCalls != 1 { t.Fatalf("unexpected first initiate: %#v calls=%d", first, browser.initiateCalls) } for _, part := range []map[string]any{ {"partNumber": 2, "eTag": "etag-two", "sizeBytes": 256 * 1024 * 1024}, {"partNumber": 1, "eTag": "etag-one", "sizeBytes": 256 * 1024 * 1024}, } { partNumber := part["partNumber"].(int) checkpoint := request("/api/external/object-sync/items/"+item.ID+"/uploads/multipart/parts", part, "multipart-checkpoint-"+strconv.Itoa(partNumber)) if checkpoint.Code != http.StatusOK { t.Fatalf("checkpoint %d status = %d; body=%s", partNumber, checkpoint.Code, checkpoint.Body.String()) } } resumed := request("/api/external/object-sync/items/"+item.ID+"/uploads/multipart", map[string]any{}, "multipart-initiate-resume") if resumed.Code != http.StatusOK { t.Fatalf("resume status = %d; body=%s", resumed.Code, resumed.Body.String()) } var resumeResponse struct { UploadID string `json:"uploadId"` UploadedParts []domain.ObjectStorageMultipartUploadPart `json:"uploadedParts"` Resumed bool `json:"resumed"` } if err := json.Unmarshal(resumed.Body.Bytes(), &resumeResponse); err != nil { t.Fatal(err) } if !resumeResponse.Resumed || resumeResponse.UploadID != first.UploadID || browser.initiateCalls != 1 { t.Fatalf("multipart upload was not resumed: %#v calls=%d", resumeResponse, browser.initiateCalls) } if len(resumeResponse.UploadedParts) != 2 || resumeResponse.UploadedParts[0].PartNumber != 1 || resumeResponse.UploadedParts[1].PartNumber != 2 { t.Fatalf("checkpointed parts were not persisted in order: %#v", resumeResponse.UploadedParts) } } func TestObjectSyncSessionsUseOpaqueCursorPagination(t *testing.T) { handler, dataStore := objectSyncTestHandler(t, true) target, _ := store.AsObjectSyncStore(dataStore) for _, id := range []string{"session-a", "session-b", "session-c"} { if err := target.UpsertObjectSyncSession(t.Context(), domain.ObjectSyncSessionRecord{ ID: id, OrganizationID: domain.DefaultOrganizationID, Status: domain.ObjectSyncSessionRunning, CreatedAt: "2026-07-28T08:00:00Z", UpdatedAt: "2026-07-28T08:00:00Z", }); err != nil { t.Fatal(err) } } first := objectSyncRequest(t, handler, http.MethodGet, "/api/object-sync/sessions?limit=2", nil, "") if first.Code != http.StatusOK { t.Fatalf("first status = %d; body=%s", first.Code, first.Body.String()) } var firstPage domain.ObjectSyncSessionPage if err := json.Unmarshal(first.Body.Bytes(), &firstPage); err != nil { t.Fatal(err) } if len(firstPage.Items) != 2 || firstPage.NextCursor == "" || strings.Contains(firstPage.NextCursor, "session-") { t.Fatalf("unexpected first page: %#v", firstPage) } second := objectSyncRequest(t, handler, http.MethodGet, "/api/object-sync/sessions?limit=2&cursor="+firstPage.NextCursor, nil, "") if second.Code != http.StatusOK { t.Fatalf("second status = %d; body=%s", second.Code, second.Body.String()) } var secondPage domain.ObjectSyncSessionPage if err := json.Unmarshal(second.Body.Bytes(), &secondPage); err != nil { t.Fatal(err) } if len(secondPage.Items) != 1 || secondPage.NextCursor != "" { t.Fatalf("unexpected second page: %#v", secondPage) } } func TestObjectSyncForceOverwriteQueuesSeparateAuditedItem(t *testing.T) { handler, dataStore := objectSyncTestHandler(t, true) target, _ := store.AsObjectSyncStore(dataStore) policy := domain.DefaultObjectSyncSpacePolicy() policy.AllowConditionalUpdate = true policy.AllowForceOverwrite = true space := domain.ObjectSyncSpaceRecord{ ID: "space-force", OrganizationID: domain.DefaultOrganizationID, ConnectionID: "bos-connection", Bucket: "robot-data", Enabled: true, Mode: "update_enabled", Policy: policy, Capability: domain.ObjectSyncCapabilityRecord{ State: domain.ObjectSyncCapabilityUpdateEnabled, ConditionalCreate: true, ConditionalUpdate: true, ConditionalMultipart: true, ExclusivePrefixConfirmed: true, }, CreatedAt: "2026-07-28T08:00:00Z", UpdatedAt: "2026-07-28T08:00:00Z", } if err := target.UpsertObjectSyncSpace(t.Context(), space); err != nil { t.Fatal(err) } session := domain.ObjectSyncSessionRecord{ ID: "session-force", OrganizationID: domain.DefaultOrganizationID, SyncSpaceID: space.ID, Status: domain.ObjectSyncSessionConflicted, CreatedAt: "2026-07-28T08:00:00Z", UpdatedAt: "2026-07-28T08:00:00Z", } if err := target.UpsertObjectSyncSession(t.Context(), session); err != nil { t.Fatal(err) } conflict := domain.ObjectSyncItemRecord{ ID: "item-conflict", OrganizationID: domain.DefaultOrganizationID, SessionID: session.ID, ClientItemID: "client-conflict", TargetKey: "incoming/file.bin.__conflict__20260728T000000Z_source", LogicalTargetKey: "incoming/file.bin", SizeBytes: 4, SHA256: "abcd", Status: domain.ObjectSyncItemKeptBoth, CreatedAt: "2026-07-28T08:00:00Z", UpdatedAt: "2026-07-28T08:00:00Z", } if err := target.UpsertObjectSyncItems(t.Context(), []domain.ObjectSyncItemRecord{conflict}); err != nil { t.Fatal(err) } writer := objectSyncRequest(t, handler, http.MethodPost, "/api/object-sync/items/"+conflict.ID+"/force-overwrite", map[string]any{}, "force-overwrite") if writer.Code != http.StatusAccepted { t.Fatalf("status = %d; body=%s", writer.Code, writer.Body.String()) } page, err := target.ListObjectSyncItems(t.Context(), domain.ObjectSyncListQuery{SessionID: session.ID, Limit: 10}) if err != nil { t.Fatal(err) } if len(page.Items) != 2 { t.Fatalf("items = %#v", page.Items) } original, err := target.GetObjectSyncItem(t.Context(), conflict.ID) if err != nil || original == nil || original.Status != domain.ObjectSyncItemKeptBoth { t.Fatalf("original conflict was mutated: %#v, %v", original, err) } var queued *domain.ObjectSyncItemRecord for index := range page.Items { if page.Items[index].ID != conflict.ID { queued = &page.Items[index] } } if queued == nil || queued.Action != "force_overwrite" || queued.ForceSourceKey != conflict.TargetKey || queued.Status != domain.ObjectSyncItemCommitting { t.Fatalf("queued force item = %#v", queued) } } func TestObjectSyncReleaseRejectsSessionsAcrossSpaces(t *testing.T) { handler, dataStore := objectSyncTestHandler(t, true) target, _ := store.AsObjectSyncStore(dataStore) for index, spaceID := range []string{"space-a", "space-b"} { if err := target.UpsertObjectSyncSession(t.Context(), domain.ObjectSyncSessionRecord{ ID: "release-session-" + strconv.Itoa(index), OrganizationID: domain.DefaultOrganizationID, SyncSpaceID: spaceID, Status: domain.ObjectSyncSessionCompleted, CreatedAt: "2026-07-28T08:00:00Z", UpdatedAt: "2026-07-28T08:00:00Z", }); err != nil { t.Fatal(err) } } writer := objectSyncRequest(t, handler, http.MethodPost, "/api/object-sync/releases", map[string]any{ "name": "ambiguous-release", "sessionIds": []string{"release-session-0", "release-session-1"}, }, "release-cross-space") if writer.Code != http.StatusConflict { t.Fatalf("status = %d; body=%s", writer.Code, writer.Body.String()) } var response objectSyncAPIError if err := json.Unmarshal(writer.Body.Bytes(), &response); err != nil { t.Fatal(err) } if response.Code != "release_space_mismatch" { t.Fatalf("code = %q", response.Code) } }