init

tests/integration/payment.test.ts

@@ -0,0 +1,373 @@
+/**
+ * Payment integration tests
+ */
+
+import { describe, it, expect } from 'vitest';
+import { createTestClient, assertSuccessResponse } from '../setup';
+import { testNon3DPaymentRequest, test3DSInitializeRequest } from '../fixtures/payment';
+import { IyzicoResponseError } from '../../src/errors';
+
+describe('Payment Integration Tests', () => {
+  const client = createTestClient();
+
+  it('should create a non-3DS payment', async () => {
+    const request = {
+      ...testNon3DPaymentRequest,
+      conversationId: `test-non3ds-${Date.now()}`,
+    };
+
+    const response = await client.payment.createNon3DS(request);
+
+    assertSuccessResponse(response);
+    expect(response.paymentId).toBeTruthy();
+    expect(response.price).toBe(request.price);
+  });
+
+  it('should get payment detail by paymentId', async () => {
+    // First create a payment
+    const paymentRequest = {
+      ...testNon3DPaymentRequest,
+      conversationId: `test-detail-${Date.now()}`,
+    };
+
+    const paymentResponse = await client.payment.createNon3DS(paymentRequest);
+    assertSuccessResponse(paymentResponse);
+
+    if (!paymentResponse.paymentId) {
+      throw new Error('Payment ID is required for detail test');
+    }
+
+    // Then get payment detail
+    const detailResponse = await client.payment.getDetail({
+      paymentId: paymentResponse.paymentId,
+      locale: 'tr',
+    });
+
+    assertSuccessResponse(detailResponse);
+    expect(detailResponse.paymentId).toBe(paymentResponse.paymentId);
+  });
+
+  it('should initialize 3DS payment', async () => {
+    const request = {
+      ...test3DSInitializeRequest,
+      conversationId: `test-3ds-init-${Date.now()}`,
+    };
+
+    const response = await client.payment.initialize3DS(request);
+
+    assertSuccessResponse(response);
+    expect(response.paymentId).toBeTruthy();
+    expect(response.htmlContent || response.threeDSHtmlContent).toBeTruthy();
+  });
+
+  it('should complete 3DS v1 payment', async () => {
+    // First initialize a 3DS payment
+    const initRequest = {
+      ...test3DSInitializeRequest,
+      conversationId: `test-3ds-v1-${Date.now()}`,
+    };
+
+    const initResponse = await client.payment.initialize3DS(initRequest);
+    assertSuccessResponse(initResponse);
+
+    if (!initResponse.paymentId) {
+      throw new Error('Payment ID is required for 3DS completion test');
+    }
+
+    // In sandbox, 3DS completion will fail without actual 3DS flow
+    // We expect an IyzicoResponseError to be thrown
+    await expect(
+      client.payment.complete3DS({
+        paymentId: initResponse.paymentId,
+        locale: 'tr',
+        conversationId: `test-3ds-v1-complete-${Date.now()}`,
+      })
+    ).rejects.toThrow(IyzicoResponseError);
+  });
+
+  it('should complete 3DS v2 payment', async () => {
+    // First initialize a 3DS payment
+    const initRequest = {
+      ...test3DSInitializeRequest,
+      conversationId: `test-3ds-v2-${Date.now()}`,
+    };
+
+    const initResponse = await client.payment.initialize3DS(initRequest);
+    assertSuccessResponse(initResponse);
+
+    if (!initResponse.paymentId) {
+      throw new Error('Payment ID is required for 3DS completion test');
+    }
+
+    // In sandbox, 3DS completion will fail without actual 3DS flow
+    // We expect an IyzicoResponseError to be thrown
+    await expect(
+      client.payment.complete3DSV2({
+        paymentId: initResponse.paymentId,
+        locale: 'tr',
+        conversationId: `test-3ds-v2-complete-${Date.now()}`,
+        paidPrice: initRequest.paidPrice,
+        basketId: initRequest.basketId!,
+        currency: initRequest.currency || 'TRY',
+      })
+    ).rejects.toThrow(IyzicoResponseError);
+  });
+
+  describe('Edge Cases - Invalid Fields', () => {
+    it('should handle missing required fields (price)', async () => {
+      const request = {
+        ...testNon3DPaymentRequest,
+        conversationId: `test-missing-price-${Date.now()}`,
+        price: undefined as any,
+      };
+
+      await expect(client.payment.createNon3DS(request)).rejects.toThrow(IyzicoResponseError);
+    });
+
+    it('should handle missing required fields (paidPrice)', async () => {
+      const request = {
+        ...testNon3DPaymentRequest,
+        conversationId: `test-missing-paidprice-${Date.now()}`,
+        paidPrice: undefined as any,
+      };
+
+      await expect(client.payment.createNon3DS(request)).rejects.toThrow(IyzicoResponseError);
+    });
+
+    it('should handle missing required fields (paymentCard)', async () => {
+      const request = {
+        ...testNon3DPaymentRequest,
+        conversationId: `test-missing-card-${Date.now()}`,
+        paymentCard: undefined as any,
+      };
+
+      await expect(client.payment.createNon3DS(request)).rejects.toThrow(IyzicoResponseError);
+    });
+
+    it('should handle missing required fields (buyer)', async () => {
+      const request = {
+        ...testNon3DPaymentRequest,
+        conversationId: `test-missing-buyer-${Date.now()}`,
+        buyer: undefined as any,
+      };
+
+      await expect(client.payment.createNon3DS(request)).rejects.toThrow(IyzicoResponseError);
+    });
+
+    it('should handle missing required fields (billingAddress)', async () => {
+      const request = {
+        ...testNon3DPaymentRequest,
+        conversationId: `test-missing-billing-${Date.now()}`,
+        billingAddress: undefined as any,
+      };
+
+      await expect(client.payment.createNon3DS(request)).rejects.toThrow(IyzicoResponseError);
+    });
+
+    it('should handle missing required fields (basketItems)', async () => {
+      const request = {
+        ...testNon3DPaymentRequest,
+        conversationId: `test-missing-basket-${Date.now()}`,
+        basketItems: undefined as any,
+      };
+
+      await expect(client.payment.createNon3DS(request)).rejects.toThrow(IyzicoResponseError);
+    });
+
+    it('should handle empty basketItems array', async () => {
+      const request = {
+        ...testNon3DPaymentRequest,
+        conversationId: `test-empty-basket-${Date.now()}`,
+        basketItems: [],
+      };
+
+      await expect(client.payment.createNon3DS(request)).rejects.toThrow(IyzicoResponseError);
+    });
+
+    it('should handle invalid card number (too short)', async () => {
+      const request = {
+        ...testNon3DPaymentRequest,
+        conversationId: `test-invalid-card-short-${Date.now()}`,
+        paymentCard: {
+          ...testNon3DPaymentRequest.paymentCard,
+          cardNumber: '1234',
+        },
+      };
+
+      await expect(client.payment.createNon3DS(request)).rejects.toThrow(IyzicoResponseError);
+    });
+
+    it('should handle invalid card number (non-numeric)', async () => {
+      const request = {
+        ...testNon3DPaymentRequest,
+        conversationId: `test-invalid-card-nonnumeric-${Date.now()}`,
+        paymentCard: {
+          ...testNon3DPaymentRequest.paymentCard,
+          cardNumber: 'ABCDEFGHIJKLMNOP',
+        },
+      };
+
+      await expect(client.payment.createNon3DS(request)).rejects.toThrow(IyzicoResponseError);
+    });
+
+    it('should handle invalid expiry month (invalid format)', async () => {
+      const request = {
+        ...testNon3DPaymentRequest,
+        conversationId: `test-invalid-expmonth-${Date.now()}`,
+        paymentCard: {
+          ...testNon3DPaymentRequest.paymentCard,
+          expireMonth: '13',
+        },
+      };
+
+      await expect(client.payment.createNon3DS(request)).rejects.toThrow(IyzicoResponseError);
+    });
+
+    it('should handle invalid expiry year (invalid format)', async () => {
+      // Note: Sandbox doesn't validate past years, so we test invalid format instead
+      const request = {
+        ...testNon3DPaymentRequest,
+        conversationId: `test-invalid-expyear-format-${Date.now()}`,
+        paymentCard: {
+          ...testNon3DPaymentRequest.paymentCard,
+          expireYear: 'AB', // Invalid format - non-numeric
+        },
+      };
+
+      await expect(client.payment.createNon3DS(request)).rejects.toThrow(IyzicoResponseError);
+    });
+
+    it('should handle invalid CVV (too short)', async () => {
+      const request = {
+        ...testNon3DPaymentRequest,
+        conversationId: `test-invalid-cvv-short-${Date.now()}`,
+        paymentCard: {
+          ...testNon3DPaymentRequest.paymentCard,
+          cvc: '12',
+        },
+      };
+
+      await expect(client.payment.createNon3DS(request)).rejects.toThrow(IyzicoResponseError);
+    });
+
+    it('should handle invalid CVV (non-numeric)', async () => {
+      const request = {
+        ...testNon3DPaymentRequest,
+        conversationId: `test-invalid-cvv-nonnumeric-${Date.now()}`,
+        paymentCard: {
+          ...testNon3DPaymentRequest.paymentCard,
+          cvc: 'ABC',
+        },
+      };
+
+      await expect(client.payment.createNon3DS(request)).rejects.toThrow(IyzicoResponseError);
+    });
+
+    it('should handle negative price', async () => {
+      const request = {
+        ...testNon3DPaymentRequest,
+        conversationId: `test-negative-price-${Date.now()}`,
+        price: -100.0,
+        paidPrice: -100.0,
+      };
+
+      await expect(client.payment.createNon3DS(request)).rejects.toThrow(IyzicoResponseError);
+    });
+
+    it('should handle zero price', async () => {
+      const request = {
+        ...testNon3DPaymentRequest,
+        conversationId: `test-zero-price-${Date.now()}`,
+        price: 0,
+        paidPrice: 0,
+      };
+
+      await expect(client.payment.createNon3DS(request)).rejects.toThrow(IyzicoResponseError);
+    });
+
+    it('should handle invalid currency', async () => {
+      const request = {
+        ...testNon3DPaymentRequest,
+        conversationId: `test-invalid-currency-${Date.now()}`,
+        currency: 'INVALID' as any,
+      };
+
+      await expect(client.payment.createNon3DS(request)).rejects.toThrow(IyzicoResponseError);
+    });
+
+    it('should handle invalid installment value', async () => {
+      const request = {
+        ...testNon3DPaymentRequest,
+        conversationId: `test-invalid-installment-${Date.now()}`,
+        installment: 99 as any,
+      };
+
+      await expect(client.payment.createNon3DS(request)).rejects.toThrow(IyzicoResponseError);
+    });
+
+    it('should handle invalid email format', async () => {
+      const request = {
+        ...testNon3DPaymentRequest,
+        conversationId: `test-invalid-email-${Date.now()}`,
+        buyer: {
+          ...testNon3DPaymentRequest.buyer,
+          email: 'invalid-email-format',
+        },
+      };
+
+      await expect(client.payment.createNon3DS(request)).rejects.toThrow(IyzicoResponseError);
+    });
+
+    it('should handle basket item with negative price', async () => {
+      const request = {
+        ...testNon3DPaymentRequest,
+        conversationId: `test-negative-basket-price-${Date.now()}`,
+        basketItems: [
+          {
+            ...testNon3DPaymentRequest.basketItems[0],
+            price: -10.0,
+          },
+        ],
+      };
+
+      await expect(client.payment.createNon3DS(request)).rejects.toThrow(IyzicoResponseError);
+    });
+
+    it('should handle missing callbackUrl for 3DS initialize', async () => {
+      const request = {
+        ...test3DSInitializeRequest,
+        conversationId: `test-missing-callback-${Date.now()}`,
+        callbackUrl: undefined as any,
+      };
+
+      await expect(client.payment.initialize3DS(request)).rejects.toThrow(IyzicoResponseError);
+    });
+
+    it('should handle invalid paymentId for getDetail', async () => {
+      await expect(
+        client.payment.getDetail({
+          paymentId: 'invalid-payment-id-12345',
+          locale: 'tr',
+        })
+      ).rejects.toThrow(IyzicoResponseError);
+    });
+
+    it('should handle empty paymentId for getDetail', async () => {
+      await expect(
+        client.payment.getDetail({
+          paymentId: '',
+          locale: 'tr',
+        })
+      ).rejects.toThrow(IyzicoResponseError);
+    });
+
+    it('should handle missing paymentId and paymentConversationId for getDetail', async () => {
+      await expect(
+        client.payment.getDetail({
+          locale: 'tr',
+        })
+      ).rejects.toThrow(IyzicoResponseError);
+    });
+  });
+});
+