package objectgateway import ( "context" "errors" "testing" ) type fakeBackend struct { byID map[string]Version latest Version latestExists bool latestErr error putVersion Version putErr error putCalls int deletes []string deleteErr error } func (f *fakeBackend) Ready(context.Context) error { return nil } func (f *fakeBackend) Observe(_ context.Context, _ string, id string) (Version, bool, error) { if id == "" { if f.latestErr != nil { return Version{}, false, f.latestErr } return f.latest, f.latestExists, nil } v, ok := f.byID[id] return v, ok, nil } func (f *fakeBackend) List(context.Context, string) ([]Version, error) { return nil, nil } func (f *fakeBackend) Put(context.Context, string, []byte, string) (Version, error) { f.putCalls++ if f.putErr != nil { return Version{}, f.putErr } return f.putVersion, nil } func (f *fakeBackend) Delete(_ context.Context, _ string, v Version) error { if f.deleteErr != nil { return f.deleteErr } f.deletes = append(f.deletes, v.ID) delete(f.byID, v.ID) return nil } func createFixture(t *testing.T) (Request, Version) { t.Helper() body := []byte("shared bucket object") grant := Grant{Epoch: 1, Owner: Digest([]byte("owner")), Plan: Digest([]byte("plan"))} r := Request{Grant: grant, Operation: Digest([]byte("operation")), Key: "kb/bound/object-1", Action: "create", SHA256: Digest(body), Bytes: int64(len(body))} v := Version{ID: "version-own", Owner: r.token(), SHA256: r.SHA256, Bytes: r.Bytes, ETag: `"etag-own"`} return r, v } func TestCreateConfirmationDetectsNewerForeignVersionWithoutSideEffects(t *testing.T) { r, own := createFixture(t) foreign := Version{ID: "version-foreign", Owner: Digest([]byte("foreign-owner")), SHA256: Digest([]byte("foreign")), Bytes: 7, ETag: `"etag-foreign"`} f := &fakeBackend{byID: map[string]Version{own.ID: own, foreign.ID: foreign}, latest: foreign, latestExists: true, putVersion: own} if _, err := confirmCreate(context.Background(), f, r, own); !errors.Is(err, ErrConflict) { t.Fatalf("concurrent newer version accepted as committed: %v", err) } // Confirmation runs after the journal intent exists. Deleting here would be // an unrecorded mutation with no delete intent/receipt and would strand the // create intent in held forever, so confirmation must be read-only. if len(f.deletes) != 0 { t.Fatalf("confirmation deleted without a delete intent/receipt: %v", f.deletes) } if _, ok := f.byID[own.ID]; !ok { t.Fatal("own version removed without a recorded delete") } if _, ok := f.byID[foreign.ID]; !ok { t.Fatal("foreign version was deleted") } } func TestCreateConfirmationCommitsOnlyWhenOwnVersionIsCurrent(t *testing.T) { r, own := createFixture(t) f := &fakeBackend{byID: map[string]Version{own.ID: own}, latest: own, latestExists: true, putVersion: own} got, err := confirmCreate(context.Background(), f, r, own) if err != nil || got != own { t.Fatalf("own current version not committed: %v %v", got, err) } if len(f.deletes) != 0 { t.Fatalf("unexpected rollback %v", f.deletes) } } func TestCreateConfirmationHoldsWithoutDeletingWhenCurrentVersionUnreadable(t *testing.T) { r, own := createFixture(t) f := &fakeBackend{byID: map[string]Version{own.ID: own}, putVersion: own, latestErr: errors.New("read failed")} if _, err := confirmCreate(context.Background(), f, r, own); !errors.Is(err, ErrHeld) { t.Fatalf("unreadable current version treated as terminal: %v", err) } if len(f.deletes) != 0 { t.Fatalf("deleted on an unknown observation: %v", f.deletes) } } func TestCreateConfirmationHoldsOnExactReadbackMismatch(t *testing.T) { r, own := createFixture(t) other := own other.ETag = `"different"` f := &fakeBackend{byID: map[string]Version{own.ID: other}, latest: other, latestExists: true, putVersion: own} if _, err := confirmCreate(context.Background(), f, r, own); !errors.Is(err, ErrHeld) { t.Fatalf("mismatched readback treated as committed: %v", err) } if len(f.deletes) != 0 { t.Fatalf("deleted on mismatch: %v", f.deletes) } } func TestCreateSendIsSingleAttemptAndNeverDeletesUnknownPut(t *testing.T) { r, _ := createFixture(t) f := &fakeBackend{putErr: errors.New("transport lost")} if _, err := sendCreate(context.Background(), f, r, []byte("shared bucket object")); !errors.Is(err, ErrHeld) { t.Fatalf("unknown PUT treated as terminal: %v", err) } if f.putCalls != 1 { t.Fatalf("PUT retried: calls=%d", f.putCalls) } if len(f.deletes) != 0 { t.Fatalf("deleted without a confirmed version: %v", f.deletes) } } func TestPlanAuthorizesOnlyFrozenObjectList(t *testing.T) { body := []byte("planned") owner, digest := Digest([]byte("owner")), Digest([]byte("plan-digest")) p := Plan{Digest: digest, Owner: owner, Objects: []ObjectBinding{{Operation: Digest([]byte("op-1")), Key: "kb/allowed/1", SHA256: Digest(body), Bytes: int64(len(body))}}} allowed := Request{Grant: Grant{1, owner, digest}, Operation: Digest([]byte("op-1")), Key: "kb/allowed/1", Action: "create", SHA256: Digest(body), Bytes: int64(len(body))} if !p.allows(allowed) { t.Fatal("frozen object rejected") } for name, mutate := range map[string]func(*Request){ "other_kb_key": func(r *Request) { r.Key = "kb/other-kb/1" }, "other_object": func(r *Request) { r.Key = "kb/allowed/2" }, "other_operation": func(r *Request) { r.Operation = Digest([]byte("op-2")) }, } { got := allowed mutate(&got) if p.allows(got) { t.Fatalf("%s authorized outside the frozen write set", name) } } dup := p dup.Objects = append(dup.Objects, p.Objects[0]) if dup.valid() { t.Fatal("duplicate key accepted in plan") } }