test: cover object version listing and wallet operations

Author: strahe

internal/admin/api_wallet_test.go

@@ -307,6 +307,61 @@ func TestHandleAPIWalletApprove_RejectsAmountField(t *testing.T) {
 	}
 }
 
+func TestHandleAPIWalletOperations(t *testing.T) {
+	srv, repos := newWalletOperationTestServer(t)
+	ctx := context.Background()
+	for _, seed := range []repository.CreateWalletOperationInput{
+		{Type: model.WalletOperationTypeFund, ClientRequestID: "req-1", Amount: "100"},
+		{Type: model.WalletOperationTypeWithdraw, ClientRequestID: "req-2", Amount: "50"},
+		{Type: model.WalletOperationTypeApprove, ClientRequestID: "req-3", Amount: "0"},
+	} {
+		if _, _, err := repos.WalletOperations.CreateOrGet(ctx, seed); err != nil {
+			t.Fatalf("CreateOrGet %q: %v", seed.ClientRequestID, err)
+		}
+	}
+
+	tests := []struct {
+		name       string
+		query      string
+		wantStatus int
+		wantIDs    []string
+	}{
+		{name: "default limit returns recent operations", wantStatus: http.StatusOK, wantIDs: []string{"req-3", "req-2", "req-1"}},
+		{name: "custom limit returns most recent operations", query: "?limit=2", wantStatus: http.StatusOK, wantIDs: []string{"req-3", "req-2"}},
+		{name: "invalid limit", query: "?limit=abc", wantStatus: http.StatusBadRequest},
+		{name: "zero limit", query: "?limit=0", wantStatus: http.StatusBadRequest},
+		{name: "negative limit", query: "?limit=-1", wantStatus: http.StatusBadRequest},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			req := httptest.NewRequest(http.MethodGet, "/api/v1/wallet/operations"+tt.query, nil)
+			rr := httptest.NewRecorder()
+
+			srv.handleAPIWalletOperations(rr, req)
+
+			if rr.Code != tt.wantStatus {
+				t.Fatalf("status = %d, want %d, body=%s", rr.Code, tt.wantStatus, rr.Body.String())
+			}
+			if tt.wantStatus != http.StatusOK {
+				return
+			}
+			var resp walletOperationsResponse
+			if err := json.Unmarshal(rr.Body.Bytes(), &resp); err != nil {
+				t.Fatalf("Unmarshal operation response: %v", err)
+			}
+			if len(resp.Operations) != len(tt.wantIDs) {
+				t.Fatalf("operations count = %d, want %d", len(resp.Operations), len(tt.wantIDs))
+			}
+			for i, wantID := range tt.wantIDs {
+				if resp.Operations[i].ClientRequestID != wantID {
+					t.Fatalf("operations[%d].client_request_id = %q, want %q", i, resp.Operations[i].ClientRequestID, wantID)
+				}
+			}
+		})
+	}
+}
+
 type walletOperationAPIHandler struct {
 	name          string
 	path          string

internal/db/repository/object_repo_test.go

@@ -962,6 +962,68 @@ func TestObjectRepo_ListVersionsByBucketOrdersAndMarksCurrent(t *testing.T) {
 	}
 }
 
+func TestObjectRepo_ListVersionsByKey(t *testing.T) {
+	db := testDB(t)
+	repos := repository.NewRepositories(db)
+	ctx := context.Background()
+	bucket := seedBucket(t, db, "version-list-key-bucket")
+	otherBucket := seedBucket(t, db, "version-list-key-other-bucket")
+
+	oldVersion := newObjectVersion(bucket.ID, "file.txt", "01J00000000000000000002001", 10)
+	if _, err := repos.Objects.CreateVersionAndSetCurrent(ctx, oldVersion); err != nil {
+		t.Fatalf("create old version: %v", err)
+	}
+	middleVersion := newObjectVersion(bucket.ID, "file.txt", "01J00000000000000000002002", 20)
+	if _, err := repos.Objects.CreateVersionAndSetCurrent(ctx, middleVersion); err != nil {
+		t.Fatalf("create middle version: %v", err)
+	}
+	currentVersion := newObjectVersion(bucket.ID, "file.txt", "01J00000000000000000002003", 30)
+	if _, err := repos.Objects.CreateVersionAndSetCurrent(ctx, currentVersion); err != nil {
+		t.Fatalf("create current version: %v", err)
+	}
+	if _, err := repos.Objects.CreateVersionAndSetCurrent(ctx, newObjectVersion(bucket.ID, "other.txt", "01J00000000000000000002004", 40)); err != nil {
+		t.Fatalf("create other key version: %v", err)
+	}
+	if _, err := repos.Objects.CreateVersionAndSetCurrent(ctx, newObjectVersion(otherBucket.ID, "file.txt", "01J00000000000000000002005", 50)); err != nil {
+		t.Fatalf("create other bucket version: %v", err)
+	}
+
+	rows, err := repos.Objects.ListVersionsByKey(ctx, bucket.ID, "file.txt", "", 10)
+	if err != nil {
+		t.Fatalf("ListVersionsByKey: %v", err)
+	}
+	if len(rows) != 3 {
+		t.Fatalf("rows len = %d, want 3", len(rows))
+	}
+	for i, row := range rows {
+		if row.BucketID != bucket.ID || row.Key != "file.txt" {
+			t.Fatalf("row %d = bucket:%d key:%q, want target bucket/file.txt", i, row.BucketID, row.Key)
+		}
+	}
+	if rows[0].VersionID != currentVersion.VersionID || !rows[0].IsCurrent {
+		t.Fatalf("first row = %#v, want current version %s", rows[0], currentVersion.VersionID)
+	}
+	if rows[1].VersionID != middleVersion.VersionID || rows[2].VersionID != oldVersion.VersionID {
+		t.Fatalf("ordered rows = %s/%s/%s, want current/middle/old", rows[0].VersionID, rows[1].VersionID, rows[2].VersionID)
+	}
+
+	page, err := repos.Objects.ListVersionsByKey(ctx, bucket.ID, "file.txt", currentVersion.VersionID, 10)
+	if err != nil {
+		t.Fatalf("ListVersionsByKey marker: %v", err)
+	}
+	if len(page) != 2 || page[0].VersionID != middleVersion.VersionID || page[1].VersionID != oldVersion.VersionID {
+		t.Fatalf("marker page = %#v, want middle then old", page)
+	}
+
+	limited, err := repos.Objects.ListVersionsByKey(ctx, bucket.ID, "file.txt", "", 2)
+	if err != nil {
+		t.Fatalf("ListVersionsByKey limit: %v", err)
+	}
+	if len(limited) != 2 || limited[0].VersionID != currentVersion.VersionID || limited[1].VersionID != middleVersion.VersionID {
+		t.Fatalf("limited rows = %#v, want current then middle", limited)
+	}
+}
+
 func TestObjectRepo_CreateDeleteMarkerHidesCurrentObjectButKeepsVersionHistory(t *testing.T) {
 	db := testDB(t)
 	repos := repository.NewRepositories(db)

internal/worker/wallet_operation_runner_test.go

@@ -351,77 +351,146 @@ func TestWalletOperationRunner_ReceiptLookupTimeoutDoesNotBlockRunner(t *testing
 }
 
 func TestWalletOperationRunner_BroadcastTimeoutDoesNotFailOperation(t *testing.T) {
-	db := testutil.NewTestDB(t)
-	repos := repository.NewRepositories(db)
-	ctx := context.Background()
-	op, _, err := repos.WalletOperations.CreateOrGet(ctx, repository.CreateWalletOperationInput{
-		Type:            model.WalletOperationTypeFund,
-		ClientRequestID: "fund-broadcast-timeout",
-		Amount:          "100",
-	})
-	if err != nil {
-		t.Fatalf("CreateOrGet: %v", err)
-	}
+	for _, tc := range []struct {
+		name     string
+		opType   model.WalletOperationType
+		amount   string
+		operator *fakeWalletOperator
+	}{
+		{name: "fund", opType: model.WalletOperationTypeFund, amount: "100", operator: &fakeWalletOperator{blockFund: true}},
+		{name: "withdraw", opType: model.WalletOperationTypeWithdraw, amount: "100", operator: &fakeWalletOperator{blockWithdraw: true}},
+		{name: "approve", opType: model.WalletOperationTypeApprove, amount: "0", operator: &fakeWalletOperator{blockApprove: true}},
+	} {
+		t.Run(tc.name, func(t *testing.T) {
+			db := testutil.NewTestDB(t)
+			repos := repository.NewRepositories(db)
+			ctx := context.Background()
+			op, _, err := repos.WalletOperations.CreateOrGet(ctx, repository.CreateWalletOperationInput{
+				Type:            tc.opType,
+				ClientRequestID: string(tc.opType) + "-broadcast-timeout",
+				Amount:          tc.amount,
+			})
+			if err != nil {
+				t.Fatalf("CreateOrGet: %v", err)
+			}
 
-	operator := &fakeWalletOperator{blockFund: true}
-	runner := NewWalletOperationRunner(repos, operator, nil, time.Millisecond, nil, WithWalletOperationTimeouts(time.Millisecond, 0))
+			runner := NewWalletOperationRunner(repos, tc.operator, nil, time.Millisecond, nil, WithWalletOperationTimeouts(time.Millisecond, 0))
 
-	started := time.Now()
-	runner.runOnce(ctx)
-	if time.Since(started) > time.Second {
-		t.Fatal("runOnce did not return after broadcast timeout")
-	}
+			started := time.Now()
+			runner.runOnce(ctx)
+			if time.Since(started) > time.Second {
+				t.Fatal("runOnce did not return after broadcast timeout")
+			}
 
-	got, err := repos.WalletOperations.GetByID(ctx, op.ID)
-	if err != nil {
-		t.Fatalf("GetByID: %v", err)
-	}
-	if got.Status != model.WalletOperationStatusRunning {
-		t.Fatalf("status = %q, want running until lease expiry", got.Status)
-	}
-	if got.TxHash != nil {
-		t.Fatalf("tx_hash = %v, want nil", got.TxHash)
+			got, err := repos.WalletOperations.GetByID(ctx, op.ID)
+			if err != nil {
+				t.Fatalf("GetByID: %v", err)
+			}
+			if got.Status != model.WalletOperationStatusRunning {
+				t.Fatalf("status = %q, want running until lease expiry", got.Status)
+			}
+			if got.TxHash != nil {
+				t.Fatalf("tx_hash = %v, want nil", got.TxHash)
+			}
+		})
 	}
 }
 
 func TestWalletOperationRunner_RemainsHealthyWhileBroadcasting(t *testing.T) {
-	db := testutil.NewTestDB(t)
-	repos := repository.NewRepositories(db)
-	ctx, cancel := context.WithCancel(context.Background())
-	defer cancel()
+	for _, tc := range []struct {
+		name     string
+		opType   model.WalletOperationType
+		amount   string
+		operator func(started, release chan struct{}) *fakeWalletOperator
+	}{
+		{
+			name:   "fund",
+			opType: model.WalletOperationTypeFund,
+			amount: "100",
+			operator: func(started, release chan struct{}) *fakeWalletOperator {
+				return &fakeWalletOperator{
+					fundHash: common.HexToHash("0x123").Hex(),
+					onFund: func(context.Context) {
+						close(started)
+						<-release
+					},
+				}
+			},
+		},
+		{
+			name:   "withdraw",
+			opType: model.WalletOperationTypeWithdraw,
+			amount: "100",
+			operator: func(started, release chan struct{}) *fakeWalletOperator {
+				return &fakeWalletOperator{
+					withdrawHash: common.HexToHash("0x123").Hex(),
+					onWithdraw: func(context.Context) {
+						close(started)
+						<-release
+					},
+				}
+			},
+		},
+		{
+			name:   "approve",
+			opType: model.WalletOperationTypeApprove,
+			amount: "0",
+			operator: func(started, release chan struct{}) *fakeWalletOperator {
+				return &fakeWalletOperator{
+					approveHash: common.HexToHash("0x123").Hex(),
+					onApprove: func(context.Context) {
+						close(started)
+						<-release
+					},
+				}
+			},
+		},
+	} {
+		t.Run(tc.name, func(t *testing.T) {
+			db := testutil.NewTestDB(t)
+			repos := repository.NewRepositories(db)
+			ctx, cancel := context.WithCancel(context.Background())
+			defer cancel()
 
-	if _, _, err := repos.WalletOperations.CreateOrGet(ctx, repository.CreateWalletOperationInput{
-		Type:            model.WalletOperationTypeFund,
-		ClientRequestID: "fund-slow-broadcast",
-		Amount:          "100",
-	}); err != nil {
-		t.Fatalf("CreateOrGet: %v", err)
-	}
+			if _, _, err := repos.WalletOperations.CreateOrGet(ctx, repository.CreateWalletOperationInput{
+				Type:            tc.opType,
+				ClientRequestID: string(tc.opType) + "-slow-broadcast",
+				Amount:          tc.amount,
+			}); err != nil {
+				t.Fatalf("CreateOrGet: %v", err)
+			}
 
-	started := make(chan struct{})
-	release := make(chan struct{})
-	operator := &fakeWalletOperator{
-		fundHash: common.HexToHash("0x123").Hex(),
-		onFund: func(context.Context) {
-			close(started)
-			<-release
-		},
-	}
-	runner := NewWalletOperationRunner(repos, operator, nil, time.Nanosecond, nil)
+			started := make(chan struct{})
+			release := make(chan struct{})
+			var releaseOnce sync.Once
+			defer releaseOnce.Do(func() { close(release) })
+
+			operator := tc.operator(started, release)
+			runner := NewWalletOperationRunner(repos, operator, nil, time.Nanosecond, nil)
+
+			done := make(chan struct{})
+			go func() {
+				runner.runOnce(ctx)
+				close(done)
+			}()
+			select {
+			case <-started:
+			case <-time.After(time.Second):
+				t.Fatal("wallet broadcast did not start")
+			}
 
-	done := make(chan struct{})
-	go func() {
-		runner.runOnce(ctx)
-		close(done)
-	}()
-	<-started
+			if !runner.Healthy() {
+				t.Fatal("runner is unhealthy during an active wallet broadcast")
+			}
 
-	if !runner.Healthy() {
-		t.Fatal("runner is unhealthy during an active wallet broadcast")
+			releaseOnce.Do(func() { close(release) })
+			select {
+			case <-done:
+			case <-time.After(time.Second):
+				t.Fatal("runOnce did not finish after releasing broadcast")
+			}
+		})
 	}
-
-	close(release)
-	<-done
 }
 
 func TestWalletOperationRunner_RecoversSubmittedAndMarksExpiredRunningUnknown(t *testing.T) {
@@ -512,7 +581,11 @@ type fakeWalletOperator struct {
 	withdrawAmount *big.Int
 	approveCalled  bool
 	onFund         func(context.Context)
+	onWithdraw     func(context.Context)
+	onApprove      func(context.Context)
 	blockFund      bool
+	blockWithdraw  bool
+	blockApprove   bool
 	fundErr        error
 	withdrawErr    error
 	approveErr     error
@@ -533,16 +606,30 @@ func (f *fakeWalletOperator) FundUSDFC(ctx context.Context, amount *big.Int) (st
 	return f.fundHash, nil
 }
 
-func (f *fakeWalletOperator) WithdrawUSDFC(_ context.Context, amount *big.Int) (string, error) {
+func (f *fakeWalletOperator) WithdrawUSDFC(ctx context.Context, amount *big.Int) (string, error) {
 	f.withdrawAmount = new(big.Int).Set(amount)
+	if f.onWithdraw != nil {
+		f.onWithdraw(ctx)
+	}
+	if f.blockWithdraw {
+		<-ctx.Done()
+		return "", ctx.Err()
+	}
 	if f.withdrawErr != nil {
 		return "", f.withdrawErr
 	}
 	return f.withdrawHash, nil
 }
 
-func (f *fakeWalletOperator) ApproveFWSS(context.Context) (string, error) {
+func (f *fakeWalletOperator) ApproveFWSS(ctx context.Context) (string, error) {
 	f.approveCalled = true
+	if f.onApprove != nil {
+		f.onApprove(ctx)
+	}
+	if f.blockApprove {
+		<-ctx.Done()
+		return "", ctx.Err()
+	}
 	if f.approveErr != nil {
 		return "", f.approveErr
 	}