Merge pull request #1320 from jhayniffy/feature/games-tests-and-pagination

Feature/games tests and pagination

Author: aji70

CHANGELOG.md

@@ -374,11 +374,11 @@
 
 ### Performance Improvements
 
-* optimise gas usage in earnings contract hot paths ([#966](https://github.com/MyFanss/MyFans/issues/966)) ([799bd81](https://github.com/MyFanss/MyFans/commit/799bd811bdd156c51e59a24ae827c0cc6e0a6b18))
-* optimise gas usage in test-consumer contract hot paths ([#986](https://github.com/MyFanss/MyFans/issues/986)) ([97d059e](https://github.com/MyFanss/MyFans/commit/97d059ec23188aee5f4442a0887dc245f6fda972))
-* Optimize creator profile page performance ([d8ba3ca](https://github.com/MyFanss/MyFans/commit/d8ba3caa3cf605404a033eb7760b7719bc15ded6)), closes [#415](https://github.com/MyFanss/MyFans/issues/415)
+* optimise gas usage in earnings contract hot paths ([#966](https://github.com/jhayniffy/MyFans/issues/966)) ([799bd81](https://github.com/jhayniffy/MyFans/commit/799bd811bdd156c51e59a24ae827c0cc6e0a6b18))
+* optimise gas usage in test-consumer contract hot paths ([#986](https://github.com/jhayniffy/MyFans/issues/986)) ([97d059e](https://github.com/jhayniffy/MyFans/commit/97d059ec23188aee5f4442a0887dc245f6fda972))
+* Optimize creator profile page performance ([d8ba3ca](https://github.com/jhayniffy/MyFans/commit/d8ba3caa3cf605404a033eb7760b7719bc15ded6)), closes [#415](https://github.com/jhayniffy/MyFans/issues/415)
 
 
 ### Reverts
 
-* Revert "feat(backend): subscription reconciler job with dry-run and audit logging" ([7b179fc](https://github.com/MyFanss/MyFans/commit/7b179fcc47dc7454dbc903c7fb019ad0642ab769))
+* Revert "feat(backend): subscription reconciler job with dry-run and audit logging" ([7b179fc](https://github.com/jhayniffy/MyFans/commit/7b179fcc47dc7454dbc903c7fb019ad0642ab769))

backend/src/games/dto/join-game.dto.spec.ts

@@ -0,0 +1,73 @@
+import { validate } from 'class-validator';
+import { plainToInstance } from 'class-transformer';
+import { JoinGameDto } from './join-game.dto';
+
+describe('JoinGameDto', () => {
+  async function validateDto(plain: object) {
+    const dto = plainToInstance(JoinGameDto, plain);
+    return validate(dto);
+  }
+
+  describe('userId', () => {
+    it('accepts a valid UUID', async () => {
+      const errors = await validateDto({ userId: '550e8400-e29b-41d4-a716-446655440000' });
+      expect(errors).toHaveLength(0);
+    });
+
+    it('rejects missing userId', async () => {
+      const errors = await validateDto({});
+
+      expect(errors.length).toBeGreaterThan(0);
+      const userIdError = errors.find(e => e.property === 'userId');
+      expect(userIdError).toBeDefined();
+    });
+
+    it('rejects empty string', async () => {
+      const errors = await validateDto({ userId: '' });
+
+      expect(errors.length).toBeGreaterThan(0);
+      const userIdError = errors.find(e => e.property === 'userId');
+      expect(userIdError).toBeDefined();
+      expect(userIdError?.constraints).toHaveProperty('isUuid');
+    });
+
+    it('rejects non-UUID string', async () => {
+      const errors = await validateDto({ userId: 'not-a-uuid' });
+
+      expect(errors.length).toBeGreaterThan(0);
+      const userIdError = errors.find(e => e.property === 'userId');
+      expect(userIdError).toBeDefined();
+      expect(userIdError?.constraints).toHaveProperty('isUuid');
+    });
+
+    it('rejects numeric value', async () => {
+      const errors = await validateDto({ userId: 12345 });
+
+      expect(errors.length).toBeGreaterThan(0);
+      const userIdError = errors.find(e => e.property === 'userId');
+      expect(userIdError).toBeDefined();
+    });
+
+    it('rejects null value', async () => {
+      const errors = await validateDto({ userId: null });
+
+      expect(errors.length).toBeGreaterThan(0);
+      const userIdError = errors.find(e => e.property === 'userId');
+      expect(userIdError).toBeDefined();
+    });
+
+    it('rejects UUID with invalid format', async () => {
+      const errors = await validateDto({ userId: '550e8400-e29b-41d4-a716' });
+
+      expect(errors.length).toBeGreaterThan(0);
+      const userIdError = errors.find(e => e.property === 'userId');
+      expect(userIdError).toBeDefined();
+      expect(userIdError?.constraints).toHaveProperty('isUuid');
+    });
+
+    it('accepts v4 UUID', async () => {
+      const errors = await validateDto({ userId: 'f47ac10b-58cc-4372-a567-0e02b2c3d479' });
+      expect(errors).toHaveLength(0);
+    });
+  });
+});

backend/src/games/dto/list-games.dto.ts

@@ -0,0 +1,14 @@
+import { IsOptional, IsEnum } from 'class-validator';
+import { ApiPropertyOptional } from '@nestjs/swagger';
+import { PaginationDto } from '../../common/dto';
+import { GameStatus } from '../entities/game.entity';
+
+export class ListGamesDto extends PaginationDto {
+  @ApiPropertyOptional({
+    description: 'Filter by game status',
+    enum: GameStatus,
+  })
+  @IsOptional()
+  @IsEnum(GameStatus)
+  status?: GameStatus;
+}

backend/src/games/games.controller.ts

@@ -1,13 +1,24 @@
-import { Controller, Post, Param, Body, HttpCode, HttpStatus } from '@nestjs/common';
-import { ApiTags, ApiOperation, ApiResponse, ApiParam } from '@nestjs/swagger';
+import { Controller, Get, Post, Param, Body, Query, HttpCode, HttpStatus } from '@nestjs/common';
+import { ApiTags, ApiOperation, ApiResponse, ApiParam, ApiQuery } from '@nestjs/swagger';
 import { GamesService } from './games.service';
 import { JoinGameDto } from './dto/join-game.dto';
+import { ListGamesDto } from './dto/list-games.dto';
 
 @ApiTags('games')
 @Controller({ path: 'games', version: '1' })
 export class GamesController {
   constructor(private readonly gamesService: GamesService) {}
 
+  @Get()
+  @ApiOperation({ summary: 'List games with pagination' })
+  @ApiQuery({ name: 'page', required: false, description: 'Page number (1-based)' })
+  @ApiQuery({ name: 'limit', required: false, description: 'Items per page (1-100)' })
+  @ApiQuery({ name: 'status', required: false, description: 'Filter by game status' })
+  @ApiResponse({ status: 200, description: 'Paginated list of games' })
+  async findAll(@Query() listGamesDto: ListGamesDto) {
+    return await this.gamesService.findAll(listGamesDto);
+  }
+
   @Post(':id/join')
   @HttpCode(HttpStatus.CREATED)
   @ApiOperation({ summary: 'Join a game' })

backend/src/games/games.service.spec.ts

@@ -0,0 +1,184 @@
+import { Test, TestingModule } from '@nestjs/testing';
+import { getRepositoryToken } from '@nestjs/typeorm';
+import { DataSource } from 'typeorm';
+import { GamesService } from './games.service';
+import { Game, GameStatus } from './entities/game.entity';
+import { Player } from './entities/player.entity';
+
+describe('GamesService', () => {
+  let service: GamesService;
+  let mockManager: Record<string, jest.Mock>;
+
+  const mockGame: Partial<Game> = {
+    id: '550e8400-e29b-41d4-a716-446655440000',
+    status: GameStatus.PENDING,
+    number_of_players: 4,
+    players: [],
+    game_settings: {
+      starting_cash: 1500,
+      randomize_turn_order: false,
+    },
+  };
+
+  const mockPlayer: Partial<Player> = {
+    id: '660e8400-e29b-41d4-a716-446655440001',
+    game_id: mockGame.id!,
+    user_id: '770e8400-e29b-41d4-a716-446655440002',
+    balance: 1500,
+    turn_order: 1,
+  };
+
+  beforeEach(async () => {
+    mockManager = {
+      findOne: jest.fn(),
+      create: jest.fn(),
+      save: jest.fn(),
+    };
+
+    const module: TestingModule = await Test.createTestingModule({
+      providers: [
+        GamesService,
+        {
+          provide: getRepositoryToken(Game),
+          useValue: {},
+        },
+        {
+          provide: getRepositoryToken(Player),
+          useValue: {},
+        },
+        {
+          provide: DataSource,
+          useValue: {
+            transaction: jest.fn((cb: (manager: typeof mockManager) => Promise<unknown>) =>
+              cb(mockManager),
+            ),
+          },
+        },
+      ],
+    }).compile();
+
+    service = module.get<GamesService>(GamesService);
+  });
+
+  it('should be defined', () => {
+    expect(service).toBeDefined();
+  });
+
+  describe('joinGame', () => {
+    it('should successfully join a pending game', async () => {
+      mockManager.findOne
+        .mockResolvedValueOnce(mockGame)
+        .mockResolvedValueOnce(null);
+      mockManager.create.mockReturnValue(mockPlayer);
+      mockManager.save.mockResolvedValue(mockPlayer);
+
+      const result = await service.joinGame(mockGame.id!, mockPlayer.user_id!);
+
+      expect(result).toEqual(mockPlayer);
+      expect(mockManager.findOne).toHaveBeenCalledWith(Game, {
+        where: { id: mockGame.id },
+        relations: ['players'],
+        lock: { mode: 'pessimistic_write' },
+      });
+      expect(mockManager.create).toHaveBeenCalledWith(Player, {
+        game_id: mockGame.id,
+        user_id: mockPlayer.user_id,
+        balance: mockGame.game_settings!.starting_cash,
+        turn_order: 1,
+      });
+      expect(mockManager.save).toHaveBeenCalledWith(Player, mockPlayer);
+    });
+
+    it('should assign sequential turn_order when randomize_turn_order is false', async () => {
+      const gameWith2Players = {
+        ...mockGame,
+        players: [{ id: 'p1' }, { id: 'p2' }],
+      };
+      mockManager.findOne
+        .mockResolvedValueOnce(gameWith2Players)
+        .mockResolvedValueOnce(null);
+      mockManager.create.mockReturnValue(mockPlayer);
+      mockManager.save.mockResolvedValue(mockPlayer);
+
+      await service.joinGame(mockGame.id!, mockPlayer.user_id!);
+
+      expect(mockManager.create).toHaveBeenCalledWith(
+        Player,
+        expect.objectContaining({ turn_order: 3 }),
+      );
+    });
+
+    it('should assign random turn_order when randomize_turn_order is true', async () => {
+      const randomizedGame = {
+        ...mockGame,
+        game_settings: { starting_cash: 1500, randomize_turn_order: true },
+      };
+      mockManager.findOne
+        .mockResolvedValueOnce(randomizedGame)
+        .mockResolvedValueOnce(null);
+      mockManager.create.mockReturnValue(mockPlayer);
+      mockManager.save.mockResolvedValue(mockPlayer);
+
+      await service.joinGame(mockGame.id!, mockPlayer.user_id!);
+
+      const createCall = mockManager.create.mock.calls[0][1];
+      expect(createCall.turn_order).toBeGreaterThanOrEqual(0);
+      expect(createCall.turn_order).toBeLessThan(1000);
+    });
+
+    it('should use starting_cash from game_settings as player balance', async () => {
+      const customCashGame = {
+        ...mockGame,
+        game_settings: { starting_cash: 3000, randomize_turn_order: false },
+      };
+      mockManager.findOne
+        .mockResolvedValueOnce(customCashGame)
+        .mockResolvedValueOnce(null);
+      mockManager.create.mockReturnValue(mockPlayer);
+      mockManager.save.mockResolvedValue(mockPlayer);
+
+      await service.joinGame(mockGame.id!, mockPlayer.user_id!);
+
+      expect(mockManager.create).toHaveBeenCalledWith(
+        Player,
+        expect.objectContaining({ balance: 3000 }),
+      );
+    });
+
+    it('should throw NotFoundException when game does not exist', async () => {
+      mockManager.findOne.mockResolvedValueOnce(null);
+
+      await expect(service.joinGame('nonexistent-id', mockPlayer.user_id!))
+        .rejects.toThrow('Game not found');
+    });
+
+    it('should throw BadRequestException when game is not PENDING', async () => {
+      const inProgressGame = { ...mockGame, status: GameStatus.IN_PROGRESS };
+      mockManager.findOne.mockResolvedValueOnce(inProgressGame);
+
+      await expect(service.joinGame(mockGame.id!, mockPlayer.user_id!))
+        .rejects.toThrow('Game is not in PENDING status');
+    });
+
+    it('should throw BadRequestException when game is full', async () => {
+      const fullGame = {
+        ...mockGame,
+        number_of_players: 2,
+        players: [{ id: 'p1' }, { id: 'p2' }],
+      };
+      mockManager.findOne.mockResolvedValueOnce(fullGame);
+
+      await expect(service.joinGame(mockGame.id!, mockPlayer.user_id!))
+        .rejects.toThrow('Game is full');
+    });
+
+    it('should throw BadRequestException when player already joined', async () => {
+      mockManager.findOne
+        .mockResolvedValueOnce(mockGame)
+        .mockResolvedValueOnce({ id: 'existing-player' });
+
+      await expect(service.joinGame(mockGame.id!, mockPlayer.user_id!))
+        .rejects.toThrow('Player already joined this game');
+    });
+  });
+});

backend/src/games/games.service.ts

@@ -3,6 +3,8 @@ import { InjectRepository } from '@nestjs/typeorm';
 import { Repository, DataSource } from 'typeorm';
 import { Game, GameStatus } from './entities/game.entity';
 import { Player } from './entities/player.entity';
+import { ListGamesDto } from './dto/list-games.dto';
+import { PaginatedResponseDto } from '../common/dto/paginated-response.dto';
 
 @Injectable()
 export class GamesService {
@@ -14,6 +16,27 @@ export class GamesService {
     private dataSource: DataSource,
   ) {}
 
+  async findAll(listGamesDto: ListGamesDto): Promise<PaginatedResponseDto<Game>> {
+    const { page = 1, limit = 20, status } = listGamesDto;
+
+    const queryBuilder = this.gameRepository
+      .createQueryBuilder('game')
+      .orderBy('game.created_at', 'DESC');
+
+    if (status) {
+      queryBuilder.where('game.status = :status', { status });
+    }
+
+    const total = await queryBuilder.getCount();
+
+    const data = await queryBuilder
+      .skip((page - 1) * limit)
+      .take(limit)
+      .getMany();
+
+    return new PaginatedResponseDto(data, total, page, limit);
+  }
+
   async joinGame(gameId: string, userId: string): Promise<Player> {
     return await this.dataSource.transaction(async (manager) => {
       const game = await manager.findOne(Game, {