@misterhomer1992/miit-bot-payment 1.1.7 → 2.0.4

package/src/modules/payments/webhook.handler.integration.test.ts

@@ -0,0 +1,975 @@
+import { describe, it, beforeEach, mock } from 'node:test';
+import assert from 'node:assert';
+import crypto from 'crypto';
+import { WebhookHandler } from './webhook.handler';
+import { WebhookHandlerService } from './webhook.service';
+import type { WayForPayCallbackData, IWayForPayService, WayForPayWebhookResponse } from './wayforpay.types';
+import type { Logger } from '../logger/types';
+import type { IPaymentService, PaymentEntity } from './types';
+import type { IInvoiceService, InvoiceEntity } from '../invoice/types';
+import type { ISubscriptionService, SubscriptionEntity } from '../subscription/types';
+import type { ISubscriptionPlanService, SubscriptionPlanEntity } from '../subscriptionPlan/types';
+import type { ITokenPackService, TokenPackEntity } from '../tokenPack/types';
+import type { GracePeriodConfig } from '../../config';
+import type { TokenPackPlan } from '../token/types';
+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',
+        ...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 payment service
+const createMockPaymentService = (payment: PaymentEntity | null = null): IPaymentService => ({
+    create: mock.fn(async () => ({ id: 'payment-1', status: 'pending' } as PaymentEntity)),
+    getByOrderReference: mock.fn(async () => payment),
+    getByUser: mock.fn(async () => (payment ? [payment] : [])),
+    updateStatus: mock.fn(async () => {}),
+    changeStatus: mock.fn(async () => {}),
+    getExpiredPendingPayments: mock.fn(async () => []),
+    createPaymentIntent: mock.fn(async () => ({ id: 'payment-1' } as PaymentEntity)),
+    createTokenPackPaymentIntent: mock.fn(async () => ({ id: 'payment-1' } as PaymentEntity)),
+    createUpgradePaymentIntent: mock.fn(async () => ({ id: 'payment-1' } as PaymentEntity)),
+    validateSignature: mock.fn(() => ({ isValid: true })),
+});
+
+// Mock invoice service
+const createMockInvoiceService = (existingInvoice: InvoiceEntity | null = null): IInvoiceService => ({
+    create: mock.fn(async (data) => ({
+        id: 'invoice-1',
+        ...data,
+    } as InvoiceEntity)),
+    getByOrderReference: mock.fn(async () => existingInvoice),
+});
+
+// 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 () => {}),
+});
+
+// Mock token pack service
+const createMockTokenPackService = (): ITokenPackService => ({
+    create: mock.fn(async () => ({
+        id: 'token-pack-1',
+        userId: 'user123',
+        platform: 'telegram',
+        packId: 'pack-small',
+        tokens: 10000,
+        tokensRemaining: 10000,
+        status: 'active',
+        purchasedAt: new Date().toISOString(),
+        provider: 'wayforpay',
+    } as TokenPackEntity)),
+    getByUser: mock.fn(async () => []),
+    getById: mock.fn(async () => null),
+    updateFieldsById: mock.fn(async () => {}),
+    deductTokens: mock.fn(async () => {}),
+    getExpiredActiveTokenPacks: 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 = () => ({
+    processPaymentWebhook: mock.fn(async () => ({
+        success: true,
+        response: { orderReference: 'test', status: 'accept' as const, time: Date.now(), signature: 'sig' },
+    })),
+});
+
+describe('WebhookHandler Integration Tests', () => {
+    let logger: Logger;
+
+    beforeEach(() => {
+        logger = createMockLogger();
+    });
+
+    describe('Purchase Transaction Webhook - HTTP Handler', () => {
+        describe('Request Validation', () => {
+            it('should return 400 for non-object request body', async () => {
+                const handler = new WebhookHandler({ 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 WebhookHandler({ 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 WebhookHandler({ 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 webhookService = new WebhookHandlerService({
+                    logger,
+                    wayForPayService,
+                    paymentService: createMockPaymentService({ id: 'pay-1', status: 'pending' } as PaymentEntity),
+                    invoiceService: createMockInvoiceService(),
+                    subscriptionService: createMockSubscriptionService(),
+                    subscriptionPlanService: createMockSubscriptionPlanService(),
+                    tokenPackService: createMockTokenPackService(),
+                    gracePeriodConfig: createMockGracePeriodConfig(),
+                });
+
+                const handler = new WebhookHandler({ 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 WebhookHandlerService({
+                    logger,
+                    wayForPayService,
+                    paymentService: createMockPaymentService(),
+                    invoiceService: createMockInvoiceService(),
+                    subscriptionService: createMockSubscriptionService(),
+                    subscriptionPlanService: createMockSubscriptionPlanService(),
+                    tokenPackService: createMockTokenPackService(),
+                    gracePeriodConfig: createMockGracePeriodConfig(),
+                });
+
+                const handler = new WebhookHandler({ 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 WebhookHandlerService({
+                    logger,
+                    wayForPayService,
+                    paymentService: createMockPaymentService(),
+                    invoiceService: createMockInvoiceService(),
+                    subscriptionService: createMockSubscriptionService(),
+                    subscriptionPlanService: createMockSubscriptionPlanService(),
+                    tokenPackService: createMockTokenPackService(),
+                    gracePeriodConfig: createMockGracePeriodConfig(),
+                });
+
+                const handler = new WebhookHandler({ 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 webhookService = new WebhookHandlerService({
+                    logger,
+                    wayForPayService,
+                    paymentService: createMockPaymentService({ id: 'pay-1', status: 'pending' } as PaymentEntity),
+                    invoiceService: createMockInvoiceService(),
+                    subscriptionService: createMockSubscriptionService(),
+                    subscriptionPlanService: createMockSubscriptionPlanService(),
+                    tokenPackService: createMockTokenPackService(),
+                    gracePeriodConfig: createMockGracePeriodConfig(),
+                });
+
+                const handler = new WebhookHandler({ 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('Purchase Transaction Webhook - Service Processing', () => {
+        describe('Approved Subscription Payment', () => {
+            it('should create invoice for approved subscription payment', async () => {
+                const invoiceService = createMockInvoiceService();
+                const webhookService = new WebhookHandlerService({
+                    logger,
+                    wayForPayService: createMockWayForPayService(),
+                    paymentService: createMockPaymentService({ id: 'pay-1', status: 'pending' } as PaymentEntity),
+                    invoiceService,
+                    subscriptionService: createMockSubscriptionService(),
+                    subscriptionPlanService: createMockSubscriptionPlanService(),
+                    tokenPackService: createMockTokenPackService(),
+                    gracePeriodConfig: createMockGracePeriodConfig(),
+                });
+
+                const orderReference = createSubscriptionOrderReference({
+                    userId: 'user123',
+                    platform: 'telegram',
+                    planId: 'plan-monthly',
+                    utcDate: '20240101120000',
+                });
+
+                const callbackData = createMockCallbackData({
+                    orderReference,
+                    transactionStatus: 'Approved',
+                });
+
+                const result = await webhookService.processPaymentWebhook(callbackData);
+
+                assert.strictEqual(result.success, true);
+                assert.strictEqual(result.response.status, 'accept');
+                assert.strictEqual((invoiceService.create as any).mock.calls.length, 1);
+            });
+
+            it('should activate new subscription when none exists', async () => {
+                const subscriptionService = createMockSubscriptionService(null);
+                const webhookService = new WebhookHandlerService({
+                    logger,
+                    wayForPayService: createMockWayForPayService(),
+                    paymentService: createMockPaymentService({ id: 'pay-1', status: 'pending' } as PaymentEntity),
+                    invoiceService: createMockInvoiceService(),
+                    subscriptionService,
+                    subscriptionPlanService: createMockSubscriptionPlanService(),
+                    tokenPackService: createMockTokenPackService(),
+                    gracePeriodConfig: createMockGracePeriodConfig(),
+                });
+
+                const orderReference = createSubscriptionOrderReference({
+                    userId: 'user123',
+                    platform: 'telegram',
+                    planId: 'plan-monthly',
+                    utcDate: '20240101120000',
+                });
+
+                const callbackData = createMockCallbackData({
+                    orderReference,
+                    transactionStatus: 'Approved',
+                });
+
+                const result = await webhookService.processPaymentWebhook(callbackData);
+
+                assert.strictEqual(result.success, true);
+                assert.strictEqual((subscriptionService.activateSubscription as any).mock.calls.length, 1);
+            });
+
+            it('should renew existing subscription', 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 WebhookHandlerService({
+                    logger,
+                    wayForPayService: createMockWayForPayService(),
+                    paymentService: createMockPaymentService({ id: 'pay-1', status: 'pending' } as PaymentEntity),
+                    invoiceService: createMockInvoiceService(),
+                    subscriptionService,
+                    subscriptionPlanService: createMockSubscriptionPlanService(),
+                    tokenPackService: createMockTokenPackService(),
+                    gracePeriodConfig: createMockGracePeriodConfig(),
+                });
+
+                const orderReference = createSubscriptionOrderReference({
+                    userId: 'user123',
+                    platform: 'telegram',
+                    planId: 'plan-monthly',
+                    utcDate: '20240101120000',
+                });
+
+                const callbackData = createMockCallbackData({
+                    orderReference,
+                    transactionStatus: 'Approved',
+                });
+
+                const result = await webhookService.processPaymentWebhook(callbackData);
+
+                assert.strictEqual(result.success, true);
+                assert.strictEqual((subscriptionService.renewSubscription as any).mock.calls.length, 1);
+                assert.strictEqual((subscriptionService.activateSubscription as any).mock.calls.length, 0);
+            });
+
+            it('should update payment status to completed', async () => {
+                const paymentService = createMockPaymentService({ id: 'pay-1', status: 'pending' } as PaymentEntity);
+                const webhookService = new WebhookHandlerService({
+                    logger,
+                    wayForPayService: createMockWayForPayService(),
+                    paymentService,
+                    invoiceService: createMockInvoiceService(),
+                    subscriptionService: createMockSubscriptionService(),
+                    subscriptionPlanService: createMockSubscriptionPlanService(),
+                    tokenPackService: createMockTokenPackService(),
+                    gracePeriodConfig: createMockGracePeriodConfig(),
+                });
+
+                const orderReference = createSubscriptionOrderReference({
+                    userId: 'user123',
+                    platform: 'telegram',
+                    planId: 'plan-monthly',
+                    utcDate: '20240101120000',
+                });
+
+                const callbackData = createMockCallbackData({
+                    orderReference,
+                    transactionStatus: 'Approved',
+                });
+
+                await webhookService.processPaymentWebhook(callbackData);
+
+                assert.strictEqual((paymentService.changeStatus as any).mock.calls.length, 1);
+                const changeStatusCall = (paymentService.changeStatus as any).mock.calls[0];
+                assert.strictEqual(changeStatusCall.arguments[0].status, 'completed');
+            });
+
+            it('should initialize token balance based on subscription plan', async () => {
+                const tokenPackService = createMockTokenPackService();
+                const webhookService = new WebhookHandlerService({
+                    logger,
+                    wayForPayService: createMockWayForPayService(),
+                    paymentService: createMockPaymentService({ id: 'pay-1', status: 'pending' } as PaymentEntity),
+                    invoiceService: createMockInvoiceService(),
+                    subscriptionService: createMockSubscriptionService(),
+                    subscriptionPlanService: createMockSubscriptionPlanService({
+                        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: 5000,
+                        isActive: true,
+                        createdAt: new Date().toISOString(),
+                        updatedAt: new Date().toISOString(),
+                    }),
+                    tokenPackService,
+                    gracePeriodConfig: createMockGracePeriodConfig(),
+                });
+
+                const orderReference = createSubscriptionOrderReference({
+                    userId: 'user123',
+                    platform: 'telegram',
+                    planId: 'plan-monthly',
+                    utcDate: '20240101120000',
+                });
+
+                const callbackData = createMockCallbackData({
+                    orderReference,
+                    transactionStatus: 'Approved',
+                });
+
+                await webhookService.processPaymentWebhook(callbackData);
+
+                assert.strictEqual((tokenPackService.create as any).mock.calls.length, 1);
+                const createCall = (tokenPackService.create as any).mock.calls[0];
+                assert.strictEqual(createCall.arguments[0].tokens, 5000);
+            });
+
+            it('should handle duplicate webhook (idempotency)', async () => {
+                const existingInvoice: InvoiceEntity = {
+                    id: 'invoice-1',
+                    merchantAccount: MERCHANT_ACCOUNT,
+                    orderReference: 'miia_telegram_bot_user123_sub_plan-monthly_v2_20240101120000',
+                    merchantSignature: 'sig',
+                    reasonCode: 1100,
+                    reason: 'Ok',
+                    createdDate: new Date().toISOString(),
+                    processingDate: new Date().toISOString(),
+                    currency: 'UAH',
+                    amount: 100,
+                };
+
+                const invoiceService = createMockInvoiceService(existingInvoice);
+                const subscriptionService = createMockSubscriptionService();
+                const webhookService = new WebhookHandlerService({
+                    logger,
+                    wayForPayService: createMockWayForPayService(),
+                    paymentService: createMockPaymentService({ id: 'pay-1', status: 'pending' } as PaymentEntity),
+                    invoiceService,
+                    subscriptionService,
+                    subscriptionPlanService: createMockSubscriptionPlanService(),
+                    tokenPackService: createMockTokenPackService(),
+                    gracePeriodConfig: createMockGracePeriodConfig(),
+                });
+
+                const callbackData = createMockCallbackData({
+                    orderReference: existingInvoice.orderReference,
+                    transactionStatus: 'Approved',
+                });
+
+                const result = await webhookService.processPaymentWebhook(callbackData);
+
+                assert.strictEqual(result.success, true);
+                // Invoice should not be created again
+                assert.strictEqual((invoiceService.create as any).mock.calls.length, 0);
+                // Subscription should not be activated again
+                assert.strictEqual((subscriptionService.activateSubscription as any).mock.calls.length, 0);
+            });
+        });
+
+        describe('Approved Token Pack Payment', () => {
+            it('should create invoice for approved token pack payment', async () => {
+                const invoiceService = createMockInvoiceService();
+                const tokenPackPlans: TokenPackPlan[] = [{
+                    id: 'pack-small',
+                    titleCode: 'packs.small.title',
+                    descriptionCode: 'packs.small.description',
+                    tokens: 10000,
+                    amount: 49,
+                    currency: 'UAH',
+                    isActive: true,
+                }];
+
+                const webhookService = new WebhookHandlerService({
+                    logger,
+                    wayForPayService: createMockWayForPayService(),
+                    paymentService: createMockPaymentService({ id: 'pay-1', status: 'pending' } as PaymentEntity),
+                    invoiceService,
+                    subscriptionService: createMockSubscriptionService(),
+                    subscriptionPlanService: createMockSubscriptionPlanService(),
+                    tokenPackService: createMockTokenPackService(),
+                    tokenPackPlans,
+                    gracePeriodConfig: createMockGracePeriodConfig(),
+                });
+
+                const orderReference = createTokenPackOrderReference({
+                    userId: 'user123',
+                    platform: 'telegram',
+                    packId: 'pack-small',
+                    utcDate: '20240101120000',
+                });
+
+                const callbackData = createMockCallbackData({
+                    orderReference,
+                    transactionStatus: 'Approved',
+                });
+
+                const result = await webhookService.processPaymentWebhook(callbackData);
+
+                assert.strictEqual(result.success, true);
+                assert.strictEqual(result.response.status, 'accept');
+                assert.strictEqual((invoiceService.create as any).mock.calls.length, 1);
+            });
+
+            it('should create token pack for user', async () => {
+                const tokenPackService = createMockTokenPackService();
+                const tokenPackPlans: TokenPackPlan[] = [{
+                    id: 'pack-small',
+                    titleCode: 'packs.small.title',
+                    descriptionCode: 'packs.small.description',
+                    tokens: 10000,
+                    amount: 49,
+                    currency: 'UAH',
+                    isActive: true,
+                }];
+
+                const webhookService = new WebhookHandlerService({
+                    logger,
+                    wayForPayService: createMockWayForPayService(),
+                    paymentService: createMockPaymentService({ id: 'pay-1', status: 'pending' } as PaymentEntity),
+                    invoiceService: createMockInvoiceService(),
+                    subscriptionService: createMockSubscriptionService(),
+                    subscriptionPlanService: createMockSubscriptionPlanService(),
+                    tokenPackService,
+                    tokenPackPlans,
+                    gracePeriodConfig: createMockGracePeriodConfig(),
+                });
+
+                const orderReference = createTokenPackOrderReference({
+                    userId: 'user123',
+                    platform: 'telegram',
+                    packId: 'pack-small',
+                    utcDate: '20240101120000',
+                });
+
+                const callbackData = createMockCallbackData({
+                    orderReference,
+                    transactionStatus: 'Approved',
+                });
+
+                await webhookService.processPaymentWebhook(callbackData);
+
+                assert.strictEqual((tokenPackService.create as any).mock.calls.length, 1);
+                const createCall = (tokenPackService.create as any).mock.calls[0];
+                assert.strictEqual(createCall.arguments[0].tokens, 10000);
+                assert.strictEqual(createCall.arguments[0].userId, 'user123');
+                assert.strictEqual(createCall.arguments[0].packId, 'pack-small');
+            });
+        });
+
+        describe('Declined/Failed Payment', () => {
+            it('should accept webhook for declined transaction without processing', async () => {
+                const invoiceService = createMockInvoiceService();
+                const subscriptionService = createMockSubscriptionService();
+                const webhookService = new WebhookHandlerService({
+                    logger,
+                    wayForPayService: createMockWayForPayService(),
+                    paymentService: createMockPaymentService({ id: 'pay-1', status: 'pending' } as PaymentEntity),
+                    invoiceService,
+                    subscriptionService,
+                    subscriptionPlanService: createMockSubscriptionPlanService(),
+                    tokenPackService: createMockTokenPackService(),
+                    gracePeriodConfig: createMockGracePeriodConfig(),
+                });
+
+                const orderReference = createSubscriptionOrderReference({
+                    userId: 'user123',
+                    platform: 'telegram',
+                    planId: 'plan-monthly',
+                    utcDate: '20240101120000',
+                });
+
+                const callbackData = createMockCallbackData({
+                    orderReference,
+                    transactionStatus: 'Declined',
+                });
+
+                const result = await webhookService.processPaymentWebhook(callbackData);
+
+                assert.strictEqual(result.success, true);
+                assert.strictEqual(result.response.status, 'accept');
+                // No invoice should be created for declined transaction
+                assert.strictEqual((invoiceService.create as any).mock.calls.length, 0);
+            });
+
+            it('should update payment status to failed for declined transaction', async () => {
+                const paymentService = createMockPaymentService({ id: 'pay-1', status: 'pending' } as PaymentEntity);
+                const webhookService = new WebhookHandlerService({
+                    logger,
+                    wayForPayService: createMockWayForPayService(),
+                    paymentService,
+                    invoiceService: createMockInvoiceService(),
+                    subscriptionService: createMockSubscriptionService(),
+                    subscriptionPlanService: createMockSubscriptionPlanService(),
+                    tokenPackService: createMockTokenPackService(),
+                    gracePeriodConfig: createMockGracePeriodConfig(),
+                });
+
+                const orderReference = createSubscriptionOrderReference({
+                    userId: 'user123',
+                    platform: 'telegram',
+                    planId: 'plan-monthly',
+                    utcDate: '20240101120000',
+                });
+
+                const callbackData = createMockCallbackData({
+                    orderReference,
+                    transactionStatus: 'Declined',
+                });
+
+                await webhookService.processPaymentWebhook(callbackData);
+
+                assert.strictEqual((paymentService.changeStatus as any).mock.calls.length, 1);
+                const changeStatusCall = (paymentService.changeStatus as any).mock.calls[0];
+                assert.strictEqual(changeStatusCall.arguments[0].status, 'failed');
+            });
+
+            it('should accept webhook for expired transaction', async () => {
+                const webhookService = new WebhookHandlerService({
+                    logger,
+                    wayForPayService: createMockWayForPayService(),
+                    paymentService: createMockPaymentService({ id: 'pay-1', status: 'pending' } as PaymentEntity),
+                    invoiceService: createMockInvoiceService(),
+                    subscriptionService: createMockSubscriptionService(),
+                    subscriptionPlanService: createMockSubscriptionPlanService(),
+                    tokenPackService: createMockTokenPackService(),
+                    gracePeriodConfig: createMockGracePeriodConfig(),
+                });
+
+                const orderReference = createSubscriptionOrderReference({
+                    userId: 'user123',
+                    platform: 'telegram',
+                    planId: 'plan-monthly',
+                    utcDate: '20240101120000',
+                });
+
+                const callbackData = createMockCallbackData({
+                    orderReference,
+                    transactionStatus: 'Expired',
+                });
+
+                const result = await webhookService.processPaymentWebhook(callbackData);
+
+                assert.strictEqual(result.success, true);
+                assert.strictEqual(result.response.status, 'accept');
+            });
+
+            it('should handle failed recurring renewal - deactivate subscription past grace period', async () => {
+                const pastExpiration = new Date(Date.now() - 5 * 24 * 60 * 60 * 1000); // 5 days ago
+                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 WebhookHandlerService({
+                    logger,
+                    wayForPayService: createMockWayForPayService(),
+                    paymentService: createMockPaymentService({ id: 'pay-1', status: 'pending' } as PaymentEntity),
+                    invoiceService: createMockInvoiceService(),
+                    subscriptionService,
+                    subscriptionPlanService: createMockSubscriptionPlanService(),
+                    tokenPackService: createMockTokenPackService(),
+                    gracePeriodConfig: createMockGracePeriodConfig(true),
+                });
+
+                const orderReference = createSubscriptionOrderReference({
+                    userId: 'user123',
+                    platform: 'telegram',
+                    planId: 'plan-monthly',
+                    utcDate: '20240101120000',
+                });
+
+                const callbackData = createMockCallbackData({
+                    orderReference,
+                    transactionStatus: 'Declined',
+                    regularOn: '1', // Indicates recurring payment
+                });
+
+                await webhookService.processPaymentWebhook(callbackData);
+
+                // Should deactivate since past grace period
+                assert.strictEqual((subscriptionService.deactivateSubscription as any).mock.calls.length, 1);
+            });
+
+            it('should handle failed recurring renewal - cancel subscription within grace period', 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 WebhookHandlerService({
+                    logger,
+                    wayForPayService: createMockWayForPayService(),
+                    paymentService: createMockPaymentService({ id: 'pay-1', status: 'pending' } as PaymentEntity),
+                    invoiceService: createMockInvoiceService(),
+                    subscriptionService,
+                    subscriptionPlanService: createMockSubscriptionPlanService(),
+                    tokenPackService: createMockTokenPackService(),
+                    gracePeriodConfig: createMockGracePeriodConfig(true),
+                });
+
+                const orderReference = createSubscriptionOrderReference({
+                    userId: 'user123',
+                    platform: 'telegram',
+                    planId: 'plan-monthly',
+                    utcDate: '20240101120000',
+                });
+
+                const callbackData = createMockCallbackData({
+                    orderReference,
+                    transactionStatus: 'Declined',
+                    regularOn: '1',
+                });
+
+                await webhookService.processPaymentWebhook(callbackData);
+
+                // Should cancel (not deactivate) since within grace period
+                assert.strictEqual((subscriptionService.cancelSubscription as any).mock.calls.length, 1);
+                assert.strictEqual((subscriptionService.deactivateSubscription as any).mock.calls.length, 0);
+            });
+        });
+
+        describe('Error Handling', () => {
+            it('should return decline response on processing error', async () => {
+                const subscriptionPlanService = createMockSubscriptionPlanService(null);
+                const webhookService = new WebhookHandlerService({
+                    logger,
+                    wayForPayService: createMockWayForPayService(),
+                    paymentService: createMockPaymentService({ id: 'pay-1', status: 'pending' } as PaymentEntity),
+                    invoiceService: createMockInvoiceService(),
+                    subscriptionService: createMockSubscriptionService(),
+                    subscriptionPlanService,
+                    tokenPackService: createMockTokenPackService(),
+                    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.processPaymentWebhook(callbackData);
+
+                assert.strictEqual(result.success, false);
+                assert.strictEqual(result.response.status, 'decline');
+                assert.ok(result.error);
+            });
+
+            it('should handle invalid order reference format', async () => {
+                const webhookService = new WebhookHandlerService({
+                    logger,
+                    wayForPayService: createMockWayForPayService(),
+                    paymentService: createMockPaymentService({ id: 'pay-1', status: 'pending' } as PaymentEntity),
+                    invoiceService: createMockInvoiceService(),
+                    subscriptionService: createMockSubscriptionService(),
+                    subscriptionPlanService: createMockSubscriptionPlanService(),
+                    tokenPackService: createMockTokenPackService(),
+                    gracePeriodConfig: createMockGracePeriodConfig(),
+                });
+
+                const callbackData = createMockCallbackData({
+                    orderReference: 'invalid-format',
+                    transactionStatus: 'Approved',
+                });
+
+                const result = await webhookService.processPaymentWebhook(callbackData);
+
+                // Unknown payment type should just accept
+                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 wayForPayService = createMockWayForPayService();
+            const webhookService = new WebhookHandlerService({
+                logger,
+                wayForPayService,
+                paymentService: createMockPaymentService({ id: 'pay-1', status: 'pending' } as PaymentEntity),
+                invoiceService: createMockInvoiceService(),
+                subscriptionService: createMockSubscriptionService(),
+                subscriptionPlanService: createMockSubscriptionPlanService(),
+                tokenPackService: createMockTokenPackService(),
+                gracePeriodConfig: createMockGracePeriodConfig(),
+            });
+
+            const handler = new WebhookHandler({ 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');
+        });
+    });
+});