@misterhomer1992/miit-bot-payment 1.1.6 → 2.0.4

package/src/modules/subscription/service.test.ts

@@ -0,0 +1,665 @@
+import { describe, it, beforeEach, mock } from 'node:test';
+import assert from 'node:assert';
+import { SubscriptionService } from './service';
+import type { SubscriptionEntity, ISubscriptionRepository, SubscriptionPlan } from './types';
+import type { IPaymentService, PaymentEntity } from '../payments/types';
+import type { Logger } from '../logger/types';
+import type { GracePeriodConfig } from '../../config';
+
+// Mock logger
+const createMockLogger = (): Logger => ({
+    info: mock.fn(),
+    warning: mock.fn(),
+    error: mock.fn(),
+    debug: mock.fn(),
+});
+
+// Mock subscription entity
+const createMockSubscription = (overrides: Partial<SubscriptionEntity> = {}): SubscriptionEntity => ({
+    id: 'sub-123',
+    userId: 'user-123',
+    platform: 'telegram',
+    planId: 'plan-monthly',
+    status: 'active',
+    expiresAt: '2025-02-01T00:00:00.000Z',
+    startedAt: '2025-01-01T00:00:00.000Z',
+    provider: 'wayforpay',
+    ...overrides,
+});
+
+// Mock payment entity
+const createMockPayment = (overrides: Partial<PaymentEntity> = {}): PaymentEntity => ({
+    id: 'pay-123',
+    orderReference: 'order-123',
+    userId: 'user-123',
+    platform: 'telegram',
+    status: 'pending',
+    paymentLink: 'https://pay.example.com/link',
+    planId: 'plan-monthly',
+    paymentType: 'subscription',
+    amount: 100,
+    currency: 'UAH',
+    createdAt: new Date().toISOString(),
+    provider: 'wayforpay',
+    ...overrides,
+});
+
+// Mock subscription plan
+const createMockSubscriptionPlan = (): SubscriptionPlan => ({
+    id: 'plan-monthly',
+    titleCode: 'subscription.monthly.title',
+    descriptionCode: 'subscription.monthly.description',
+    amount: 100,
+    currency: 'UAH',
+    features: {
+        messages: 1000,
+        images: 50,
+        voice: 100,
+    },
+    regularMode: 'monthly',
+    count: 1,
+    credits: 5000,
+});
+
+// Mock repository
+const createMockRepository = (overrides: Partial<ISubscriptionRepository> = {}): ISubscriptionRepository => ({
+    getByUser: mock.fn(async () => null),
+    create: mock.fn(async (params) => ({
+        id: 'new-sub-id',
+        ...params,
+        status: 'active',
+        provider: 'wayforpay',
+    })),
+    updateFieldsByUserId: mock.fn(async () => {}),
+    getExpiredActiveSubscriptions: mock.fn(async () => []),
+    updateFieldsById: mock.fn(async () => {}),
+    activateSubscription: mock.fn(async () => {}),
+    renewSubscription: mock.fn(async () => {}),
+    getByStatus: mock.fn(async () => []),
+    deactivateSubscription: mock.fn(async () => {}),
+    cancelSubscription: mock.fn(async () => {}),
+    ...overrides,
+});
+
+// Mock payment service
+const createMockPaymentService = (overrides: Partial<IPaymentService> = {}): IPaymentService => ({
+    getByOrderReference: mock.fn(async () => null),
+    getByUser: mock.fn(async () => []),
+    create: mock.fn(async (data) => ({ id: 'pay-id', ...data })),
+    updateStatus: mock.fn(async () => {}),
+    changeStatus: mock.fn(async () => {}),
+    getExpiredPendingPayments: mock.fn(async () => []),
+    createPaymentIntent: mock.fn(async () => createMockPayment()),
+    createTokenPackPaymentIntent: mock.fn(async () => createMockPayment()),
+    createUpgradePaymentIntent: mock.fn(async () => createMockPayment()),
+    validateSignature: mock.fn(() => ({ isValid: true })),
+    ...overrides,
+});
+
+describe('SubscriptionService', () => {
+    let logger: Logger;
+    let repository: ISubscriptionRepository;
+    let paymentService: IPaymentService;
+    let gracePeriodConfig: GracePeriodConfig;
+    let service: SubscriptionService;
+
+    beforeEach(() => {
+        logger = createMockLogger();
+        repository = createMockRepository();
+        paymentService = createMockPaymentService();
+        gracePeriodConfig = {
+            enabled: true,
+            durationMs: 3 * 24 * 60 * 60 * 1000, // 3 days
+        };
+        service = new SubscriptionService({
+            logger,
+            repository,
+            paymentService,
+            gracePeriodConfig,
+        });
+    });
+
+    describe('getByUser', () => {
+        it('should return subscription when found', async () => {
+            const mockSubscription = createMockSubscription();
+            repository = createMockRepository({
+                getByUser: mock.fn(async () => mockSubscription),
+            });
+            service = new SubscriptionService({ logger, repository, paymentService, gracePeriodConfig });
+
+            const result = await service.getByUser({
+                userId: 'user-123',
+                platform: 'telegram',
+            });
+
+            assert.deepStrictEqual(result, mockSubscription);
+        });
+
+        it('should return null when subscription not found', async () => {
+            const result = await service.getByUser({
+                userId: 'user-123',
+                platform: 'telegram',
+            });
+
+            assert.strictEqual(result, null);
+        });
+
+        it('should return null and log error on repository error', async () => {
+            repository = createMockRepository({
+                getByUser: mock.fn(async () => {
+                    throw new Error('DB error');
+                }),
+            });
+            service = new SubscriptionService({ logger, repository, paymentService, gracePeriodConfig });
+
+            const result = await service.getByUser({
+                userId: 'user-123',
+                platform: 'telegram',
+            });
+
+            assert.strictEqual(result, null);
+            assert.strictEqual((logger.error as any).mock.calls.length, 1);
+        });
+
+        it('should filter by status when provided', async () => {
+            const getByUserMock = mock.fn(async () => createMockSubscription());
+            repository = createMockRepository({ getByUser: getByUserMock });
+            service = new SubscriptionService({ logger, repository, paymentService, gracePeriodConfig });
+
+            await service.getByUser({
+                userId: 'user-123',
+                platform: 'telegram',
+                status: 'active',
+            });
+
+            const calls = (getByUserMock as any).mock.calls;
+            const callArgs = calls[0]?.arguments[0];
+            assert.strictEqual(callArgs?.userId, 'user-123');
+            assert.strictEqual(callArgs?.platform, 'telegram');
+            assert.strictEqual(callArgs?.status, 'active');
+        });
+    });
+
+    describe('create', () => {
+        it('should create subscription successfully', async () => {
+            const params = {
+                userId: 'user-123',
+                platform: 'telegram',
+                planId: 'plan-monthly',
+                expiresAt: '2025-02-01T00:00:00.000Z',
+                startedAt: '2025-01-01T00:00:00.000Z',
+            };
+
+            const result = await service.create(params);
+
+            assert.strictEqual(result.userId, params.userId);
+            assert.strictEqual(result.platform, params.platform);
+            assert.strictEqual(result.planId, params.planId);
+        });
+
+        it('should throw error and log on repository error', async () => {
+            repository = createMockRepository({
+                create: mock.fn(async () => {
+                    throw new Error('DB error');
+                }),
+            });
+            service = new SubscriptionService({ logger, repository, paymentService, gracePeriodConfig });
+
+            await assert.rejects(
+                async () =>
+                    service.create({
+                        userId: 'user-123',
+                        platform: 'telegram',
+                        planId: 'plan-monthly',
+                        expiresAt: '2025-02-01T00:00:00.000Z',
+                        startedAt: '2025-01-01T00:00:00.000Z',
+                    }),
+                { message: 'DB error' },
+            );
+            assert.strictEqual((logger.error as any).mock.calls.length, 1);
+        });
+    });
+
+    describe('updateFieldsByUserId', () => {
+        it('should update fields successfully', async () => {
+            const updateMock = mock.fn(async () => {});
+            repository = createMockRepository({ updateFieldsByUserId: updateMock });
+            service = new SubscriptionService({ logger, repository, paymentService, gracePeriodConfig });
+
+            await service.updateFieldsByUserId({
+                userId: 'user-123',
+                platform: 'telegram',
+                fields: [['status', 'cancelled']],
+            });
+
+            assert.strictEqual(updateMock.mock.calls.length, 1);
+        });
+
+        it('should throw error on repository error', async () => {
+            repository = createMockRepository({
+                updateFieldsByUserId: mock.fn(async () => {
+                    throw new Error('Update error');
+                }),
+            });
+            service = new SubscriptionService({ logger, repository, paymentService, gracePeriodConfig });
+
+            await assert.rejects(
+                async () =>
+                    service.updateFieldsByUserId({
+                        userId: 'user-123',
+                        platform: 'telegram',
+                        fields: [['status', 'cancelled']],
+                    }),
+                { message: 'Update error' },
+            );
+        });
+    });
+
+    describe('getExpiredActiveSubscriptions', () => {
+        it('should return expired subscriptions', async () => {
+            const expiredSubs = [createMockSubscription({ status: 'active' })];
+            repository = createMockRepository({
+                getExpiredActiveSubscriptions: mock.fn(async () => expiredSubs),
+            });
+            service = new SubscriptionService({ logger, repository, paymentService, gracePeriodConfig });
+
+            const result = await service.getExpiredActiveSubscriptions();
+
+            assert.deepStrictEqual(result, expiredSubs);
+        });
+
+        it('should return empty array on error', async () => {
+            repository = createMockRepository({
+                getExpiredActiveSubscriptions: mock.fn(async () => {
+                    throw new Error('DB error');
+                }),
+            });
+            service = new SubscriptionService({ logger, repository, paymentService, gracePeriodConfig });
+
+            const result = await service.getExpiredActiveSubscriptions();
+
+            assert.deepStrictEqual(result, []);
+        });
+    });
+
+    describe('updateFieldsById', () => {
+        it('should update fields by ID successfully', async () => {
+            const updateMock = mock.fn(async () => {});
+            repository = createMockRepository({ updateFieldsById: updateMock });
+            service = new SubscriptionService({ logger, repository, paymentService, gracePeriodConfig });
+
+            await service.updateFieldsById({
+                subscriptionId: 'sub-123',
+                fields: [['status', 'expired']],
+            });
+
+            assert.strictEqual(updateMock.mock.calls.length, 1);
+        });
+
+        it('should throw error on repository error', async () => {
+            repository = createMockRepository({
+                updateFieldsById: mock.fn(async () => {
+                    throw new Error('Update error');
+                }),
+            });
+            service = new SubscriptionService({ logger, repository, paymentService, gracePeriodConfig });
+
+            await assert.rejects(
+                async () =>
+                    service.updateFieldsById({
+                        subscriptionId: 'sub-123',
+                        fields: [['status', 'expired']],
+                    }),
+                { message: 'Update error' },
+            );
+        });
+    });
+
+    describe('getOrCreateSubscriptionPaymentUrl', () => {
+        it('should return existing payment URL if recent pending payment exists', async () => {
+            const recentPayment = createMockPayment({
+                planId: 'plan-monthly',
+                createdAt: new Date().toISOString(),
+                paymentLink: 'https://existing-payment-link.com',
+            });
+            paymentService = createMockPaymentService({
+                getByUser: mock.fn(async () => [recentPayment]),
+            });
+            service = new SubscriptionService({ logger, repository, paymentService, gracePeriodConfig });
+
+            const translate = () => 'Monthly Subscription';
+            const result = await service.getOrCreateSubscriptionPaymentUrl({
+                userId: 'user-123',
+                platform: 'telegram',
+                languageCode: 'en',
+                translate,
+                subscriptionPlan: createMockSubscriptionPlan(),
+            });
+
+            assert.strictEqual(result, 'https://existing-payment-link.com');
+        });
+
+        it('should create new payment if no recent payment exists', async () => {
+            const newPayment = createMockPayment({
+                paymentLink: 'https://new-payment-link.com',
+            });
+            paymentService = createMockPaymentService({
+                getByUser: mock.fn(async () => []),
+                createPaymentIntent: mock.fn(async () => newPayment),
+            });
+            service = new SubscriptionService({ logger, repository, paymentService, gracePeriodConfig });
+
+            const translate = () => 'Monthly Subscription';
+            const result = await service.getOrCreateSubscriptionPaymentUrl({
+                userId: 'user-123',
+                platform: 'telegram',
+                languageCode: 'en',
+                translate,
+                subscriptionPlan: createMockSubscriptionPlan(),
+            });
+
+            assert.strictEqual(result, 'https://new-payment-link.com');
+        });
+
+        it('should throw error and log on payment service error', async () => {
+            paymentService = createMockPaymentService({
+                getByUser: mock.fn(async () => {
+                    throw new Error('Payment error');
+                }),
+            });
+            service = new SubscriptionService({ logger, repository, paymentService, gracePeriodConfig });
+
+            const translate = () => 'Monthly Subscription';
+            await assert.rejects(
+                async () =>
+                    service.getOrCreateSubscriptionPaymentUrl({
+                        userId: 'user-123',
+                        platform: 'telegram',
+                        languageCode: 'en',
+                        translate,
+                        subscriptionPlan: createMockSubscriptionPlan(),
+                    }),
+                { message: 'Payment error' },
+            );
+        });
+    });
+
+    describe('activateSubscription', () => {
+        it('should activate subscription successfully', async () => {
+            const activateMock = mock.fn(async () => {});
+            repository = createMockRepository({ activateSubscription: activateMock });
+            service = new SubscriptionService({ logger, repository, paymentService, gracePeriodConfig });
+
+            await service.activateSubscription({
+                userId: 'user-123',
+                platform: 'telegram',
+                planId: 'plan-monthly',
+                expiresAt: '2025-02-01T00:00:00.000Z',
+                startedAt: '2025-01-01T00:00:00.000Z',
+                provider: 'wayforpay',
+            });
+
+            assert.strictEqual(activateMock.mock.calls.length, 1);
+        });
+
+        it('should throw error on repository error', async () => {
+            repository = createMockRepository({
+                activateSubscription: mock.fn(async () => {
+                    throw new Error('Activation error');
+                }),
+            });
+            service = new SubscriptionService({ logger, repository, paymentService, gracePeriodConfig });
+
+            await assert.rejects(
+                async () =>
+                    service.activateSubscription({
+                        userId: 'user-123',
+                        platform: 'telegram',
+                        planId: 'plan-monthly',
+                        expiresAt: '2025-02-01T00:00:00.000Z',
+                        startedAt: '2025-01-01T00:00:00.000Z',
+                        provider: 'wayforpay',
+                    }),
+                { message: 'Activation error' },
+            );
+        });
+    });
+
+    describe('renewSubscription', () => {
+        it('should renew subscription successfully', async () => {
+            const renewMock = mock.fn(async () => {});
+            repository = createMockRepository({ renewSubscription: renewMock });
+            service = new SubscriptionService({ logger, repository, paymentService, gracePeriodConfig });
+
+            await service.renewSubscription({
+                userId: 'user-123',
+                platform: 'telegram',
+                expiresAt: '2025-03-01T00:00:00.000Z',
+            });
+
+            assert.strictEqual(renewMock.mock.calls.length, 1);
+        });
+
+        it('should throw error on repository error', async () => {
+            repository = createMockRepository({
+                renewSubscription: mock.fn(async () => {
+                    throw new Error('Renew error');
+                }),
+            });
+            service = new SubscriptionService({ logger, repository, paymentService, gracePeriodConfig });
+
+            await assert.rejects(
+                async () =>
+                    service.renewSubscription({
+                        userId: 'user-123',
+                        platform: 'telegram',
+                        expiresAt: '2025-03-01T00:00:00.000Z',
+                    }),
+                { message: 'Renew error' },
+            );
+        });
+    });
+
+    describe('getSubscriptionsForDeactivationCheck', () => {
+        it('should return active and cancelled subscriptions excluding unlimited', async () => {
+            const subs = [
+                createMockSubscription({ id: 'sub-1', status: 'active' }),
+                createMockSubscription({ id: 'sub-2', status: 'cancelled' }),
+                createMockSubscription({ id: 'unlimited', status: 'active' }),
+            ];
+            repository = createMockRepository({
+                getByStatus: mock.fn(async () => subs),
+            });
+            service = new SubscriptionService({ logger, repository, paymentService, gracePeriodConfig });
+
+            const result = await service.getSubscriptionsForDeactivationCheck();
+
+            assert.strictEqual(result.length, 2);
+            assert.ok(!result.find((s) => s.id === 'unlimited'));
+        });
+
+        it('should throw error on repository error', async () => {
+            repository = createMockRepository({
+                getByStatus: mock.fn(async () => {
+                    throw new Error('DB error');
+                }),
+            });
+            service = new SubscriptionService({ logger, repository, paymentService, gracePeriodConfig });
+
+            await assert.rejects(async () => service.getSubscriptionsForDeactivationCheck(), { message: 'DB error' });
+        });
+    });
+
+    describe('deactivateSubscription', () => {
+        it('should deactivate subscription successfully', async () => {
+            const deactivateMock = mock.fn(async () => {});
+            repository = createMockRepository({ deactivateSubscription: deactivateMock });
+            service = new SubscriptionService({ logger, repository, paymentService, gracePeriodConfig });
+
+            await service.deactivateSubscription({ id: 'sub-123' });
+
+            assert.strictEqual(deactivateMock.mock.calls.length, 1);
+        });
+
+        it('should throw error on repository error', async () => {
+            repository = createMockRepository({
+                deactivateSubscription: mock.fn(async () => {
+                    throw new Error('Deactivation error');
+                }),
+            });
+            service = new SubscriptionService({ logger, repository, paymentService, gracePeriodConfig });
+
+            await assert.rejects(async () => service.deactivateSubscription({ id: 'sub-123' }), {
+                message: 'Deactivation error',
+            });
+        });
+    });
+
+    describe('cancelSubscription', () => {
+        it('should cancel subscription successfully', async () => {
+            const cancelMock = mock.fn(async () => {});
+            repository = createMockRepository({ cancelSubscription: cancelMock });
+            service = new SubscriptionService({ logger, repository, paymentService, gracePeriodConfig });
+
+            await service.cancelSubscription({ id: 'sub-123' });
+
+            assert.strictEqual(cancelMock.mock.calls.length, 1);
+        });
+
+        it('should not throw on repository error (silent failure)', async () => {
+            repository = createMockRepository({
+                cancelSubscription: mock.fn(async () => {
+                    throw new Error('Cancel error');
+                }),
+            });
+            service = new SubscriptionService({ logger, repository, paymentService, gracePeriodConfig });
+
+            // Should not throw, just logs error
+            await service.cancelSubscription({ id: 'sub-123' });
+            assert.strictEqual((logger.error as any).mock.calls.length, 1);
+        });
+    });
+
+    describe('getExpiredSubscriptions', () => {
+        it('should return expired subscriptions after grace period', async () => {
+            // Subscription expired 5 days ago (past 3-day grace period)
+            const expiredSub = createMockSubscription({
+                expiresAt: new Date(Date.now() - 5 * 24 * 60 * 60 * 1000).toISOString(),
+            });
+            repository = createMockRepository({
+                getExpiredActiveSubscriptions: mock.fn(async () => [expiredSub]),
+            });
+            service = new SubscriptionService({ logger, repository, paymentService, gracePeriodConfig });
+
+            const result = await service.getExpiredSubscriptions();
+
+            assert.strictEqual(result.length, 1);
+        });
+
+        it('should not return subscriptions still within grace period', async () => {
+            // Subscription expired 1 day ago (within 3-day grace period)
+            const recentlyExpiredSub = createMockSubscription({
+                expiresAt: new Date(Date.now() - 1 * 24 * 60 * 60 * 1000).toISOString(),
+            });
+            repository = createMockRepository({
+                getExpiredActiveSubscriptions: mock.fn(async () => [recentlyExpiredSub]),
+            });
+            service = new SubscriptionService({ logger, repository, paymentService, gracePeriodConfig });
+
+            const result = await service.getExpiredSubscriptions();
+
+            assert.strictEqual(result.length, 0);
+        });
+
+        it('should return all expired subscriptions if grace period is disabled', async () => {
+            const expiredSub = createMockSubscription({
+                expiresAt: new Date(Date.now() - 1 * 60 * 1000).toISOString(), // 1 minute ago
+            });
+            repository = createMockRepository({
+                getExpiredActiveSubscriptions: mock.fn(async () => [expiredSub]),
+            });
+            service = new SubscriptionService({
+                logger,
+                repository,
+                paymentService,
+                gracePeriodConfig: { enabled: false, durationMs: 0 },
+            });
+
+            const result = await service.getExpiredSubscriptions();
+
+            assert.strictEqual(result.length, 1);
+        });
+
+        it('should return empty array on error', async () => {
+            repository = createMockRepository({
+                getExpiredActiveSubscriptions: mock.fn(async () => {
+                    throw new Error('DB error');
+                }),
+            });
+            service = new SubscriptionService({ logger, repository, paymentService, gracePeriodConfig });
+
+            const result = await service.getExpiredSubscriptions();
+
+            assert.deepStrictEqual(result, []);
+        });
+    });
+
+    describe('getFailedRenewals', () => {
+        it('should return cancelled subscriptions past grace period', async () => {
+            const cancelledSub = createMockSubscription({
+                id: 'sub-cancelled',
+                status: 'cancelled',
+                expiresAt: new Date(Date.now() - 5 * 24 * 60 * 60 * 1000).toISOString(),
+            });
+            repository = createMockRepository({
+                getByStatus: mock.fn(async () => [cancelledSub]),
+            });
+            service = new SubscriptionService({ logger, repository, paymentService, gracePeriodConfig });
+
+            const result = await service.getFailedRenewals();
+
+            assert.strictEqual(result.length, 1);
+        });
+
+        it('should exclude unlimited subscriptions', async () => {
+            const unlimitedSub = createMockSubscription({
+                id: 'unlimited',
+                status: 'cancelled',
+                expiresAt: new Date(Date.now() - 5 * 24 * 60 * 60 * 1000).toISOString(),
+            });
+            repository = createMockRepository({
+                getByStatus: mock.fn(async () => [unlimitedSub]),
+            });
+            service = new SubscriptionService({ logger, repository, paymentService, gracePeriodConfig });
+
+            const result = await service.getFailedRenewals();
+
+            assert.strictEqual(result.length, 0);
+        });
+
+        it('should return empty array on error', async () => {
+            repository = createMockRepository({
+                getByStatus: mock.fn(async () => {
+                    throw new Error('DB error');
+                }),
+            });
+            service = new SubscriptionService({ logger, repository, paymentService, gracePeriodConfig });
+
+            const result = await service.getFailedRenewals();
+
+            assert.deepStrictEqual(result, []);
+        });
+    });
+
+    describe('deactivate', () => {
+        it('should call deactivateSubscription', async () => {
+            const deactivateMock = mock.fn(async () => {});
+            repository = createMockRepository({ deactivateSubscription: deactivateMock });
+            service = new SubscriptionService({ logger, repository, paymentService, gracePeriodConfig });
+
+            await service.deactivate({ id: 'sub-123' });
+
+            assert.strictEqual(deactivateMock.mock.calls.length, 1);
+        });
+    });
+});