init

tests/integration/bin-check.test.ts

@@ -0,0 +1,224 @@
+/**
+ * BIN Check integration tests
+ */
+
+import { describe, it, expect } from 'vitest';
+import { createTestClient, assertSuccessResponse } from '../setup';
+import type { ErrorResponse } from '../../src/types';
+
+describe('BIN Check Integration Tests', () => {
+  const client = createTestClient();
+
+  it('should check BIN for a valid card number', async () => {
+    const response = await client.binCheck.check({
+      locale: 'tr',
+      binNumber: '535805',
+      conversationId: 'test-bin-check-1',
+    });
+
+    assertSuccessResponse(response);
+    expect(response.binNumber).toBe('535805');
+    expect(response.cardType).toBeTruthy();
+    expect(response.cardAssociation).toBeTruthy();
+  });
+
+  it('should check BIN with price for installment details', async () => {
+    const response = await client.binCheck.check({
+      locale: 'tr',
+      binNumber: '535805',
+      price: 100.0,
+      conversationId: 'test-bin-check-2',
+    });
+
+    assertSuccessResponse(response);
+    expect(response.binNumber).toBe('535805');
+    if (response.installmentDetails && response.installmentDetails.length > 0) {
+      expect(response.installmentDetails[0].installmentPrices).toBeTruthy();
+    }
+  });
+
+  it('should handle invalid BIN number', async () => {
+    try {
+      const response = await client.binCheck.check({
+        locale: 'tr',
+        binNumber: '000000',
+        conversationId: 'test-bin-check-invalid',
+      });
+      // If API doesn't reject invalid BINs, verify response structure
+      expect(response).toBeDefined();
+      expect(response.status).toBeDefined();
+      // If it's a success response, verify it has expected structure
+      if (response.status === 'success') {
+        expect(response.binNumber).toBe('000000');
+      }
+    } catch (error: any) {
+      // API might return an error for invalid BIN - verify it's an Iyzico error
+      expect(error).toBeDefined();
+      expect(error).toBeInstanceOf(Error);
+      // Verify error has proper structure
+      if (error.code) {
+        expect(typeof error.code).toBe('string');
+      }
+    }
+  });
+
+  describe('Edge Cases - Invalid Fields', () => {
+    it('should handle missing binNumber', async () => {
+      try {
+        const response = await client.binCheck.check({
+          locale: 'tr',
+          binNumber: undefined as any,
+          conversationId: 'test-missing-bin',
+        });
+        expect(response).toBeDefined();
+        expect(response.status).toBeDefined();
+        if (response.status === 'failure') {
+          const errorResponse = response as unknown as ErrorResponse;
+          expect(errorResponse.errorCode || errorResponse.errorMessage).toBeTruthy();
+        }
+      } catch (error: any) {
+        expect(error).toBeDefined();
+        expect(error).toBeInstanceOf(Error);
+      }
+    });
+
+    it('should handle empty binNumber', async () => {
+      try {
+        const response = await client.binCheck.check({
+          locale: 'tr',
+          binNumber: '',
+          conversationId: 'test-empty-bin',
+        });
+        expect(response).toBeDefined();
+        expect(response.status).toBeDefined();
+        if (response.status === 'failure') {
+          const errorResponse = response as unknown as ErrorResponse;
+          expect(errorResponse.errorCode || errorResponse.errorMessage).toBeTruthy();
+        }
+      } catch (error: any) {
+        expect(error).toBeDefined();
+        expect(error).toBeInstanceOf(Error);
+      }
+    });
+
+    it('should handle binNumber that is too short', async () => {
+      try {
+        const response = await client.binCheck.check({
+          locale: 'tr',
+          binNumber: '12345', // 5 digits, should be 6
+          conversationId: 'test-short-bin',
+        });
+        expect(response).toBeDefined();
+        expect(response.status).toBeDefined();
+      } catch (error: any) {
+        expect(error).toBeDefined();
+        expect(error).toBeInstanceOf(Error);
+      }
+    });
+
+    it('should handle binNumber that is too long', async () => {
+      try {
+        const response = await client.binCheck.check({
+          locale: 'tr',
+          binNumber: '1234567', // 7 digits, should be 6
+          conversationId: 'test-long-bin',
+        });
+        expect(response).toBeDefined();
+        expect(response.status).toBeDefined();
+      } catch (error: any) {
+        expect(error).toBeDefined();
+        expect(error).toBeInstanceOf(Error);
+      }
+    });
+
+    it('should handle binNumber with non-numeric characters', async () => {
+      try {
+        const response = await client.binCheck.check({
+          locale: 'tr',
+          binNumber: 'ABC123',
+          conversationId: 'test-nonnumeric-bin',
+        });
+        expect(response).toBeDefined();
+        expect(response.status).toBeDefined();
+        if (response.status === 'failure') {
+          const errorResponse = response as unknown as ErrorResponse;
+          expect(errorResponse.errorCode || errorResponse.errorMessage).toBeTruthy();
+        }
+      } catch (error: any) {
+        expect(error).toBeDefined();
+        expect(error).toBeInstanceOf(Error);
+      }
+    });
+
+    it('should handle negative price', async () => {
+      try {
+        const response = await client.binCheck.check({
+          locale: 'tr',
+          binNumber: '535805',
+          price: -100.0,
+          conversationId: 'test-negative-price',
+        });
+        expect(response).toBeDefined();
+        expect(response.status).toBeDefined();
+        if (response.status === 'failure') {
+          const errorResponse = response as unknown as ErrorResponse;
+          expect(errorResponse.errorCode || errorResponse.errorMessage).toBeTruthy();
+        }
+      } catch (error: any) {
+        expect(error).toBeDefined();
+        expect(error).toBeInstanceOf(Error);
+      }
+    });
+
+    it('should handle zero price', async () => {
+      try {
+        const response = await client.binCheck.check({
+          locale: 'tr',
+          binNumber: '535805',
+          price: 0,
+          conversationId: 'test-zero-price',
+        });
+        expect(response).toBeDefined();
+        expect(response.status).toBeDefined();
+      } catch (error: any) {
+        expect(error).toBeDefined();
+        expect(error).toBeInstanceOf(Error);
+      }
+    });
+
+    it('should handle invalid locale', async () => {
+      try {
+        const response = await client.binCheck.check({
+          locale: 'invalid' as any,
+          binNumber: '535805',
+          conversationId: 'test-invalid-locale',
+        });
+        expect(response).toBeDefined();
+        expect(response.status).toBeDefined();
+        if (response.status === 'failure') {
+          const errorResponse = response as unknown as ErrorResponse;
+          expect(errorResponse.errorCode || errorResponse.errorMessage).toBeTruthy();
+        }
+      } catch (error: any) {
+        expect(error).toBeDefined();
+        expect(error).toBeInstanceOf(Error);
+      }
+    });
+
+    it('should handle missing locale', async () => {
+      try {
+        const response = await client.binCheck.check({
+          locale: undefined as any,
+          binNumber: '535805',
+          conversationId: 'test-missing-locale',
+        });
+        expect(response).toBeDefined();
+        expect(response.status).toBeDefined();
+      } catch (error: any) {
+        expect(error).toBeDefined();
+        expect(error).toBeInstanceOf(Error);
+      }
+    });
+  });
+});
+