@misterhomer1992/miit-bot-payment 1.1.6 → 2.0.4

package/src/modules/payments/subscription-check-webhook.handler.integration.test.ts

@@ -0,0 +1,935 @@
+import { describe, it, beforeEach, mock } from 'node:test';
+import assert from 'node:assert';
+import crypto from 'crypto';
+import { SubscriptionCheckWebhookHandler } from './subscription-check-webhook.handler';
+import { SubscriptionCheckWebhookService } from './subscription-check-webhook.service';
+import type { WayForPayCallbackData, IWayForPayService, WayForPayWebhookResponse } from './wayforpay.types';
+import type { Logger } from '../logger/types';
+import type { ISubscriptionService, SubscriptionEntity } from '../subscription/types';
+import type { ISubscriptionPlanService, SubscriptionPlanEntity } from '../subscriptionPlan/types';
+import type { GracePeriodConfig } from '../../config';
+import { createSubscriptionOrderReference, createTokenPackOrderReference } from './utils';
+
+const MERCHANT_SECRET_KEY = 'test-secret-key';
+const MERCHANT_ACCOUNT = 'test_merchant';
+
+// Mock logger
+const createMockLogger = (): Logger => ({
+    info: mock.fn(),
+    warning: mock.fn(),
+    error: mock.fn(),
+    debug: mock.fn(),
+});
+
+// Mock response object
+const createMockResponse = () => {
+    let statusCode: number | undefined;
+    let jsonData: unknown;
+
+    const res = {
+        status: mock.fn((code: number) => {
+            statusCode = code;
+            return res;
+        }),
+        json: mock.fn((data: unknown) => {
+            jsonData = data;
+        }),
+        getStatusCode: () => statusCode,
+        getJsonData: () => jsonData,
+    };
+
+    return res;
+};
+
+// Calculate signature for callback data
+const calculateSignature = (data: Partial<WayForPayCallbackData>, secretKey: string): string => {
+    const signatureData = [
+        data.merchantAccount,
+        data.orderReference,
+        data.amount,
+        data.currency,
+        data.authCode,
+        data.cardPan,
+        data.transactionStatus,
+        data.reasonCode,
+    ];
+    const signatureString = signatureData.join(';');
+    return crypto.createHmac('md5', secretKey).update(signatureString).digest('hex');
+};
+
+// Mock callback data factory
+const createMockCallbackData = (
+    overrides: Partial<WayForPayCallbackData> = {},
+    secretKey: string = MERCHANT_SECRET_KEY,
+): WayForPayCallbackData => {
+    const baseData: Omit<WayForPayCallbackData, 'merchantSignature'> = {
+        merchantAccount: MERCHANT_ACCOUNT,
+        orderReference: 'miia_telegram_bot_user123_sub_plan-monthly_v2_20240101120000',
+        amount: 100,
+        currency: 'UAH',
+        authCode: 'auth-123',
+        cardPan: '4111****1111',
+        transactionStatus: 'Approved',
+        reasonCode: '1100',
+        email: 'test@example.com',
+        phone: '+380123456789',
+        createdDate: Math.floor(Date.now() / 1000),
+        processingDate: Math.floor(Date.now() / 1000),
+        cardType: 'VISA',
+        issuerBankCountry: 'UA',
+        issuerBankName: 'Test Bank',
+        recToken: 'rec-token-123',
+        reason: 'Ok',
+        fee: 2.5,
+        paymentSystem: 'VISA',
+        regularOn: '1', // Indicates recurring payment
+        ...overrides,
+    };
+
+    const merchantSignature =
+        overrides.merchantSignature !== undefined
+            ? overrides.merchantSignature
+            : calculateSignature(baseData as Partial<WayForPayCallbackData>, secretKey);
+
+    return {
+        ...baseData,
+        merchantSignature,
+    } as WayForPayCallbackData;
+};
+
+// Mock WayForPay service
+const createMockWayForPayService = (): IWayForPayService => ({
+    generateSubscriptionPaymentUrl: mock.fn(async () => null),
+    generateOneTimePaymentUrl: mock.fn(async () => null),
+    verifyCallbackSignature: mock.fn((data: WayForPayCallbackData) => {
+        const expectedSignature = calculateSignature(data, MERCHANT_SECRET_KEY);
+        const isValid = data.merchantSignature?.toLowerCase() === expectedSignature.toLowerCase();
+        return {
+            isValid,
+            error: isValid ? undefined : data.merchantSignature ? undefined : 'Missing merchant signature in callback data',
+        };
+    }),
+    buildWebhookResponse: mock.fn((orderReference: string, status: 'accept' | 'decline'): WayForPayWebhookResponse => {
+        const time = Math.floor(Date.now() / 1000);
+        const signatureData = [orderReference, status, time];
+        const signatureString = signatureData.join(';');
+        const signature = crypto.createHmac('md5', MERCHANT_SECRET_KEY).update(signatureString).digest('hex');
+        return { orderReference, status, time, signature };
+    }),
+});
+
+// Mock subscription service
+const createMockSubscriptionService = (
+    existingSubscription: SubscriptionEntity | null = null,
+): ISubscriptionService => ({
+    activateSubscription: mock.fn(async () => {}),
+    getByUser: mock.fn(async () => existingSubscription),
+    create: mock.fn(async () => ({ id: 'sub-1', status: 'active' } as SubscriptionEntity)),
+    updateFieldsByUserId: mock.fn(async () => {}),
+    getExpiredActiveSubscriptions: mock.fn(async () => []),
+    updateFieldsById: mock.fn(async () => {}),
+    getOrCreateSubscriptionPaymentUrl: mock.fn(async () => 'https://payment.url'),
+    getSubscriptionsForDeactivationCheck: mock.fn(async () => []),
+    renewSubscription: mock.fn(async () => {}),
+    cancelSubscription: mock.fn(async () => {}),
+    deactivateSubscription: mock.fn(async () => {}),
+    getExpiredSubscriptions: mock.fn(async () => []),
+    getFailedRenewals: mock.fn(async () => []),
+    deactivate: mock.fn(async () => {}),
+});
+
+// Mock subscription plan service
+const createMockSubscriptionPlanService = (
+    plan: SubscriptionPlanEntity | null = {
+        id: 'plan-monthly',
+        titleCode: 'plans.monthly.title',
+        descriptionCode: 'plans.monthly.description',
+        amount: 100,
+        currency: 'UAH',
+        features: { messages: 1000, images: 100, voice: 50 },
+        regularMode: 'monthly',
+        count: 1,
+        credits: 1000,
+        isActive: true,
+        createdAt: new Date().toISOString(),
+        updatedAt: new Date().toISOString(),
+    },
+): ISubscriptionPlanService => ({
+    getById: mock.fn(async () => plan),
+    getAll: mock.fn(async () => (plan ? [plan] : [])),
+    create: mock.fn(async () => plan as SubscriptionPlanEntity),
+    update: mock.fn(async () => plan as SubscriptionPlanEntity),
+    deactivate: mock.fn(async () => {}),
+    resetCache: mock.fn(() => {}),
+    seedDefaults: mock.fn(async () => {}),
+});
+
+// Grace period config
+const createMockGracePeriodConfig = (enabled: boolean = true): GracePeriodConfig => ({
+    durationMs: 3 * 24 * 60 * 60 * 1000, // 3 days
+    enabled,
+});
+
+// Minimal mock service for validation-only tests (avoids Firebase initialization)
+const createMinimalMockWebhookService = () => ({
+    processSubscriptionCheckWebhook: mock.fn(async () => ({
+        success: true,
+        response: { orderReference: 'test', status: 'accept' as const, time: Date.now(), signature: 'sig' },
+    })),
+});
+
+describe('SubscriptionCheckWebhookHandler Integration Tests', () => {
+    let logger: Logger;
+
+    beforeEach(() => {
+        logger = createMockLogger();
+    });
+
+    describe('Subscription Check Webhook - HTTP Handler', () => {
+        describe('Request Validation', () => {
+            it('should return 400 for non-object request body', async () => {
+                const handler = new SubscriptionCheckWebhookHandler({ logger, webhookService: createMinimalMockWebhookService() });
+                const res = createMockResponse();
+
+                await handler.handleRequest({ body: null }, res);
+
+                assert.strictEqual(res.getStatusCode(), 400);
+                const jsonData = res.getJsonData() as { error: string };
+                assert.strictEqual(jsonData.error, 'Request body must be a JSON object');
+            });
+
+            it('should return 400 for missing required fields', async () => {
+                const handler = new SubscriptionCheckWebhookHandler({ logger, webhookService: createMinimalMockWebhookService() });
+                const res = createMockResponse();
+
+                await handler.handleRequest({ body: { merchantAccount: 'test' } }, res);
+
+                assert.strictEqual(res.getStatusCode(), 400);
+                const jsonData = res.getJsonData() as { error: string };
+                assert.ok(jsonData.error.includes('Missing required fields'));
+            });
+
+            it('should return 400 for invalid transaction status', async () => {
+                const handler = new SubscriptionCheckWebhookHandler({ logger, webhookService: createMinimalMockWebhookService() });
+                const res = createMockResponse();
+
+                await handler.handleRequest({
+                    body: {
+                        merchantAccount: 'test',
+                        orderReference: 'order-123',
+                        merchantSignature: 'sig',
+                        amount: 100,
+                        currency: 'UAH',
+                        transactionStatus: 'InvalidStatus',
+                    },
+                }, res);
+
+                assert.strictEqual(res.getStatusCode(), 400);
+                const jsonData = res.getJsonData() as { error: string };
+                assert.ok(jsonData.error.includes('Invalid transaction status'));
+            });
+
+            it('should accept valid request body with all required fields', async () => {
+                const wayForPayService = createMockWayForPayService();
+                const existingSubscription: SubscriptionEntity = {
+                    id: 'sub-1',
+                    userId: 'user123',
+                    platform: 'telegram',
+                    planId: 'plan-monthly',
+                    status: 'active',
+                    startedAt: new Date(Date.now() - 30 * 24 * 60 * 60 * 1000).toISOString(),
+                    expiresAt: new Date(Date.now() + 1 * 24 * 60 * 60 * 1000).toISOString(),
+                    provider: 'wayforpay',
+                };
+
+                const webhookService = new SubscriptionCheckWebhookService({
+                    logger,
+                    wayForPayService,
+                    subscriptionService: createMockSubscriptionService(existingSubscription),
+                    subscriptionPlanService: createMockSubscriptionPlanService(),
+                    gracePeriodConfig: createMockGracePeriodConfig(),
+                });
+
+                const handler = new SubscriptionCheckWebhookHandler({ logger, webhookService });
+                const res = createMockResponse();
+                const callbackData = createMockCallbackData();
+
+                await handler.handleRequest({ body: callbackData }, res);
+
+                assert.strictEqual(res.getStatusCode(), 200);
+            });
+        });
+
+        describe('Signature Validation', () => {
+            it('should decline webhook with invalid signature', async () => {
+                const wayForPayService = createMockWayForPayService();
+                const webhookService = new SubscriptionCheckWebhookService({
+                    logger,
+                    wayForPayService,
+                    subscriptionService: createMockSubscriptionService(),
+                    subscriptionPlanService: createMockSubscriptionPlanService(),
+                    gracePeriodConfig: createMockGracePeriodConfig(),
+                });
+
+                const handler = new SubscriptionCheckWebhookHandler({ logger, webhookService });
+                const res = createMockResponse();
+                const callbackData = createMockCallbackData({ merchantSignature: 'invalid-signature' });
+
+                await handler.handleRequest({ body: callbackData }, res);
+
+                assert.strictEqual(res.getStatusCode(), 200);
+                const jsonData = res.getJsonData() as WayForPayWebhookResponse;
+                assert.strictEqual(jsonData.status, 'decline');
+            });
+
+            it('should decline webhook with missing signature', async () => {
+                const wayForPayService = createMockWayForPayService();
+                const webhookService = new SubscriptionCheckWebhookService({
+                    logger,
+                    wayForPayService,
+                    subscriptionService: createMockSubscriptionService(),
+                    subscriptionPlanService: createMockSubscriptionPlanService(),
+                    gracePeriodConfig: createMockGracePeriodConfig(),
+                });
+
+                const handler = new SubscriptionCheckWebhookHandler({ logger, webhookService });
+                const res = createMockResponse();
+                const callbackData = createMockCallbackData({ merchantSignature: '' });
+
+                await handler.handleRequest({ body: callbackData }, res);
+
+                assert.strictEqual(res.getStatusCode(), 200);
+                const jsonData = res.getJsonData() as WayForPayWebhookResponse;
+                assert.strictEqual(jsonData.status, 'decline');
+            });
+
+            it('should accept webhook with valid signature (case-insensitive)', async () => {
+                const wayForPayService = createMockWayForPayService();
+                const existingSubscription: SubscriptionEntity = {
+                    id: 'sub-1',
+                    userId: 'user123',
+                    platform: 'telegram',
+                    planId: 'plan-monthly',
+                    status: 'active',
+                    startedAt: new Date(Date.now() - 30 * 24 * 60 * 60 * 1000).toISOString(),
+                    expiresAt: new Date(Date.now() + 1 * 24 * 60 * 60 * 1000).toISOString(),
+                    provider: 'wayforpay',
+                };
+
+                const webhookService = new SubscriptionCheckWebhookService({
+                    logger,
+                    wayForPayService,
+                    subscriptionService: createMockSubscriptionService(existingSubscription),
+                    subscriptionPlanService: createMockSubscriptionPlanService(),
+                    gracePeriodConfig: createMockGracePeriodConfig(),
+                });
+
+                const handler = new SubscriptionCheckWebhookHandler({ logger, webhookService });
+                const res = createMockResponse();
+                const callbackData = createMockCallbackData();
+                // Make signature uppercase
+                callbackData.merchantSignature = callbackData.merchantSignature.toUpperCase();
+
+                await handler.handleRequest({ body: callbackData }, res);
+
+                assert.strictEqual(res.getStatusCode(), 200);
+                const jsonData = res.getJsonData() as WayForPayWebhookResponse;
+                assert.strictEqual(jsonData.status, 'accept');
+            });
+        });
+    });
+
+    describe('Subscription Check Webhook - Service Processing', () => {
+        describe('Successful Renewal', () => {
+            it('should renew subscription for approved renewal', async () => {
+                const existingSubscription: SubscriptionEntity = {
+                    id: 'sub-1',
+                    userId: 'user123',
+                    platform: 'telegram',
+                    planId: 'plan-monthly',
+                    status: 'active',
+                    startedAt: new Date(Date.now() - 30 * 24 * 60 * 60 * 1000).toISOString(),
+                    expiresAt: new Date(Date.now() + 1 * 24 * 60 * 60 * 1000).toISOString(),
+                    provider: 'wayforpay',
+                };
+
+                const subscriptionService = createMockSubscriptionService(existingSubscription);
+                const webhookService = new SubscriptionCheckWebhookService({
+                    logger,
+                    wayForPayService: createMockWayForPayService(),
+                    subscriptionService,
+                    subscriptionPlanService: createMockSubscriptionPlanService(),
+                    gracePeriodConfig: createMockGracePeriodConfig(),
+                });
+
+                const orderReference = createSubscriptionOrderReference({
+                    userId: 'user123',
+                    platform: 'telegram',
+                    planId: 'plan-monthly',
+                    utcDate: '20240101120000',
+                });
+
+                const callbackData = createMockCallbackData({
+                    orderReference,
+                    transactionStatus: 'Approved',
+                });
+
+                const result = await webhookService.processSubscriptionCheckWebhook(callbackData);
+
+                assert.strictEqual(result.success, true);
+                assert.strictEqual(result.response.status, 'accept');
+                assert.strictEqual((subscriptionService.renewSubscription as any).mock.calls.length, 1);
+            });
+
+            it('should extend expiration from current date if subscription not yet expired', async () => {
+                const futureExpiration = new Date(Date.now() + 5 * 24 * 60 * 60 * 1000); // 5 days from now
+                const existingSubscription: SubscriptionEntity = {
+                    id: 'sub-1',
+                    userId: 'user123',
+                    platform: 'telegram',
+                    planId: 'plan-monthly',
+                    status: 'active',
+                    startedAt: new Date(Date.now() - 25 * 24 * 60 * 60 * 1000).toISOString(),
+                    expiresAt: futureExpiration.toISOString(),
+                    provider: 'wayforpay',
+                };
+
+                const subscriptionService = createMockSubscriptionService(existingSubscription);
+                const webhookService = new SubscriptionCheckWebhookService({
+                    logger,
+                    wayForPayService: createMockWayForPayService(),
+                    subscriptionService,
+                    subscriptionPlanService: createMockSubscriptionPlanService(),
+                    gracePeriodConfig: createMockGracePeriodConfig(),
+                });
+
+                const orderReference = createSubscriptionOrderReference({
+                    userId: 'user123',
+                    platform: 'telegram',
+                    planId: 'plan-monthly',
+                    utcDate: '20240101120000',
+                });
+
+                const callbackData = createMockCallbackData({
+                    orderReference,
+                    transactionStatus: 'Approved',
+                });
+
+                await webhookService.processSubscriptionCheckWebhook(callbackData);
+
+                assert.strictEqual((subscriptionService.renewSubscription as any).mock.calls.length, 1);
+                // The renewal should extend from current expiration
+            });
+
+            it('should accept webhook for non-subscription order reference without processing', async () => {
+                const subscriptionService = createMockSubscriptionService();
+                const webhookService = new SubscriptionCheckWebhookService({
+                    logger,
+                    wayForPayService: createMockWayForPayService(),
+                    subscriptionService,
+                    subscriptionPlanService: createMockSubscriptionPlanService(),
+                    gracePeriodConfig: createMockGracePeriodConfig(),
+                });
+
+                // Use token pack order reference instead of subscription
+                const orderReference = createTokenPackOrderReference({
+                    userId: 'user123',
+                    platform: 'telegram',
+                    packId: 'pack-small',
+                    utcDate: '20240101120000',
+                });
+
+                const callbackData = createMockCallbackData({
+                    orderReference,
+                    transactionStatus: 'Approved',
+                });
+
+                const result = await webhookService.processSubscriptionCheckWebhook(callbackData);
+
+                assert.strictEqual(result.success, true);
+                assert.strictEqual(result.response.status, 'accept');
+                // Should not try to renew since it's not a subscription
+                assert.strictEqual((subscriptionService.renewSubscription as any).mock.calls.length, 0);
+            });
+
+            it('should handle missing active subscription gracefully', async () => {
+                const subscriptionService = createMockSubscriptionService(null);
+                const webhookService = new SubscriptionCheckWebhookService({
+                    logger,
+                    wayForPayService: createMockWayForPayService(),
+                    subscriptionService,
+                    subscriptionPlanService: createMockSubscriptionPlanService(),
+                    gracePeriodConfig: createMockGracePeriodConfig(),
+                });
+
+                const orderReference = createSubscriptionOrderReference({
+                    userId: 'user123',
+                    platform: 'telegram',
+                    planId: 'plan-monthly',
+                    utcDate: '20240101120000',
+                });
+
+                const callbackData = createMockCallbackData({
+                    orderReference,
+                    transactionStatus: 'Approved',
+                });
+
+                const result = await webhookService.processSubscriptionCheckWebhook(callbackData);
+
+                assert.strictEqual(result.success, true);
+                assert.strictEqual(result.response.status, 'accept');
+                // Should not try to renew since no active subscription
+                assert.strictEqual((subscriptionService.renewSubscription as any).mock.calls.length, 0);
+            });
+
+            it('should handle missing subscription plan gracefully', async () => {
+                const existingSubscription: SubscriptionEntity = {
+                    id: 'sub-1',
+                    userId: 'user123',
+                    platform: 'telegram',
+                    planId: 'plan-monthly',
+                    status: 'active',
+                    startedAt: new Date(Date.now() - 30 * 24 * 60 * 60 * 1000).toISOString(),
+                    expiresAt: new Date(Date.now() + 1 * 24 * 60 * 60 * 1000).toISOString(),
+                    provider: 'wayforpay',
+                };
+
+                const subscriptionService = createMockSubscriptionService(existingSubscription);
+                const webhookService = new SubscriptionCheckWebhookService({
+                    logger,
+                    wayForPayService: createMockWayForPayService(),
+                    subscriptionService,
+                    subscriptionPlanService: createMockSubscriptionPlanService(null),
+                    gracePeriodConfig: createMockGracePeriodConfig(),
+                });
+
+                const orderReference = createSubscriptionOrderReference({
+                    userId: 'user123',
+                    platform: 'telegram',
+                    planId: 'non-existent-plan',
+                    utcDate: '20240101120000',
+                });
+
+                const callbackData = createMockCallbackData({
+                    orderReference,
+                    transactionStatus: 'Approved',
+                });
+
+                const result = await webhookService.processSubscriptionCheckWebhook(callbackData);
+
+                assert.strictEqual(result.success, true);
+                // Should not renew since plan not found
+                assert.strictEqual((subscriptionService.renewSubscription as any).mock.calls.length, 0);
+            });
+        });
+
+        describe('Failed Renewal', () => {
+            it('should deactivate subscription past grace period on declined renewal', async () => {
+                const pastExpiration = new Date(Date.now() - 5 * 24 * 60 * 60 * 1000); // 5 days ago (past 3-day grace)
+                const existingSubscription: SubscriptionEntity = {
+                    id: 'sub-1',
+                    userId: 'user123',
+                    platform: 'telegram',
+                    planId: 'plan-monthly',
+                    status: 'active',
+                    startedAt: new Date(Date.now() - 35 * 24 * 60 * 60 * 1000).toISOString(),
+                    expiresAt: pastExpiration.toISOString(),
+                    provider: 'wayforpay',
+                };
+
+                const subscriptionService = createMockSubscriptionService(existingSubscription);
+                const webhookService = new SubscriptionCheckWebhookService({
+                    logger,
+                    wayForPayService: createMockWayForPayService(),
+                    subscriptionService,
+                    subscriptionPlanService: createMockSubscriptionPlanService(),
+                    gracePeriodConfig: createMockGracePeriodConfig(true),
+                });
+
+                const orderReference = createSubscriptionOrderReference({
+                    userId: 'user123',
+                    platform: 'telegram',
+                    planId: 'plan-monthly',
+                    utcDate: '20240101120000',
+                });
+
+                const callbackData = createMockCallbackData({
+                    orderReference,
+                    transactionStatus: 'Declined',
+                });
+
+                const result = await webhookService.processSubscriptionCheckWebhook(callbackData);
+
+                assert.strictEqual(result.success, true);
+                assert.strictEqual(result.response.status, 'accept');
+                assert.strictEqual((subscriptionService.deactivateSubscription as any).mock.calls.length, 1);
+            });
+
+            it('should cancel subscription within grace period on declined renewal', async () => {
+                const recentExpiration = new Date(Date.now() - 1 * 24 * 60 * 60 * 1000); // 1 day ago (within 3-day grace)
+                const existingSubscription: SubscriptionEntity = {
+                    id: 'sub-1',
+                    userId: 'user123',
+                    platform: 'telegram',
+                    planId: 'plan-monthly',
+                    status: 'active',
+                    startedAt: new Date(Date.now() - 32 * 24 * 60 * 60 * 1000).toISOString(),
+                    expiresAt: recentExpiration.toISOString(),
+                    provider: 'wayforpay',
+                };
+
+                const subscriptionService = createMockSubscriptionService(existingSubscription);
+                const webhookService = new SubscriptionCheckWebhookService({
+                    logger,
+                    wayForPayService: createMockWayForPayService(),
+                    subscriptionService,
+                    subscriptionPlanService: createMockSubscriptionPlanService(),
+                    gracePeriodConfig: createMockGracePeriodConfig(true),
+                });
+
+                const orderReference = createSubscriptionOrderReference({
+                    userId: 'user123',
+                    platform: 'telegram',
+                    planId: 'plan-monthly',
+                    utcDate: '20240101120000',
+                });
+
+                const callbackData = createMockCallbackData({
+                    orderReference,
+                    transactionStatus: 'Declined',
+                });
+
+                const result = await webhookService.processSubscriptionCheckWebhook(callbackData);
+
+                assert.strictEqual(result.success, true);
+                // Should cancel, not deactivate
+                assert.strictEqual((subscriptionService.cancelSubscription as any).mock.calls.length, 1);
+                assert.strictEqual((subscriptionService.deactivateSubscription as any).mock.calls.length, 0);
+            });
+
+            it('should not deactivate subscription that has not yet expired', async () => {
+                const futureExpiration = new Date(Date.now() + 2 * 24 * 60 * 60 * 1000); // 2 days from now
+                const existingSubscription: SubscriptionEntity = {
+                    id: 'sub-1',
+                    userId: 'user123',
+                    platform: 'telegram',
+                    planId: 'plan-monthly',
+                    status: 'active',
+                    startedAt: new Date(Date.now() - 28 * 24 * 60 * 60 * 1000).toISOString(),
+                    expiresAt: futureExpiration.toISOString(),
+                    provider: 'wayforpay',
+                };
+
+                const subscriptionService = createMockSubscriptionService(existingSubscription);
+                const webhookService = new SubscriptionCheckWebhookService({
+                    logger,
+                    wayForPayService: createMockWayForPayService(),
+                    subscriptionService,
+                    subscriptionPlanService: createMockSubscriptionPlanService(),
+                    gracePeriodConfig: createMockGracePeriodConfig(true),
+                });
+
+                const orderReference = createSubscriptionOrderReference({
+                    userId: 'user123',
+                    platform: 'telegram',
+                    planId: 'plan-monthly',
+                    utcDate: '20240101120000',
+                });
+
+                const callbackData = createMockCallbackData({
+                    orderReference,
+                    transactionStatus: 'Declined',
+                });
+
+                const result = await webhookService.processSubscriptionCheckWebhook(callbackData);
+
+                assert.strictEqual(result.success, true);
+                // Should not cancel or deactivate since subscription not expired
+                assert.strictEqual((subscriptionService.cancelSubscription as any).mock.calls.length, 0);
+                assert.strictEqual((subscriptionService.deactivateSubscription as any).mock.calls.length, 0);
+            });
+
+            it('should handle expired transaction status same as declined', async () => {
+                const pastExpiration = new Date(Date.now() - 5 * 24 * 60 * 60 * 1000);
+                const existingSubscription: SubscriptionEntity = {
+                    id: 'sub-1',
+                    userId: 'user123',
+                    platform: 'telegram',
+                    planId: 'plan-monthly',
+                    status: 'active',
+                    startedAt: new Date(Date.now() - 35 * 24 * 60 * 60 * 1000).toISOString(),
+                    expiresAt: pastExpiration.toISOString(),
+                    provider: 'wayforpay',
+                };
+
+                const subscriptionService = createMockSubscriptionService(existingSubscription);
+                const webhookService = new SubscriptionCheckWebhookService({
+                    logger,
+                    wayForPayService: createMockWayForPayService(),
+                    subscriptionService,
+                    subscriptionPlanService: createMockSubscriptionPlanService(),
+                    gracePeriodConfig: createMockGracePeriodConfig(true),
+                });
+
+                const orderReference = createSubscriptionOrderReference({
+                    userId: 'user123',
+                    platform: 'telegram',
+                    planId: 'plan-monthly',
+                    utcDate: '20240101120000',
+                });
+
+                const callbackData = createMockCallbackData({
+                    orderReference,
+                    transactionStatus: 'Expired',
+                });
+
+                const result = await webhookService.processSubscriptionCheckWebhook(callbackData);
+
+                assert.strictEqual(result.success, true);
+                assert.strictEqual((subscriptionService.deactivateSubscription as any).mock.calls.length, 1);
+            });
+
+            it('should handle no active subscription for failed renewal gracefully', async () => {
+                const subscriptionService = createMockSubscriptionService(null);
+                const webhookService = new SubscriptionCheckWebhookService({
+                    logger,
+                    wayForPayService: createMockWayForPayService(),
+                    subscriptionService,
+                    subscriptionPlanService: createMockSubscriptionPlanService(),
+                    gracePeriodConfig: createMockGracePeriodConfig(),
+                });
+
+                const orderReference = createSubscriptionOrderReference({
+                    userId: 'user123',
+                    platform: 'telegram',
+                    planId: 'plan-monthly',
+                    utcDate: '20240101120000',
+                });
+
+                const callbackData = createMockCallbackData({
+                    orderReference,
+                    transactionStatus: 'Declined',
+                });
+
+                const result = await webhookService.processSubscriptionCheckWebhook(callbackData);
+
+                assert.strictEqual(result.success, true);
+                assert.strictEqual((subscriptionService.deactivateSubscription as any).mock.calls.length, 0);
+                assert.strictEqual((subscriptionService.cancelSubscription as any).mock.calls.length, 0);
+            });
+
+            it('should deactivate immediately when grace period is disabled', async () => {
+                const pastExpiration = new Date(Date.now() - 1 * 24 * 60 * 60 * 1000); // 1 day ago
+                const existingSubscription: SubscriptionEntity = {
+                    id: 'sub-1',
+                    userId: 'user123',
+                    platform: 'telegram',
+                    planId: 'plan-monthly',
+                    status: 'active',
+                    startedAt: new Date(Date.now() - 32 * 24 * 60 * 60 * 1000).toISOString(),
+                    expiresAt: pastExpiration.toISOString(),
+                    provider: 'wayforpay',
+                };
+
+                const subscriptionService = createMockSubscriptionService(existingSubscription);
+                const webhookService = new SubscriptionCheckWebhookService({
+                    logger,
+                    wayForPayService: createMockWayForPayService(),
+                    subscriptionService,
+                    subscriptionPlanService: createMockSubscriptionPlanService(),
+                    gracePeriodConfig: createMockGracePeriodConfig(false), // Grace period disabled
+                });
+
+                const orderReference = createSubscriptionOrderReference({
+                    userId: 'user123',
+                    platform: 'telegram',
+                    planId: 'plan-monthly',
+                    utcDate: '20240101120000',
+                });
+
+                const callbackData = createMockCallbackData({
+                    orderReference,
+                    transactionStatus: 'Declined',
+                });
+
+                const result = await webhookService.processSubscriptionCheckWebhook(callbackData);
+
+                assert.strictEqual(result.success, true);
+                // Should deactivate immediately since grace period disabled
+                assert.strictEqual((subscriptionService.deactivateSubscription as any).mock.calls.length, 1);
+            });
+        });
+
+        describe('Non-Final Status', () => {
+            it('should accept webhook with Pending status without action', async () => {
+                const existingSubscription: SubscriptionEntity = {
+                    id: 'sub-1',
+                    userId: 'user123',
+                    platform: 'telegram',
+                    planId: 'plan-monthly',
+                    status: 'active',
+                    startedAt: new Date(Date.now() - 30 * 24 * 60 * 60 * 1000).toISOString(),
+                    expiresAt: new Date(Date.now() + 1 * 24 * 60 * 60 * 1000).toISOString(),
+                    provider: 'wayforpay',
+                };
+
+                const subscriptionService = createMockSubscriptionService(existingSubscription);
+                const webhookService = new SubscriptionCheckWebhookService({
+                    logger,
+                    wayForPayService: createMockWayForPayService(),
+                    subscriptionService,
+                    subscriptionPlanService: createMockSubscriptionPlanService(),
+                    gracePeriodConfig: createMockGracePeriodConfig(),
+                });
+
+                const orderReference = createSubscriptionOrderReference({
+                    userId: 'user123',
+                    platform: 'telegram',
+                    planId: 'plan-monthly',
+                    utcDate: '20240101120000',
+                });
+
+                const callbackData = createMockCallbackData({
+                    orderReference,
+                    transactionStatus: 'Pending',
+                });
+
+                const result = await webhookService.processSubscriptionCheckWebhook(callbackData);
+
+                assert.strictEqual(result.success, true);
+                assert.strictEqual(result.response.status, 'accept');
+                // No subscription actions should be taken
+                assert.strictEqual((subscriptionService.renewSubscription as any).mock.calls.length, 0);
+                assert.strictEqual((subscriptionService.cancelSubscription as any).mock.calls.length, 0);
+                assert.strictEqual((subscriptionService.deactivateSubscription as any).mock.calls.length, 0);
+            });
+
+            it('should accept webhook with InProcessing status without action', async () => {
+                const subscriptionService = createMockSubscriptionService();
+                const webhookService = new SubscriptionCheckWebhookService({
+                    logger,
+                    wayForPayService: createMockWayForPayService(),
+                    subscriptionService,
+                    subscriptionPlanService: createMockSubscriptionPlanService(),
+                    gracePeriodConfig: createMockGracePeriodConfig(),
+                });
+
+                const orderReference = createSubscriptionOrderReference({
+                    userId: 'user123',
+                    platform: 'telegram',
+                    planId: 'plan-monthly',
+                    utcDate: '20240101120000',
+                });
+
+                const callbackData = createMockCallbackData({
+                    orderReference,
+                    transactionStatus: 'InProcessing',
+                });
+
+                const result = await webhookService.processSubscriptionCheckWebhook(callbackData);
+
+                assert.strictEqual(result.success, true);
+                assert.strictEqual(result.response.status, 'accept');
+            });
+        });
+
+        describe('Error Handling', () => {
+            it('should return decline response on processing error', async () => {
+                const subscriptionService = createMockSubscriptionService();
+                // Make getByUser throw an error
+                (subscriptionService.getByUser as any) = mock.fn(async () => {
+                    throw new Error('Database connection error');
+                });
+
+                const webhookService = new SubscriptionCheckWebhookService({
+                    logger,
+                    wayForPayService: createMockWayForPayService(),
+                    subscriptionService,
+                    subscriptionPlanService: createMockSubscriptionPlanService(),
+                    gracePeriodConfig: createMockGracePeriodConfig(),
+                });
+
+                const orderReference = createSubscriptionOrderReference({
+                    userId: 'user123',
+                    platform: 'telegram',
+                    planId: 'plan-monthly',
+                    utcDate: '20240101120000',
+                });
+
+                const callbackData = createMockCallbackData({
+                    orderReference,
+                    transactionStatus: 'Approved',
+                });
+
+                const result = await webhookService.processSubscriptionCheckWebhook(callbackData);
+
+                assert.strictEqual(result.success, false);
+                assert.strictEqual(result.response.status, 'decline');
+                assert.ok(result.error);
+            });
+
+            it('should handle invalid order reference format gracefully', async () => {
+                const webhookService = new SubscriptionCheckWebhookService({
+                    logger,
+                    wayForPayService: createMockWayForPayService(),
+                    subscriptionService: createMockSubscriptionService(),
+                    subscriptionPlanService: createMockSubscriptionPlanService(),
+                    gracePeriodConfig: createMockGracePeriodConfig(),
+                });
+
+                const callbackData = createMockCallbackData({
+                    orderReference: 'invalid-format',
+                    transactionStatus: 'Approved',
+                });
+
+                const result = await webhookService.processSubscriptionCheckWebhook(callbackData);
+
+                // Invalid format means not a subscription reference
+                assert.strictEqual(result.success, true);
+                assert.strictEqual(result.response.status, 'accept');
+            });
+        });
+    });
+
+    describe('Direct Callback Processing', () => {
+        it('should process callback directly via processCallback method', async () => {
+            const existingSubscription: SubscriptionEntity = {
+                id: 'sub-1',
+                userId: 'user123',
+                platform: 'telegram',
+                planId: 'plan-monthly',
+                status: 'active',
+                startedAt: new Date(Date.now() - 30 * 24 * 60 * 60 * 1000).toISOString(),
+                expiresAt: new Date(Date.now() + 1 * 24 * 60 * 60 * 1000).toISOString(),
+                provider: 'wayforpay',
+            };
+
+            const webhookService = new SubscriptionCheckWebhookService({
+                logger,
+                wayForPayService: createMockWayForPayService(),
+                subscriptionService: createMockSubscriptionService(existingSubscription),
+                subscriptionPlanService: createMockSubscriptionPlanService(),
+                gracePeriodConfig: createMockGracePeriodConfig(),
+            });
+
+            const handler = new SubscriptionCheckWebhookHandler({ logger, webhookService });
+
+            const orderReference = createSubscriptionOrderReference({
+                userId: 'user123',
+                platform: 'telegram',
+                planId: 'plan-monthly',
+                utcDate: '20240101120000',
+            });
+
+            const callbackData = createMockCallbackData({
+                orderReference,
+                transactionStatus: 'Approved',
+            });
+
+            const result = await handler.processCallback(callbackData);
+
+            assert.strictEqual(result.success, true);
+            assert.strictEqual(result.response.status, 'accept');
+        });
+    });
+});