integration tests

tests/integration/leagues/wallet/WalletManagement.test.ts

@@ -0,0 +1,164 @@
+import { describe, it, expect, beforeEach } from 'vitest';
+import { LeaguesTestContext } from '../LeaguesTestContext';
+import { League } from '../../../../core/racing/domain/entities/League';
+import { LeagueWallet } from '../../../../core/racing/domain/entities/league-wallet/LeagueWallet';
+import { Transaction } from '../../../../core/racing/domain/entities/league-wallet/Transaction';
+import { Money } from '../../../../core/racing/domain/value-objects/Money';
+
+describe('WalletManagement', () => {
+  let context: LeaguesTestContext;
+
+  beforeEach(() => {
+    context = new LeaguesTestContext();
+    context.walletRepository.clear();
+    context.transactionRepository.clear();
+  });
+
+  describe('GetLeagueWalletUseCase - Success Path', () => {
+    it('should retrieve current wallet balance', async () => {
+      const leagueId = 'league-123';
+      const ownerId = 'owner-1';
+      
+      await context.racingLeagueRepository.create(League.create({
+        id: leagueId,
+        name: 'Test League',
+        description: 'Test league description',
+        ownerId: ownerId,
+      }));
+
+      const balance = Money.create(1000, 'USD');
+      await context.walletRepository.create(LeagueWallet.create({
+        id: 'wallet-1',
+        leagueId,
+        balance,
+      }));
+
+      const result = await context.getLeagueWalletUseCase.execute({ leagueId });
+
+      expect(result.isOk()).toBe(true);
+      expect(result.unwrap().aggregates.balance.amount).toBe(1000);
+    });
+
+    it('should retrieve transaction history', async () => {
+      const leagueId = 'league-123';
+      const ownerId = 'owner-1';
+      
+      await context.racingLeagueRepository.create(League.create({
+        id: leagueId,
+        name: 'Test League',
+        description: 'Test league description',
+        ownerId: ownerId,
+      }));
+
+      const wallet = LeagueWallet.create({
+        id: 'wallet-1',
+        leagueId,
+        balance: Money.create(1000, 'USD'),
+      });
+      await context.walletRepository.create(wallet);
+
+      const tx = Transaction.create({
+        id: 'tx1',
+        walletId: wallet.id,
+        type: 'sponsorship_payment',
+        amount: Money.create(1000, 'USD'),
+        description: 'Deposit',
+      });
+      await context.transactionRepository.create(tx);
+
+      const result = await context.getLeagueWalletUseCase.execute({ leagueId });
+
+      expect(result.isOk()).toBe(true);
+      expect(result.unwrap().transactions).toHaveLength(1);
+      expect(result.unwrap().transactions[0].id.toString()).toBe('tx1');
+    });
+  });
+
+  describe('WithdrawFromLeagueWalletUseCase - Success Path', () => {
+    it('should allow owner to withdraw funds', async () => {
+      const leagueId = 'league-123';
+      const ownerId = 'owner-1';
+      
+      await context.racingLeagueRepository.create(League.create({
+        id: leagueId,
+        name: 'Test League',
+        description: 'Test league description',
+        ownerId: ownerId,
+      }));
+
+      const wallet = LeagueWallet.create({
+        id: 'wallet-1',
+        leagueId,
+        balance: Money.create(1000, 'USD'),
+      });
+      await context.walletRepository.create(wallet);
+
+      const result = await context.withdrawFromLeagueWalletUseCase.execute({
+        leagueId,
+        requestedById: ownerId,
+        amount: 500,
+        currency: 'USD',
+        reason: 'Test withdrawal'
+      });
+
+      expect(result.isOk()).toBe(true);
+      expect(result.unwrap().walletBalanceAfter.amount).toBe(500);
+      
+      const walletAfter = await context.walletRepository.findByLeagueId(leagueId);
+      expect(walletAfter?.balance.amount).toBe(500);
+    });
+  });
+
+  describe('WalletManagement - Error Handling', () => {
+    it('should return error when league does not exist', async () => {
+      const result = await context.getLeagueWalletUseCase.execute({ leagueId: 'non-existent' });
+
+      expect(result.isErr()).toBe(true);
+      expect((result as any).error.code).toBe('LEAGUE_NOT_FOUND');
+    });
+
+    it('should return error when wallet does not exist', async () => {
+      const leagueId = 'league-123';
+      await context.racingLeagueRepository.create(League.create({
+        id: leagueId,
+        name: 'Test League',
+        description: 'Test league description',
+        ownerId: 'owner-1',
+      }));
+
+      const result = await context.getLeagueWalletUseCase.execute({ leagueId });
+
+      expect(result.isErr()).toBe(true);
+      expect((result as any).error.code).toBe('WALLET_NOT_FOUND');
+    });
+
+    it('should prevent non-owner from withdrawing', async () => {
+      const leagueId = 'league-123';
+      const ownerId = 'owner-1';
+      const otherId = 'other-user';
+      
+      await context.racingLeagueRepository.create(League.create({
+        id: leagueId,
+        name: 'Test League',
+        description: 'Test league description',
+        ownerId: ownerId,
+      }));
+
+      await context.walletRepository.create(LeagueWallet.create({
+        id: 'wallet-1',
+        leagueId,
+        balance: Money.create(1000, 'USD'),
+      }));
+
+      const result = await context.withdrawFromLeagueWalletUseCase.execute({
+        leagueId,
+        requestedById: otherId,
+        amount: 500,
+        currency: 'USD'
+      });
+
+      expect(result.isErr()).toBe(true);
+      expect((result as any).error.code).toBe('UNAUTHORIZED_WITHDRAWAL');
+    });
+  });
+});