@commercetools/checkout-payments-processor-sdk 0.0.6

package/src/api/handlers/status.handler.test.ts

@@ -0,0 +1,551 @@
+import type { Logger } from '@logger-types';
+import type { AuthorizationService } from '@security-types';
+import {
+  type HealthCheck,
+  healthCheckCommercetoolsPermissions,
+  type StatusConfig,
+  StatusHandler,
+  type StatusIncomingHttpHeaders,
+  type StatusRequest,
+} from '@/api/handlers/status.handler.js';
+
+// Concrete implementation for testing the abstract class
+class TestStatusHandler extends StatusHandler {
+  private statusConfig: StatusConfig;
+
+  constructor(opts: { logger: Logger; statusConfig: StatusConfig }) {
+    super({ logger: opts.logger });
+    this.statusConfig = opts.statusConfig;
+  }
+
+  public handleStatus(): StatusConfig {
+    return this.statusConfig;
+  }
+}
+
+describe('StatusHandler', () => {
+  let handler: TestStatusHandler;
+  let mockLogger: Logger;
+  let mockHealthCheck1: HealthCheck;
+  let mockHealthCheck2: HealthCheck;
+  let mockMetadataFn: () => Promise<object>;
+
+  const mockHeaders: StatusIncomingHttpHeaders = {
+    authorization: 'Bearer test-token',
+    'content-type': 'application/json',
+    accept: 'application/json',
+    'x-request-id': '123',
+    'x-correlation-id': '456',
+  };
+
+  beforeEach(() => {
+    mockLogger = {
+      error: vi.fn(),
+      info: vi.fn(),
+      debug: vi.fn(),
+      warn: vi.fn(),
+    } as unknown as Logger;
+
+    mockHealthCheck1 = vi.fn();
+    mockHealthCheck2 = vi.fn();
+    mockMetadataFn = vi.fn();
+
+    // Set default success behavior
+    vi.mocked(mockHealthCheck1).mockResolvedValue({
+      name: 'test-check-1',
+      status: 'UP',
+      details: { test: 'details' },
+    });
+
+    vi.mocked(mockHealthCheck2).mockResolvedValue({
+      name: 'test-check-2',
+      status: 'UP',
+    });
+
+    vi.mocked(mockMetadataFn).mockResolvedValue({ env: 'test' });
+
+    const defaultStatusConfig: StatusConfig = {
+      timeout: 5000,
+      checks: [mockHealthCheck1, mockHealthCheck2],
+      metadataFn: mockMetadataFn,
+      log: mockLogger,
+    };
+
+    handler = new TestStatusHandler({
+      logger: mockLogger,
+      statusConfig: defaultStatusConfig,
+    });
+
+    // Reset environment variable
+    delete process.env.npm_package_version;
+  });
+
+  describe('Basic handler methods', () => {
+    it('should return GET method', () => {
+      expect(handler.method()).toBe('GET');
+    });
+
+    it('should return correct endpoint', () => {
+      expect(handler.endpoint()).toBe('/operations/status');
+    });
+
+    it('should return JWT auth configuration', () => {
+      const authConfig = handler.auth();
+      expect(authConfig).toEqual([{ type: 'jwt' }]);
+    });
+  });
+
+  describe('handler method', () => {
+    const mockRequest: StatusRequest = undefined;
+
+    describe('successful scenarios', () => {
+      it('should return OK status when all checks pass', async () => {
+        const result = await handler.handler({
+          request: mockRequest,
+          headers: mockHeaders,
+        });
+
+        expect(result.status).toBe(200);
+        expect(result.body.status).toBe('OK');
+        expect(result.body.checks).toHaveLength(2);
+        expect(result.body.checks[0]).toEqual({
+          name: 'test-check-1',
+          status: 'UP',
+          details: { test: 'details' },
+        });
+        expect(result.body.checks[1]).toEqual({
+          name: 'test-check-2',
+          status: 'UP',
+        });
+        expect(result.body.timestamp).toBeDefined();
+        expect(result.body.version).toBe('0.0.0');
+        expect(result.body.metadata).toEqual({ env: 'test' });
+      });
+
+      it('should use npm_package_version if available', async () => {
+        process.env.npm_package_version = '1.2.3';
+
+        const result = await handler.handler({
+          request: mockRequest,
+          headers: mockHeaders,
+        });
+
+        expect(result.body.version).toBe('1.2.3');
+      });
+
+      it('should work without metadata function', async () => {
+        const configWithoutMetadata: StatusConfig = {
+          timeout: 5000,
+          checks: [mockHealthCheck1],
+          log: mockLogger,
+        };
+
+        const handlerWithoutMetadata = new TestStatusHandler({
+          logger: mockLogger,
+          statusConfig: configWithoutMetadata,
+        });
+
+        const result = await handlerWithoutMetadata.handler({
+          request: mockRequest,
+          headers: mockHeaders,
+        });
+
+        expect(result.status).toBe(200);
+        expect(result.body.metadata).toBeUndefined();
+        expect(mockMetadataFn).not.toHaveBeenCalled();
+      });
+
+      it('should return unavailable with empty checks array', async () => {
+        const configWithNoChecks: StatusConfig = {
+          timeout: 5000,
+          checks: [],
+          log: mockLogger,
+        };
+
+        const handlerWithNoChecks = new TestStatusHandler({
+          logger: mockLogger,
+          statusConfig: configWithNoChecks,
+        });
+
+        const result = await handlerWithNoChecks.handler({
+          request: mockRequest,
+          headers: mockHeaders,
+        });
+
+        expect(result.status).toBe(503);
+        expect(result.body.status).toBe('Unavailable');
+        expect(result.body.checks).toHaveLength(0);
+      });
+    });
+
+    describe('partial failure scenarios', () => {
+      it('should return Partially Available when some checks fail', async () => {
+        vi.mocked(mockHealthCheck1).mockResolvedValue({
+          name: 'test-check-1',
+          status: 'DOWN',
+          message: 'Test failure message',
+          details: { error: 'test error' },
+        });
+
+        const result = await handler.handler({
+          request: mockRequest,
+          headers: mockHeaders,
+        });
+
+        expect(result.status).toBe(200);
+        expect(result.body.status).toBe('Partially Available');
+        expect(result.body.checks).toHaveLength(2);
+        expect(result.body.checks[0].status).toBe('DOWN');
+        expect(result.body.checks[1].status).toBe('UP');
+
+        // Verify error logging
+        expect(mockLogger.error).toHaveBeenCalledWith(
+          { details: { error: 'test error' } },
+          'Test failure message',
+        );
+      });
+
+      it('should log default message when no message provided for failed check', async () => {
+        vi.mocked(mockHealthCheck1).mockResolvedValue({
+          name: 'test-check-1',
+          status: 'DOWN',
+          details: { error: 'test error' },
+        });
+
+        await handler.handler({
+          request: mockRequest,
+          headers: mockHeaders,
+        });
+
+        expect(mockLogger.error).toHaveBeenCalledWith(
+          { details: { error: 'test error' } },
+          'Health check for test-check-1 failed, check details',
+        );
+      });
+    });
+
+    describe('complete failure scenarios', () => {
+      it('should return Unavailable when all checks fail', async () => {
+        vi.mocked(mockHealthCheck1).mockResolvedValue({
+          name: 'test-check-1',
+          status: 'DOWN',
+          message: 'Check 1 failed',
+        });
+
+        vi.mocked(mockHealthCheck2).mockResolvedValue({
+          name: 'test-check-2',
+          status: 'DOWN',
+          message: 'Check 2 failed',
+        });
+
+        const result = await handler.handler({
+          request: mockRequest,
+          headers: mockHeaders,
+        });
+
+        expect(result.status).toBe(503);
+        expect(result.body.status).toBe('Unavailable');
+        expect(result.body.checks).toHaveLength(2);
+        expect(result.body.checks[0].status).toBe('DOWN');
+        expect(result.body.checks[1].status).toBe('DOWN');
+      });
+    });
+
+    describe('timeout scenarios', () => {
+      it('should handle timeout and return Unavailable', async () => {
+        const slowHealthCheck = vi.fn().mockImplementation(
+          () =>
+            new Promise((resolve) =>
+              setTimeout(
+                () =>
+                  resolve({
+                    name: 'slow-check',
+                    status: 'UP',
+                  }),
+                100,
+              ),
+            ),
+        );
+
+        const timeoutConfig: StatusConfig = {
+          timeout: 50, // Short timeout
+          checks: [slowHealthCheck],
+          log: mockLogger,
+        };
+
+        const timeoutHandler = new TestStatusHandler({
+          logger: mockLogger,
+          statusConfig: timeoutConfig,
+        });
+
+        const result = await timeoutHandler.handler({
+          request: mockRequest,
+          headers: mockHeaders,
+        });
+
+        expect(result.status).toBe(503);
+        expect(result.body.status).toBe('Unavailable');
+        expect(result.body.checks).toHaveLength(0);
+        expect(slowHealthCheck).toHaveBeenCalled();
+      });
+
+      it('should handle non-timeout errors', async () => {
+        const errorHealthCheck = vi
+          .fn()
+          .mockRejectedValue(new Error('Custom error'));
+
+        const errorConfig: StatusConfig = {
+          timeout: 5000,
+          checks: [errorHealthCheck],
+          log: mockLogger,
+        };
+
+        const errorHandler = new TestStatusHandler({
+          logger: mockLogger,
+          statusConfig: errorConfig,
+        });
+
+        const result = await errorHandler.handler({
+          request: mockRequest,
+          headers: mockHeaders,
+        });
+
+        expect(result.status).toBe(503);
+        expect(result.body.status).toBe('Unavailable');
+        expect(result.body.checks).toHaveLength(0);
+      });
+
+      it('should log timeout errors specifically', async () => {
+        // Create a timeout error that matches exactly what the code expects
+        const timeoutError = new Error('Timeout');
+
+        const errorConfig: StatusConfig = {
+          timeout: 5000,
+          checks: [vi.fn().mockRejectedValue(timeoutError)],
+          log: mockLogger,
+        };
+
+        const errorHandler = new TestStatusHandler({
+          logger: mockLogger,
+          statusConfig: errorConfig,
+        });
+
+        const result = await errorHandler.handler({
+          request: mockRequest,
+          headers: mockHeaders,
+        });
+
+        expect(result.status).toBe(503);
+        expect(result.body.status).toBe('Unavailable');
+        expect(mockLogger.error).toHaveBeenCalledWith(
+          { err: timeoutError },
+          'Health check timed out',
+        );
+      });
+    });
+  });
+});
+
+describe('healthCheckCommercetoolsPermissions', () => {
+  let mockAuthService: AuthorizationService;
+  const projectKey = 'test-project';
+  const requiredPermissions = ['manage_payments', 'view_customers'];
+
+  beforeEach(() => {
+    mockAuthService = {
+      getAccessToken: vi.fn(),
+    } as unknown as AuthorizationService;
+  });
+
+  describe('successful permission checks', () => {
+    it('should return UP when manage_project permission is available', async () => {
+      const mockToken = {
+        access_token: 'test-token',
+        token_type: 'Bearer',
+        scope: `manage_project:${projectKey} other_scope`,
+        expires_in: 3600,
+      };
+      vi.mocked(mockAuthService.getAccessToken).mockResolvedValue(mockToken);
+
+      const healthCheck = healthCheckCommercetoolsPermissions({
+        ctAuthorizationService: mockAuthService,
+        projectKey,
+        requiredPermissions,
+      });
+
+      const result = await healthCheck();
+
+      expect(result).toEqual({
+        name: 'commercetools permissions',
+        status: 'UP',
+        details: {
+          scope: mockToken.scope,
+        },
+      });
+    });
+
+    it('should return UP when all required permissions are available', async () => {
+      const mockToken = {
+        access_token: 'test-token',
+        token_type: 'Bearer',
+        scope: `manage_payments:${projectKey} view_customers:${projectKey} other_scope`,
+        expires_in: 3600,
+      };
+      vi.mocked(mockAuthService.getAccessToken).mockResolvedValue(mockToken);
+
+      const healthCheck = healthCheckCommercetoolsPermissions({
+        ctAuthorizationService: mockAuthService,
+        projectKey,
+        requiredPermissions,
+      });
+
+      const result = await healthCheck();
+
+      expect(result).toEqual({
+        name: 'commercetools permissions',
+        status: 'UP',
+        details: {
+          scope: mockToken.scope,
+        },
+      });
+    });
+
+    it('should return UP when some required permissions and manage_project are available', async () => {
+      const mockToken = {
+        access_token: 'test-token',
+        token_type: 'Bearer',
+        scope: `manage_project:${projectKey} view_customers:${projectKey}`,
+        expires_in: 3600,
+      };
+      vi.mocked(mockAuthService.getAccessToken).mockResolvedValue(mockToken);
+
+      const healthCheck = healthCheckCommercetoolsPermissions({
+        ctAuthorizationService: mockAuthService,
+        projectKey,
+        requiredPermissions,
+      });
+
+      const result = await healthCheck();
+
+      expect(result.status).toBe('UP');
+    });
+  });
+
+  describe('failed permission checks', () => {
+    it('should return DOWN when required permissions are missing', async () => {
+      const mockToken = {
+        access_token: 'test-token',
+        token_type: 'Bearer',
+        scope: 'other_scope manage_payments:other-project',
+        expires_in: 3600,
+      };
+      vi.mocked(mockAuthService.getAccessToken).mockResolvedValue(mockToken);
+
+      const healthCheck = healthCheckCommercetoolsPermissions({
+        ctAuthorizationService: mockAuthService,
+        projectKey,
+        requiredPermissions,
+      });
+
+      const result = await healthCheck();
+
+      expect(result).toEqual({
+        name: 'commercetools permissions',
+        status: 'DOWN',
+        message: `commercetools permissions are not correct, expected scopes: ${requiredPermissions.join(' ')}, actual scopes: ${mockToken.scope}`,
+        details: {
+          expectedScopes: requiredPermissions,
+          actualScopes: mockToken.scope,
+          reason: 'scopes not available',
+        },
+      });
+    });
+
+    it('should return DOWN when only some required permissions are available', async () => {
+      const mockToken = {
+        access_token: 'test-token',
+        token_type: 'Bearer',
+        scope: `manage_payments:${projectKey} other_scope`,
+        expires_in: 3600,
+      };
+      vi.mocked(mockAuthService.getAccessToken).mockResolvedValue(mockToken);
+
+      const healthCheck = healthCheckCommercetoolsPermissions({
+        ctAuthorizationService: mockAuthService,
+        projectKey,
+        requiredPermissions,
+      });
+
+      const result = await healthCheck();
+
+      expect(result.status).toBe('DOWN');
+      expect(result.message).toContain(
+        'commercetools permissions are not correct',
+      );
+    });
+
+    it('should return DOWN when API call fails', async () => {
+      const error = new Error('API Error');
+      vi.mocked(mockAuthService.getAccessToken).mockRejectedValue(error);
+
+      const healthCheck = healthCheckCommercetoolsPermissions({
+        ctAuthorizationService: mockAuthService,
+        projectKey,
+        requiredPermissions,
+      });
+
+      const result = await healthCheck();
+
+      expect(result).toEqual({
+        name: 'commercetools permissions',
+        status: 'DOWN',
+        message: 'Not able to talk with commercetools API',
+        details: {
+          error,
+        },
+      });
+    });
+  });
+
+  describe('edge cases', () => {
+    it('should handle empty required permissions array', async () => {
+      const mockToken = {
+        access_token: 'test-token',
+        token_type: 'Bearer',
+        scope: 'some_scope',
+        expires_in: 3600,
+      };
+      vi.mocked(mockAuthService.getAccessToken).mockResolvedValue(mockToken);
+
+      const healthCheck = healthCheckCommercetoolsPermissions({
+        ctAuthorizationService: mockAuthService,
+        projectKey,
+        requiredPermissions: [],
+      });
+
+      const result = await healthCheck();
+
+      expect(result.status).toBe('UP');
+    });
+
+    it('should handle scope with extra spaces', async () => {
+      const mockToken = {
+        access_token: 'test-token',
+        token_type: 'Bearer',
+        scope: `  manage_payments:${projectKey}   view_customers:${projectKey}  `,
+        expires_in: 3600,
+      };
+      vi.mocked(mockAuthService.getAccessToken).mockResolvedValue(mockToken);
+
+      const healthCheck = healthCheckCommercetoolsPermissions({
+        ctAuthorizationService: mockAuthService,
+        projectKey,
+        requiredPermissions,
+      });
+
+      const result = await healthCheck();
+
+      expect(result.status).toBe('UP');
+    });
+  });
+});