droboticflow/internal/api/object_sync_closure_test.go

350 lines
16 KiB
Go

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)
}
}
}