Merge pull request #1323 from martinzhames/feat/subscriptions-tests-and-pagination

Feat/subscriptions tests and pagination

Author: aji70

backend/src/subscriptions/dto/dto-validation.spec.ts

@@ -0,0 +1,265 @@
+import { validate } from 'class-validator';
+import { plainToInstance } from 'class-transformer';
+import { ListSubscriptionsQueryDto } from './list-subscriptions-query.dto';
+import { ListCreatorSubscribersQueryDto } from './list-creator-subscribers-query.dto';
+import { SubscriptionStateQueryDto } from './subscription-state-query.dto';
+import { SubscriptionIndexerEventDto } from './subscription-indexer-event.dto';
+import { SetSpendingCapDto } from './spending-cap.dto';
+import { FanDashboardQueryDto } from './fan-dashboard-query.dto';
+
+describe('ListSubscriptionsQueryDto – invalid input', () => {
+  async function validateDto(plain: object) {
+    const dto = plainToInstance(ListSubscriptionsQueryDto, plain);
+    return validate(dto);
+  }
+
+  it('fails when fan is empty string', async () => {
+    const errors = await validateDto({ fan: '' });
+    expect(errors.some((e) => e.property === 'fan')).toBe(true);
+  });
+
+  it('fails when fan is missing', async () => {
+    const errors = await validateDto({});
+    expect(errors.some((e) => e.property === 'fan')).toBe(true);
+  });
+
+  it('fails when status is an invalid string', async () => {
+    const errors = await validateDto({ fan: 'GFAN', status: 'bogus' });
+    const statusErrors = errors.filter((e) => e.property === 'status');
+    expect(statusErrors).toHaveLength(1);
+  });
+
+  it('fails when sort is an invalid string', async () => {
+    const errors = await validateDto({ fan: 'GFAN', sort: 'alphabetical' });
+    const sortErrors = errors.filter((e) => e.property === 'sort');
+    expect(sortErrors).toHaveLength(1);
+  });
+
+  it('fails when limit is zero', async () => {
+    const errors = await validateDto({ fan: 'GFAN', limit: 0 });
+    expect(errors.some((e) => e.property === 'limit')).toBe(true);
+  });
+
+  it('fails when limit is negative', async () => {
+    const errors = await validateDto({ fan: 'GFAN', limit: -5 });
+    expect(errors.some((e) => e.property === 'limit')).toBe(true);
+  });
+
+  it('fails when limit exceeds maximum', async () => {
+    const errors = await validateDto({ fan: 'GFAN', limit: 101 });
+    expect(errors.some((e) => e.property === 'limit')).toBe(true);
+  });
+
+  it('fails when page is zero', async () => {
+    const errors = await validateDto({ fan: 'GFAN', page: 0 });
+    expect(errors.some((e) => e.property === 'page')).toBe(true);
+  });
+
+  it('fails when page is negative', async () => {
+    const errors = await validateDto({ fan: 'GFAN', page: -1 });
+    expect(errors.some((e) => e.property === 'page')).toBe(true);
+  });
+});
+
+describe('ListCreatorSubscribersQueryDto – invalid input', () => {
+  async function validateDto(plain: object) {
+    const dto = plainToInstance(ListCreatorSubscribersQueryDto, plain);
+    return validate(dto);
+  }
+
+  it('fails when creator is missing', async () => {
+    const errors = await validateDto({});
+    expect(errors.some((e) => e.property === 'creator')).toBe(true);
+  });
+
+  it('fails when creator is empty string', async () => {
+    const errors = await validateDto({ creator: '' });
+    expect(errors.some((e) => e.property === 'creator')).toBe(true);
+  });
+
+  it('fails when status is not active or expired', async () => {
+    const errors = await validateDto({ creator: 'GCREATOR', status: 'pending' });
+    expect(errors.some((e) => e.property === 'status')).toBe(true);
+  });
+
+  it('fails when sort is invalid', async () => {
+    const errors = await validateDto({ creator: 'GCREATOR', sort: 'price' });
+    expect(errors.some((e) => e.property === 'sort')).toBe(true);
+  });
+
+  it('fails when limit exceeds maximum', async () => {
+    const errors = await validateDto({ creator: 'GCREATOR', limit: 200 });
+    expect(errors.some((e) => e.property === 'limit')).toBe(true);
+  });
+
+  it('fails when limit is zero', async () => {
+    const errors = await validateDto({ creator: 'GCREATOR', limit: 0 });
+    expect(errors.some((e) => e.property === 'limit')).toBe(true);
+  });
+});
+
+describe('SubscriptionStateQueryDto – invalid input', () => {
+  async function validateDto(plain: object) {
+    const dto = plainToInstance(SubscriptionStateQueryDto, plain);
+    return validate(dto);
+  }
+
+  it('fails when creator is missing', async () => {
+    const errors = await validateDto({});
+    expect(errors.some((e) => e.property === 'creator')).toBe(true);
+  });
+
+  it('fails when creator is empty string', async () => {
+    const errors = await validateDto({ creator: '' });
+    expect(errors.some((e) => e.property === 'creator')).toBe(true);
+  });
+
+  it('fails when creator does not match G-address format', async () => {
+    const errors = await validateDto({ creator: 'not-a-stellar-address' });
+    const creatorErrors = errors.filter((e) => e.property === 'creator');
+    expect(creatorErrors.length).toBeGreaterThan(0);
+  });
+
+  it('fails when creator is lowercase g-address', async () => {
+    const errors = await validateDto({ creator: 'g' + 'A'.repeat(55) });
+    const creatorErrors = errors.filter((e) => e.property === 'creator');
+    expect(creatorErrors.length).toBeGreaterThan(0);
+  });
+
+  it('fails when creator is too short', async () => {
+    const errors = await validateDto({ creator: 'GABCDEF' });
+    const creatorErrors = errors.filter((e) => e.property === 'creator');
+    expect(creatorErrors.length).toBeGreaterThan(0);
+  });
+});
+
+describe('SubscriptionIndexerEventDto – invalid input', () => {
+  async function validateDto(plain: object) {
+    const dto = plainToInstance(SubscriptionIndexerEventDto, plain);
+    return validate(dto);
+  }
+
+  it('fails when event is missing', async () => {
+    const errors = await validateDto({ userId: 'GFAN', creatorId: 'GCREATOR', planId: 1 });
+    expect(errors.some((e) => e.property === 'event')).toBe(true);
+  });
+
+  it('fails when event is invalid value', async () => {
+    const errors = await validateDto({ event: 'created', userId: 'GFAN', creatorId: 'GCREATOR', planId: 1 });
+    expect(errors.some((e) => e.property === 'event')).toBe(true);
+  });
+
+  it('fails when userId is missing', async () => {
+    const errors = await validateDto({ event: 'renewed', creatorId: 'GCREATOR', planId: 1 });
+    expect(errors.some((e) => e.property === 'userId')).toBe(true);
+  });
+
+  it('fails when creatorId is missing', async () => {
+    const errors = await validateDto({ event: 'renewed', userId: 'GFAN', planId: 1 });
+    expect(errors.some((e) => e.property === 'creatorId')).toBe(true);
+  });
+
+  it('fails when planId is missing', async () => {
+    const errors = await validateDto({ event: 'renewed', userId: 'GFAN', creatorId: 'GCREATOR' });
+    expect(errors.some((e) => e.property === 'planId')).toBe(true);
+  });
+
+  it('fails when planId is zero', async () => {
+    const errors = await validateDto({ event: 'renewed', userId: 'GFAN', creatorId: 'GCREATOR', planId: 0 });
+    expect(errors.some((e) => e.property === 'planId')).toBe(true);
+  });
+
+  it('fails when planId is negative', async () => {
+    const errors = await validateDto({ event: 'renewed', userId: 'GFAN', creatorId: 'GCREATOR', planId: -1 });
+    expect(errors.some((e) => e.property === 'planId')).toBe(true);
+  });
+
+  it('fails when expiry is negative', async () => {
+    const errors = await validateDto({ event: 'renewed', userId: 'GFAN', creatorId: 'GCREATOR', planId: 1, expiry: -100 });
+    expect(errors.some((e) => e.property === 'expiry')).toBe(true);
+  });
+
+  it('fails when cancelledAt is negative', async () => {
+    const errors = await validateDto({ event: 'cancelled', userId: 'GFAN', creatorId: 'GCREATOR', planId: 1, cancelledAt: -1 });
+    expect(errors.some((e) => e.property === 'cancelledAt')).toBe(true);
+  });
+
+  it('passes for valid renewed event', async () => {
+    const errors = await validateDto({ event: 'renewed', userId: 'GFAN', creatorId: 'GCREATOR', planId: 1, expiry: 1700000000 });
+    expect(errors).toHaveLength(0);
+  });
+
+  it('passes for valid cancelled event', async () => {
+    const errors = await validateDto({ event: 'cancelled', userId: 'GFAN', creatorId: 'GCREATOR', planId: 1, cancelledAt: 1700000000 });
+    expect(errors).toHaveLength(0);
+  });
+});
+
+describe('SetSpendingCapDto – invalid input', () => {
+  async function validateDto(plain: object) {
+    const dto = plainToInstance(SetSpendingCapDto, plain);
+    return validate(dto);
+  }
+
+  it('fails when period is invalid', async () => {
+    const errors = await validateDto({ period: 'weekly' });
+    expect(errors.some((e) => e.property === 'period')).toBe(true);
+  });
+
+  it('fails when capAmount is negative', async () => {
+    const errors = await validateDto({ capAmount: -100, period: 'monthly' });
+    expect(errors.some((e) => e.property === 'capAmount')).toBe(true);
+  });
+
+  it('fails when capAmount is a float', async () => {
+    const errors = await validateDto({ capAmount: 10.5, period: 'monthly' });
+    expect(errors.some((e) => e.property === 'capAmount')).toBe(true);
+  });
+
+  it('passes when capAmount is zero', async () => {
+    const errors = await validateDto({ capAmount: 0, period: 'monthly' });
+    expect(errors.filter((e) => e.property === 'capAmount')).toHaveLength(0);
+  });
+
+  it('passes when capAmount is omitted', async () => {
+    const errors = await validateDto({ period: 'monthly' });
+    expect(errors.filter((e) => e.property === 'capAmount')).toHaveLength(0);
+  });
+});
+
+describe('FanDashboardQueryDto – invalid input', () => {
+  async function validateDto(plain: object) {
+    const dto = plainToInstance(FanDashboardQueryDto, plain);
+    return validate(dto);
+  }
+
+  it('fails when page is zero', async () => {
+    const errors = await validateDto({ page: 0 });
+    expect(errors.some((e) => e.property === 'page')).toBe(true);
+  });
+
+  it('fails when page is negative', async () => {
+    const errors = await validateDto({ page: -1 });
+    expect(errors.some((e) => e.property === 'page')).toBe(true);
+  });
+
+  it('fails when limit is zero', async () => {
+    const errors = await validateDto({ limit: 0 });
+    expect(errors.some((e) => e.property === 'limit')).toBe(true);
+  });
+
+  it('fails when limit exceeds maximum', async () => {
+    const errors = await validateDto({ limit: 101 });
+    expect(errors.some((e) => e.property === 'limit')).toBe(true);
+  });
+
+  it('passes with valid page and limit', async () => {
+    const errors = await validateDto({ page: 1, limit: 50 });
+    expect(errors).toHaveLength(0);
+  });
+
+  it('passes when both are omitted', async () => {
+    const errors = await validateDto({});
+    expect(errors).toHaveLength(0);
+  });
+});

backend/src/subscriptions/dto/fan-dashboard-query.dto.ts

@@ -0,0 +1,20 @@
+import { ApiPropertyOptional } from '@nestjs/swagger';
+import { IsOptional, IsInt, Min, Max } from 'class-validator';
+import { Type } from 'class-transformer';
+
+export class FanDashboardQueryDto {
+  @ApiPropertyOptional({ description: 'Page number (1-based)', default: 1, minimum: 1 })
+  @IsOptional()
+  @IsInt()
+  @Min(1)
+  @Type(() => Number)
+  page?: number = 1;
+
+  @ApiPropertyOptional({ description: 'Items per page', default: 20, minimum: 1, maximum: 100 })
+  @IsOptional()
+  @IsInt()
+  @Min(1)
+  @Max(100)
+  @Type(() => Number)
+  limit?: number = 20;
+}

backend/src/subscriptions/subscriptions.controller.spec.ts

@@ -19,7 +19,7 @@ describe('SubscriptionsController', () => {
   let service: jest.Mocked<
     Pick<
       SubscriptionsService,
-      'getFanCreatorSubscriptionState' | 'listCreatorSubscribers' | 'listSubscriptions'
+      'getFanCreatorSubscriptionState' | 'listCreatorSubscribers' | 'listSubscriptions' | 'getFanDashboardSummary'
     >
   >;
 
@@ -63,6 +63,14 @@ describe('SubscriptionsController', () => {
         nextCursor: null,
         cursor: null,
       }),
+      getFanDashboardSummary: jest.fn().mockResolvedValue({
+        fan,
+        totalActive: 0,
+        subscriptions: [],
+        page: 1,
+        limit: 20,
+        totalPages: 0,
+      }),
     };
 
     const module: TestingModule = await Test.createTestingModule({
@@ -156,6 +164,20 @@ describe('SubscriptionsController', () => {
       20,
     );
   });
+
+  it('getFanDashboard delegates to getFanDashboardSummary with fan from request', async () => {
+    const req = { fanAddress: fan } as RequestWithFan;
+    await controller.getFanDashboard(req, { page: 2, limit: 10 });
+
+    expect(service.getFanDashboardSummary).toHaveBeenCalledWith(fan, 2, 10);
+  });
+
+  it('getFanDashboard uses default page and limit', async () => {
+    const req = { fanAddress: fan } as RequestWithFan;
+    await controller.getFanDashboard(req, {});
+
+    expect(service.getFanDashboardSummary).toHaveBeenCalledWith(fan, undefined, undefined);
+  });
 });
 
 describe('ListSubscriptionsQueryDto – status validation', () => {

backend/src/subscriptions/subscriptions.controller.ts

@@ -163,6 +163,29 @@ export class SubscriptionsController {
     );
   }
 
+  @Get('me/dashboard')
+  @UseGuards(FanBearerGuard)
+  @ApiBearerAuth()
+  @ApiOperation({
+    summary: 'Get fan dashboard summary with active subscriptions',
+    description:
+      'Offset-paginated dashboard. Pass `page` and `limit` to control pagination.',
+  })
+  @ApiQuery({ name: 'page', required: false, description: 'Page number (1-based, default 1)' })
+  @ApiQuery({ name: 'limit', required: false, description: 'Items per page (default 20, max 100)' })
+  @ApiResponse({ status: 200, description: 'Fan dashboard summary with pagination' })
+  @ApiResponse({ status: 401, description: 'Unauthorized' })
+  getFanDashboard(
+    @Req() req: RequestWithFan,
+    @Query() query: FanDashboardQueryDto,
+  ) {
+    return this.subscriptionsService.getFanDashboardSummary(
+      req.fanAddress,
+      query.page,
+      query.limit,
+    );
+  }
+
   @Post('checkout')
   @Throttle({ short: { limit: 10, ttl: 60000 } })
   @UseGuards(FeatureFlagGuard)