forked from longtao.wu/droboticflow
101 lines
4.8 KiB
Go
101 lines
4.8 KiB
Go
package api
|
|
|
|
import (
|
|
"bytes"
|
|
"droboticflow/internal/domain"
|
|
"droboticflow/internal/store"
|
|
"net/http"
|
|
"net/http/httptest"
|
|
"testing"
|
|
"time"
|
|
)
|
|
|
|
func TestObjectSyncAbortReleasesLeaseAndRejectsClosedOperations(t *testing.T) {
|
|
t.Run("device", func(t *testing.T) {
|
|
handler, data := objectSyncTestHandler(t, true)
|
|
target, _ := store.AsObjectSyncStore(data)
|
|
ctx := t.Context()
|
|
org := domain.DefaultOrganizationID
|
|
token := "abort-test-token"
|
|
space := domain.ObjectSyncSpaceRecord{ID: "abort-space", OrganizationID: org, ConnectionID: "bos-connection", Bucket: "test", Enabled: true, Mode: "create_only", Policy: domain.DefaultObjectSyncSpacePolicy(), Capability: domain.ObjectSyncCapabilityRecord{State: domain.ObjectSyncCapabilityCreateOnly, ConditionalCreate: true}}
|
|
cred := domain.ObjectSyncCredentialRecord{ID: "abort-credential", OrganizationID: org, Enabled: true, TokenBindings: []domain.ObjectSyncCredentialTokenBinding{{TokenHash: sessionTokenHash(token), DeviceID: "abort-device"}}, Scopes: []domain.ObjectSyncCredentialScope{{SyncSpaceID: space.ID, AllowedRelativePrefixes: []string{""}, Actions: []string{"plan", "create"}}}}
|
|
must := func(err error) {
|
|
t.Helper()
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
}
|
|
must(target.UpsertObjectSyncSpace(ctx, space))
|
|
must(target.UpsertObjectSyncCredential(ctx, cred))
|
|
must(target.UpsertObjectSyncDevice(ctx, domain.ObjectSyncDeviceRecord{ID: "abort-device", OrganizationID: org, Status: "active"}))
|
|
session := domain.ObjectSyncSessionRecord{ID: "abort-session", OrganizationID: org, SyncSpaceID: space.ID, CredentialID: cred.ID, DeviceID: "abort-device", Status: domain.ObjectSyncSessionRunning}
|
|
must(target.UpsertObjectSyncSession(ctx, session))
|
|
lease, ok, err := target.AcquireObjectSyncLease(ctx, domain.ObjectSyncLeaseRecord{ID: "abort-lease", OrganizationID: org, ResourceHash: "abort-resource", OwnerSessionID: session.ID, OwnerItemID: "abort-item"}, time.Minute)
|
|
must(err)
|
|
if !ok {
|
|
t.Fatal("lease not acquired")
|
|
}
|
|
item := domain.ObjectSyncItemRecord{ID: "abort-item", OrganizationID: org, SessionID: session.ID, Status: domain.ObjectSyncItemUploading, LeaseID: lease.ID, FencingToken: lease.FencingToken}
|
|
committed := domain.ObjectSyncItemRecord{ID: "committed-item", OrganizationID: org, SessionID: session.ID, Status: domain.ObjectSyncItemCommitted}
|
|
must(target.UpsertObjectSyncItems(ctx, []domain.ObjectSyncItemRecord{item, committed}))
|
|
request := func(path, key string) *httptest.ResponseRecorder {
|
|
r := httptest.NewRequest(http.MethodPost, path, bytes.NewBufferString("{}"))
|
|
r.Header.Set("Content-Type", "application/json")
|
|
r.Header.Set("Idempotency-Key", key)
|
|
r.Header.Set(objectSyncCredentialHeader, token)
|
|
w := httptest.NewRecorder()
|
|
handler.ServeHTTP(w, r)
|
|
return w
|
|
}
|
|
abortPath := "/api/external/object-sync/sessions/" + session.ID + "/abort"
|
|
w := request(abortPath, "abort-first")
|
|
if w.Code != 200 {
|
|
t.Fatalf("abort %d %s", w.Code, w.Body.String())
|
|
}
|
|
got, _ := target.GetObjectSyncItem(ctx, item.ID)
|
|
if got.Status != domain.ObjectSyncItemAborted {
|
|
t.Fatalf("item status %s", got.Status)
|
|
}
|
|
saved, _ := target.GetObjectSyncItem(ctx, committed.ID)
|
|
if saved.Status != domain.ObjectSyncItemCommitted {
|
|
t.Fatal("committed item changed")
|
|
}
|
|
next, acquired, err := target.AcquireObjectSyncLease(ctx, domain.ObjectSyncLeaseRecord{ID: lease.ID, OrganizationID: org, ResourceHash: lease.ResourceHash, OwnerSessionID: "next-session", OwnerItemID: "next-item"}, time.Minute)
|
|
must(err)
|
|
if !acquired || next.FencingToken <= lease.FencingToken {
|
|
t.Fatal("lease not released / fencing not increased")
|
|
}
|
|
for _, action := range []string{"heartbeat", "reserve", "commit"} {
|
|
w = request("/api/external/object-sync/items/"+item.ID+"/"+action, "closed-"+action)
|
|
if w.Code != 409 {
|
|
t.Fatalf("%s status %d %s", action, w.Code, w.Body.String())
|
|
}
|
|
}
|
|
w = request(abortPath, "abort-repeat")
|
|
if w.Code != 200 {
|
|
t.Fatalf("repeat abort %d", w.Code)
|
|
}
|
|
renewed, err := target.RenewObjectSyncLease(ctx, next.ID, "next-session", "next-item", next.FencingToken, time.Minute)
|
|
must(err)
|
|
if !renewed {
|
|
t.Fatal("repeat abort released new owner's lease")
|
|
}
|
|
w = request("/api/external/object-sync/sessions/"+session.ID+"/complete", "closed-complete")
|
|
if w.Code != 409 {
|
|
t.Fatalf("closed complete %d", w.Code)
|
|
}
|
|
})
|
|
}
|
|
|
|
func TestRetiredAdminAbortEntryIsUnavailable(t *testing.T) {
|
|
handler, _ := objectSyncTestHandler(t, true)
|
|
request := httptest.NewRequest(http.MethodPost, "/api/object-sync/sessions/session/admin-abort", bytes.NewBufferString("{}"))
|
|
request.Header.Set("Content-Type", "application/json")
|
|
request.Header.Set("Idempotency-Key", "retired-admin-abort")
|
|
response := httptest.NewRecorder()
|
|
handler.ServeHTTP(response, request)
|
|
if response.Code != http.StatusNotFound {
|
|
t.Fatalf("retired admin-abort = %d, want 404", response.Code)
|
|
}
|
|
}
|