@commercetools/checkout-payments-processor-sdk 0.0.6

package/src/api/handlers/payment-components.handler.test.ts

@@ -0,0 +1,378 @@
+import type { HandlerResponse } from '@api-types';
+import type { Logger } from '@logger-types';
+import {
+  PaymentComponentsHandler,
+  type PaymentComponentsIncomingHttpHeaders,
+  type PaymentComponentsOutgoingHttpHeaders,
+  type PaymentComponentsRequest,
+  type PaymentComponentsResponse,
+} from '@/api/handlers/payment-components.handler.js';
+
+// Concrete implementation for testing the abstract class
+class TestPaymentComponentsHandler extends PaymentComponentsHandler {
+  public handlePaymentComponents = vi.fn();
+}
+
+describe('PaymentComponentsHandler', () => {
+  let handler: TestPaymentComponentsHandler;
+  let mockLogger: Logger;
+
+  const mockHeaders: PaymentComponentsIncomingHttpHeaders = {
+    authorization: 'Bearer test-token',
+    'content-type': 'application/json',
+    accept: 'application/json',
+    'x-request-id': '123',
+    'x-correlation-id': '456',
+  };
+
+  const mockSuccessResponse: HandlerResponse<
+    PaymentComponentsResponse,
+    PaymentComponentsOutgoingHttpHeaders
+  > = {
+    status: 200,
+    body: {
+      dropins: [
+        {
+          type: 'embedded',
+        },
+      ],
+      components: [
+        {
+          type: 'card',
+          subtypes: ['visa', 'mastercard', 'amex'],
+        },
+        {
+          type: 'paypal',
+        },
+      ],
+      express: [],
+    },
+  };
+
+  beforeEach(() => {
+    mockLogger = {
+      error: vi.fn(),
+      info: vi.fn(),
+      debug: vi.fn(),
+      warn: vi.fn(),
+    } as unknown as Logger;
+
+    handler = new TestPaymentComponentsHandler({ logger: mockLogger });
+
+    // Set default success behavior
+    handler.handlePaymentComponents.mockResolvedValue(mockSuccessResponse);
+  });
+
+  afterEach(() => {
+    vi.clearAllMocks();
+  });
+
+  describe('Public methods', () => {
+    test('should return GET as HTTP method', () => {
+      expect(handler.method()).toBe('GET');
+    });
+
+    test('should return correct endpoint', () => {
+      expect(handler.endpoint()).toBe('/operations/payment-components');
+    });
+
+    test('should return correct auth configuration', () => {
+      const auth = handler.auth();
+      expect(auth).toEqual([
+        {
+          type: 'jwt',
+        },
+      ]);
+    });
+  });
+
+  describe('Handler method', () => {
+    describe('successful scenarios', () => {
+      test('should handle payment components request successfully with embedded dropin', async () => {
+        const request: PaymentComponentsRequest = undefined;
+
+        const result = await handler.handler({
+          request,
+          headers: mockHeaders,
+        });
+
+        expect(handler.handlePaymentComponents).toHaveBeenCalledWith({
+          headers: mockHeaders,
+        });
+        expect(result).toEqual(mockSuccessResponse);
+        expect(result.body.dropins).toHaveLength(1);
+        expect(result.body.dropins[0].type).toBe('embedded');
+        expect(result.body.components).toHaveLength(2);
+      });
+
+      test('should handle payment components request successfully with hpp dropin', async () => {
+        const request: PaymentComponentsRequest = undefined;
+        const hppResponse: HandlerResponse<
+          PaymentComponentsResponse,
+          PaymentComponentsOutgoingHttpHeaders
+        > = {
+          status: 200,
+          body: {
+            dropins: [
+              {
+                type: 'hpp',
+              },
+            ],
+            components: [],
+            express: [],
+          },
+        };
+
+        handler.handlePaymentComponents.mockResolvedValue(hppResponse);
+
+        const result = await handler.handler({
+          request,
+          headers: mockHeaders,
+        });
+
+        expect(handler.handlePaymentComponents).toHaveBeenCalledWith({
+          headers: mockHeaders,
+        });
+        expect(result.body.dropins[0].type).toBe('hpp');
+      });
+
+      test('should handle payment components request with multiple dropins', async () => {
+        const request: PaymentComponentsRequest = undefined;
+        const multipleDropinsResponse: HandlerResponse<
+          PaymentComponentsResponse,
+          PaymentComponentsOutgoingHttpHeaders
+        > = {
+          status: 200,
+          body: {
+            dropins: [
+              {
+                type: 'embedded',
+              },
+              {
+                type: 'hpp',
+              },
+            ],
+            components: [
+              {
+                type: 'card',
+                subtypes: ['visa', 'mastercard'],
+              },
+            ],
+            express: [],
+          },
+        };
+
+        handler.handlePaymentComponents.mockResolvedValue(
+          multipleDropinsResponse,
+        );
+
+        const result = await handler.handler({
+          request,
+          headers: mockHeaders,
+        });
+
+        expect(result.body.dropins).toHaveLength(2);
+        expect(result.body.dropins[0].type).toBe('embedded');
+        expect(result.body.dropins[1].type).toBe('hpp');
+      });
+
+      test('should handle payment components with components that have subtypes', async () => {
+        const request: PaymentComponentsRequest = undefined;
+
+        const result = await handler.handler({
+          request,
+          headers: mockHeaders,
+        });
+
+        expect(result.body.components[0].type).toBe('card');
+        expect(result.body.components[0].subtypes).toEqual([
+          'visa',
+          'mastercard',
+          'amex',
+        ]);
+      });
+
+      test('should handle payment components with components without subtypes', async () => {
+        const request: PaymentComponentsRequest = undefined;
+        const noSubtypesResponse: HandlerResponse<
+          PaymentComponentsResponse,
+          PaymentComponentsOutgoingHttpHeaders
+        > = {
+          status: 200,
+          body: {
+            dropins: [],
+            components: [
+              {
+                type: 'paypal',
+              },
+              {
+                type: 'googlepay',
+              },
+            ],
+            express: [],
+          },
+        };
+
+        handler.handlePaymentComponents.mockResolvedValue(noSubtypesResponse);
+
+        const result = await handler.handler({
+          request,
+          headers: mockHeaders,
+        });
+
+        expect(result.body.components).toHaveLength(2);
+        expect(result.body.components[0].subtypes).toBeUndefined();
+        expect(result.body.components[1].subtypes).toBeUndefined();
+      });
+
+      test('should handle empty dropins and components arrays', async () => {
+        const request: PaymentComponentsRequest = undefined;
+        const emptyResponse: HandlerResponse<
+          PaymentComponentsResponse,
+          PaymentComponentsOutgoingHttpHeaders
+        > = {
+          status: 200,
+          body: {
+            dropins: [],
+            components: [],
+            express: [],
+          },
+        };
+
+        handler.handlePaymentComponents.mockResolvedValue(emptyResponse);
+
+        const result = await handler.handler({
+          request,
+          headers: mockHeaders,
+        });
+
+        expect(result.body.dropins).toHaveLength(0);
+        expect(result.body.components).toHaveLength(0);
+      });
+    });
+
+    describe('error scenarios', () => {
+      test('should handle errors thrown by handlePaymentComponents', async () => {
+        const request: PaymentComponentsRequest = undefined;
+        const error = new Error('Failed to fetch payment components');
+
+        handler.handlePaymentComponents.mockRejectedValue(error);
+
+        await expect(
+          handler.handler({
+            request,
+            headers: mockHeaders,
+          }),
+        ).rejects.toThrow('Failed to fetch payment components');
+
+        expect(handler.handlePaymentComponents).toHaveBeenCalledWith({
+          headers: mockHeaders,
+        });
+      });
+
+      test('should propagate custom error from handlePaymentComponents', async () => {
+        const request: PaymentComponentsRequest = undefined;
+        class CustomError extends Error {
+          constructor(
+            message: string,
+            public statusCode: number,
+          ) {
+            super(message);
+          }
+        }
+        const customError = new CustomError('Custom error', 503);
+
+        handler.handlePaymentComponents.mockRejectedValue(customError);
+
+        await expect(
+          handler.handler({
+            request,
+            headers: mockHeaders,
+          }),
+        ).rejects.toThrow(customError);
+      });
+    });
+
+    describe('headers handling', () => {
+      test('should pass headers correctly to handlePaymentComponents', async () => {
+        const request: PaymentComponentsRequest = undefined;
+        const customHeaders: PaymentComponentsIncomingHttpHeaders = {
+          authorization: 'Bearer custom-token',
+          'content-type': 'application/json',
+          accept: 'application/json',
+          'x-request-id': 'custom-request-id',
+          'x-correlation-id': 'custom-correlation-id',
+        };
+
+        await handler.handler({
+          request,
+          headers: customHeaders,
+        });
+
+        expect(handler.handlePaymentComponents).toHaveBeenCalledWith({
+          headers: customHeaders,
+        });
+      });
+    });
+
+    describe('response structure validation', () => {
+      test('should return valid response structure with all required fields', async () => {
+        const request: PaymentComponentsRequest = undefined;
+
+        const result = await handler.handler({
+          request,
+          headers: mockHeaders,
+        });
+
+        expect(result).toHaveProperty('status');
+        expect(result).toHaveProperty('body');
+        expect(result.body).toHaveProperty('dropins');
+        expect(result.body).toHaveProperty('components');
+        expect(Array.isArray(result.body.dropins)).toBe(true);
+        expect(Array.isArray(result.body.components)).toBe(true);
+      });
+
+      test('should validate dropin type is either embedded or hpp', async () => {
+        const request: PaymentComponentsRequest = undefined;
+
+        const result = await handler.handler({
+          request,
+          headers: mockHeaders,
+        });
+
+        result.body.dropins.forEach((dropin) => {
+          expect(['embedded', 'hpp']).toContain(dropin.type);
+        });
+      });
+
+      test('should validate components have required type field', async () => {
+        const request: PaymentComponentsRequest = undefined;
+
+        const result = await handler.handler({
+          request,
+          headers: mockHeaders,
+        });
+
+        result.body.components.forEach((component) => {
+          expect(component).toHaveProperty('type');
+          expect(typeof component.type).toBe('string');
+        });
+      });
+
+      test('should validate subtypes is optional and array when present', async () => {
+        const request: PaymentComponentsRequest = undefined;
+
+        const result = await handler.handler({
+          request,
+          headers: mockHeaders,
+        });
+
+        result.body.components.forEach((component) => {
+          if (component.subtypes !== undefined) {
+            expect(Array.isArray(component.subtypes)).toBe(true);
+          }
+        });
+      });
+    });
+  });
+});

package/src/api/handlers/payment-components.handler.ts

@@ -0,0 +1,80 @@
+import type {
+  AuthType,
+  BaseIncomingHttpHeaders,
+  BaseOutgoingHttpHeaders,
+  HandlerResponse,
+  RouteHandler,
+} from '@api-types';
+import type { PaymentMethodType } from '@commercetools/checkout-payments-core';
+import type { Logger } from '@/logger/types.js';
+
+export type PaymentComponentsRequest = undefined;
+
+export type PaymentComponentsResponse = {
+  dropins: {
+    type: 'embedded' | 'hpp';
+  }[];
+  components: {
+    subtypes?: string[] | undefined;
+    type: PaymentMethodType;
+  }[];
+  express: {
+    type: string;
+  }[];
+};
+
+export type PaymentComponentsIncomingHttpHeaders = BaseIncomingHttpHeaders & {};
+
+export type PaymentComponentsOutgoingHttpHeaders = BaseOutgoingHttpHeaders & {};
+
+export abstract class PaymentComponentsHandler
+  implements
+    RouteHandler<
+      PaymentComponentsRequest,
+      PaymentComponentsResponse,
+      PaymentComponentsIncomingHttpHeaders,
+      PaymentComponentsOutgoingHttpHeaders
+    >
+{
+  public readonly logger: Logger;
+  public constructor(opts: { logger: Logger }) {
+    this.logger = opts.logger;
+  }
+
+  public method() {
+    return 'GET';
+  }
+
+  public endpoint() {
+    return '/operations/payment-components';
+  }
+
+  public auth(): AuthType[] {
+    return [
+      {
+        type: 'jwt',
+      },
+    ];
+  }
+
+  public async handler(opts: {
+    request: PaymentComponentsRequest;
+    headers: PaymentComponentsIncomingHttpHeaders;
+  }): Promise<
+    HandlerResponse<
+      PaymentComponentsResponse,
+      PaymentComponentsOutgoingHttpHeaders
+    >
+  > {
+    return await this.handlePaymentComponents({ headers: opts.headers });
+  }
+
+  public abstract handlePaymentComponents(opts: {
+    headers: PaymentComponentsIncomingHttpHeaders;
+  }): Promise<
+    HandlerResponse<
+      PaymentComponentsResponse,
+      PaymentComponentsOutgoingHttpHeaders
+    >
+  >;
+}