| package account |
|
|
| import ( |
| "context" |
| "errors" |
| "path/filepath" |
| "strings" |
| "testing" |
| "time" |
|
|
| accountdomain "github.com/chenyme/grok2api/backend/internal/domain/account" |
| "github.com/chenyme/grok2api/backend/internal/infra/persistence/relational" |
| "github.com/chenyme/grok2api/backend/internal/repository" |
| ) |
|
|
| func TestBatchDeleteWithLinkedRemovesPeersAndKeepsUntargetedWeb(t *testing.T) { |
| t.Parallel() |
| ctx := context.Background() |
| repo, service := newLinkedDeleteTestService(t, "svc-linked-delete.db") |
| web, build, console := seedLinkedTrio(t, repo, strings.Repeat("1", 64), "u1") |
|
|
| result, err := service.BatchDeleteWithLinked(ctx, accountdomain.ProviderBuild, []uint64{build.ID}, []accountdomain.Provider{accountdomain.ProviderConsole}) |
| if err != nil { |
| t.Fatal(err) |
| } |
| if result.Deleted != 2 || result.LinkedDeleted != 1 { |
| t.Fatalf("result = %#v", result) |
| } |
| assertAccountMissing(t, repo, build.ID) |
| assertAccountMissing(t, repo, console.ID) |
| assertAccountPresent(t, repo, web.ID) |
|
|
| web2 := mustUpsertLinked(t, repo, accountdomain.Credential{ |
| Provider: accountdomain.ProviderWeb, AuthType: accountdomain.AuthTypeSSO, Name: "web2", SourceKey: "sso:" + strings.Repeat("2", 64), |
| }) |
| deleted, err := service.BatchDelete(ctx, []uint64{web2.ID}) |
| if err != nil || deleted != 1 { |
| t.Fatalf("legacy batch delete deleted=%d err=%v", deleted, err) |
| } |
| } |
|
|
| func TestBatchDeleteWithLinkedWebDeletesBuildAndConsole(t *testing.T) { |
| t.Parallel() |
| ctx := context.Background() |
| repo, service := newLinkedDeleteTestService(t, "svc-linked-delete-web.db") |
| web, build, console := seedLinkedTrio(t, repo, strings.Repeat("a", 64), "u-web") |
|
|
| result, err := service.BatchDeleteWithLinked(ctx, accountdomain.ProviderWeb, []uint64{web.ID}, []accountdomain.Provider{accountdomain.ProviderBuild, accountdomain.ProviderConsole}) |
| if err != nil { |
| t.Fatal(err) |
| } |
| if result.Deleted != 3 || result.RootsDeleted != 1 || result.LinkedDeleted != 2 { |
| t.Fatalf("result = %#v", result) |
| } |
| assertAccountMissing(t, repo, web.ID) |
| assertAccountMissing(t, repo, build.ID) |
| assertAccountMissing(t, repo, console.ID) |
| } |
|
|
| func TestBatchDeleteWithLinkedMixedBatchOnlyExpandsLinkedRoots(t *testing.T) { |
| t.Parallel() |
| ctx := context.Background() |
| repo, service := newLinkedDeleteTestService(t, "svc-linked-delete-mix.db") |
| webLinked, _, console := seedLinkedTrio(t, repo, strings.Repeat("b", 64), "u-mix") |
| webOnly := mustUpsertLinked(t, repo, accountdomain.Credential{ |
| Provider: accountdomain.ProviderWeb, AuthType: accountdomain.AuthTypeSSO, Name: "web-only", SourceKey: "sso:" + strings.Repeat("c", 64), |
| }) |
|
|
| result, err := service.BatchDeleteWithLinked(ctx, accountdomain.ProviderWeb, []uint64{webLinked.ID, webOnly.ID}, []accountdomain.Provider{accountdomain.ProviderConsole}) |
| if err != nil { |
| t.Fatal(err) |
| } |
| if result.Deleted != 3 { |
| t.Fatalf("result = %#v", result) |
| } |
| assertAccountMissing(t, repo, webLinked.ID) |
| assertAccountMissing(t, repo, webOnly.ID) |
| assertAccountMissing(t, repo, console.ID) |
| } |
|
|
| func TestPreviewLinkedDeleteCountsWithoutDeleting(t *testing.T) { |
| t.Parallel() |
| ctx := context.Background() |
| repo, service := newLinkedDeleteTestService(t, "svc-linked-preview.db") |
| web, build, console := seedLinkedTrio(t, repo, strings.Repeat("d", 64), "u-prev") |
|
|
| res, err := service.PreviewLinkedDelete(ctx, accountdomain.ProviderWeb, []uint64{web.ID}, []accountdomain.Provider{accountdomain.ProviderBuild, accountdomain.ProviderConsole}) |
| if err != nil { |
| t.Fatal(err) |
| } |
| if len(res.RootIDs) != 1 || res.LinkedByProvider[accountdomain.ProviderBuild] != 1 || res.LinkedByProvider[accountdomain.ProviderConsole] != 1 || len(res.FinalIDs) != 3 { |
| t.Fatalf("preview = %#v", res) |
| } |
| assertAccountPresent(t, repo, web.ID) |
| assertAccountPresent(t, repo, build.ID) |
| assertAccountPresent(t, repo, console.ID) |
| } |
|
|
| func TestBatchDeleteWithLinkedEmptyTargetsDeletesRootOnly(t *testing.T) { |
| t.Parallel() |
| ctx := context.Background() |
| repo, service := newLinkedDeleteTestService(t, "svc-linked-empty-targets.db") |
| web, build, console := seedLinkedTrio(t, repo, strings.Repeat("e", 64), "u-empty") |
|
|
| result, err := service.BatchDeleteWithLinked(ctx, accountdomain.ProviderWeb, []uint64{web.ID}, nil) |
| if err != nil { |
| t.Fatal(err) |
| } |
| if result.Deleted != 1 || result.LinkedDeleted != 0 { |
| t.Fatalf("result = %#v", result) |
| } |
| assertAccountMissing(t, repo, web.ID) |
| assertAccountPresent(t, repo, build.ID) |
| assertAccountPresent(t, repo, console.ID) |
| } |
|
|
| func TestBatchDeleteWithLinkedInvalidTarget(t *testing.T) { |
| t.Parallel() |
| ctx := context.Background() |
| repo, service := newLinkedDeleteTestService(t, "svc-linked-bad-target.db") |
| web, _, _ := seedLinkedTrio(t, repo, strings.Repeat("f", 64), "u-bad") |
|
|
| if _, err := service.BatchDeleteWithLinked(ctx, accountdomain.ProviderWeb, []uint64{web.ID}, []accountdomain.Provider{accountdomain.Provider("nope")}); err == nil { |
| t.Fatal("expected invalid target error") |
| } |
| if _, err := service.BatchDeleteWithLinked(ctx, accountdomain.ProviderWeb, []uint64{web.ID}, []accountdomain.Provider{accountdomain.ProviderWeb}); err == nil { |
| t.Fatal("expected self-target error") |
| } |
| assertAccountPresent(t, repo, web.ID) |
| } |
|
|
| func TestDeleteMissingAccountReturnsNotFound(t *testing.T) { |
| t.Parallel() |
| ctx := context.Background() |
| _, service := newLinkedDeleteTestService(t, "svc-delete-missing.db") |
|
|
| if err := service.Delete(ctx, 9_999_999); !errors.Is(err, ErrNotFound) { |
| t.Fatalf("Delete missing: err=%v", err) |
| } |
| if _, err := service.DeleteWithLinked(ctx, accountdomain.ProviderWeb, 9_999_999, []accountdomain.Provider{accountdomain.ProviderBuild}); !errors.Is(err, ErrNotFound) { |
| t.Fatalf("DeleteWithLinked missing: err=%v", err) |
| } |
| } |
|
|
| func TestDeleteWithLinkedRejectsRootFromAnotherProvider(t *testing.T) { |
| t.Parallel() |
| ctx := context.Background() |
| repo, service := newLinkedDeleteTestService(t, "svc-delete-provider-mismatch.db") |
| web, _, _ := seedLinkedTrio(t, repo, strings.Repeat("9", 64), "u-provider-mismatch") |
|
|
| _, err := service.DeleteWithLinked(ctx, accountdomain.ProviderBuild, web.ID, []accountdomain.Provider{accountdomain.ProviderConsole}) |
| if !errors.Is(err, ErrConflict) { |
| t.Fatalf("provider mismatch error = %v", err) |
| } |
| assertAccountPresent(t, repo, web.ID) |
| } |
|
|
| func TestFinishLinkedDeleteUsesBatchStickyCleanup(t *testing.T) { |
| sticky := &stickyBatchStub{} |
| service := &Service{sticky: sticky} |
| service.finishLinkedDelete(context.Background(), []uint64{3, 5, 8}) |
| if sticky.singleCalls != 0 { |
| t.Fatalf("single-account cleanup calls = %d", sticky.singleCalls) |
| } |
| if len(sticky.batchCalls) != 1 || len(sticky.batchCalls[0]) != 3 || sticky.batchCalls[0][0] != 3 || sticky.batchCalls[0][2] != 8 { |
| t.Fatalf("batch cleanup calls = %#v", sticky.batchCalls) |
| } |
| } |
|
|
| func newLinkedDeleteTestService(t *testing.T, dbName string) (*relational.AccountRepository, *Service) { |
| t.Helper() |
| ctx := context.Background() |
| database, err := relational.OpenSQLite(ctx, filepath.Join(t.TempDir(), dbName)) |
| if err != nil { |
| t.Fatal(err) |
| } |
| t.Cleanup(func() { _ = database.Close() }) |
| if err := database.InitializeSchema(ctx); err != nil { |
| t.Fatal(err) |
| } |
| repo := relational.NewAccountRepository(database) |
| return repo, &Service{accounts: repo, sticky: stickyStub{}, logger: nil} |
| } |
|
|
| func seedLinkedTrio(t *testing.T, repo *relational.AccountRepository, digest, userID string) (web, build, console accountdomain.Credential) { |
| t.Helper() |
| ctx := context.Background() |
| web = mustUpsertLinked(t, repo, accountdomain.Credential{ |
| Provider: accountdomain.ProviderWeb, AuthType: accountdomain.AuthTypeSSO, Name: "web", SourceKey: "sso:" + digest, UserID: userID, |
| }) |
| build = mustUpsertLinked(t, repo, accountdomain.Credential{ |
| Provider: accountdomain.ProviderBuild, AuthType: accountdomain.AuthTypeOAuth, Name: "build", SourceKey: "build-" + digest[:8], UserID: userID, |
| }) |
| console = mustUpsertLinked(t, repo, accountdomain.Credential{ |
| Provider: accountdomain.ProviderConsole, AuthType: accountdomain.AuthTypeSSO, Name: "console", SourceKey: "console-sso:" + digest, UserID: userID, |
| }) |
| if err := repo.LinkWebToBuild(ctx, web.ID, build.ID); err != nil { |
| t.Fatal(err) |
| } |
| if err := repo.ReconcileProviderLinks(ctx, web.ID); err != nil { |
| t.Fatal(err) |
| } |
| return web, build, console |
| } |
|
|
| func mustUpsertLinked(t *testing.T, repo *relational.AccountRepository, value accountdomain.Credential) accountdomain.Credential { |
| t.Helper() |
| value.EncryptedAccessToken = "encrypted" |
| value.Enabled = true |
| value.AuthStatus = accountdomain.AuthStatusActive |
| value.Priority = accountdomain.DefaultPriority |
| value.MaxConcurrent = accountdomain.DefaultMaxConcurrent |
| stored, _, err := repo.UpsertByIdentity(context.Background(), value) |
| if err != nil { |
| t.Fatal(err) |
| } |
| return stored |
| } |
|
|
| func assertAccountMissing(t *testing.T, repo *relational.AccountRepository, id uint64) { |
| t.Helper() |
| if _, err := repo.Get(context.Background(), id); !errors.Is(err, repository.ErrNotFound) { |
| t.Fatalf("account %d should be missing, err=%v", id, err) |
| } |
| } |
|
|
| func assertAccountPresent(t *testing.T, repo *relational.AccountRepository, id uint64) { |
| t.Helper() |
| if _, err := repo.Get(context.Background(), id); err != nil { |
| t.Fatalf("account %d should remain: %v", id, err) |
| } |
| } |
|
|
| type stickyStub struct{} |
|
|
| func (stickyStub) Get(context.Context, string, time.Time) (uint64, bool, error) { |
| return 0, false, nil |
| } |
| func (stickyStub) Bind(context.Context, string, uint64, time.Time, time.Time) (uint64, error) { |
| return 0, nil |
| } |
| func (stickyStub) Set(context.Context, string, uint64, time.Time) error { return nil } |
| func (stickyStub) DeleteByAccount(context.Context, uint64) error { return nil } |
|
|
| type stickyBatchStub struct { |
| singleCalls int |
| batchCalls [][]uint64 |
| } |
|
|
| func (*stickyBatchStub) Get(context.Context, string, time.Time) (uint64, bool, error) { |
| return 0, false, nil |
| } |
| func (*stickyBatchStub) Bind(context.Context, string, uint64, time.Time, time.Time) (uint64, error) { |
| return 0, nil |
| } |
| func (*stickyBatchStub) Set(context.Context, string, uint64, time.Time) error { return nil } |
| func (s *stickyBatchStub) DeleteByAccount(context.Context, uint64) error { |
| s.singleCalls++ |
| return nil |
| } |
| func (s *stickyBatchStub) DeleteByAccounts(_ context.Context, ids []uint64) error { |
| s.batchCalls = append(s.batchCalls, append([]uint64(nil), ids...)) |
| return nil |
| } |
|
|
