CCM-12875: Added more tests for coverage

Author: ScottFullerton-NHSE

lambdas/pdm-mock-api/jest.config.ts

@@ -24,9 +24,10 @@ const config: Config = {
   },
 
   moduleNameMapper: {
+    '^utils$': '<rootDir>/../../utils/utils',
     '^handlers$': '<rootDir>/src/handlers',
-    '^utils$': '<rootDir>/src/utils',
     '^container$': '<rootDir>/src/container',
+    '^config$': '<rootDir>/src/config',
     '^authenticator$': '<rootDir>/src/authenticator',
   },
 };

lambdas/pdm-mock-api/src/__tests__/config.test.ts

@@ -0,0 +1,144 @@
+import { ParameterStoreService, loadConfig } from 'config';
+
+describe('Config', () => {
+  const originalEnv = process.env;
+
+  beforeEach(() => {
+    jest.resetModules();
+    process.env = { ...originalEnv };
+  });
+
+  afterAll(() => {
+    process.env = originalEnv;
+  });
+
+  describe('loadConfig', () => {
+    it('should load config with default values', () => {
+      delete process.env.MOCK_ACCESS_TOKEN;
+      delete process.env.ACCESS_TOKEN_SSM_PATH;
+      delete process.env.USE_NON_MOCK_TOKEN;
+      delete process.env.LOG_LEVEL;
+
+      const config = loadConfig();
+
+      expect(config.mockAccessToken).toBe('mock-token-for-local-dev');
+      expect(config.accessTokenSsmPath).toBe('/mock/access-token');
+      expect(config.useNonMockToken).toBe(false);
+      expect(config.logLevel).toBe('INFO');
+    });
+
+    it('should load config from environment variables', () => {
+      process.env.MOCK_ACCESS_TOKEN = 'custom-token';
+      process.env.ACCESS_TOKEN_SSM_PATH = '/custom/path';
+      process.env.USE_NON_MOCK_TOKEN = 'true';
+      process.env.LOG_LEVEL = 'DEBUG';
+
+      const config = loadConfig();
+
+      expect(config.mockAccessToken).toBe('custom-token');
+      expect(config.accessTokenSsmPath).toBe('/custom/path');
+      expect(config.useNonMockToken).toBe(true);
+      expect(config.logLevel).toBe('DEBUG');
+    });
+
+    it('should parse boolean environment variables correctly', () => {
+      process.env.USE_NON_MOCK_TOKEN = 'TRUE';
+      let config = loadConfig();
+      expect(config.useNonMockToken).toBe(true);
+
+      process.env.USE_NON_MOCK_TOKEN = 'false';
+      config = loadConfig();
+      expect(config.useNonMockToken).toBe(false);
+
+      process.env.USE_NON_MOCK_TOKEN = 'FALSE';
+      config = loadConfig();
+      expect(config.useNonMockToken).toBe(false);
+    });
+
+    it('should throw error for missing required env var without default', () => {
+      const config = loadConfig();
+      expect(config).toBeDefined();
+    });
+  });
+
+  describe('ParameterStoreService', () => {
+    let service: ParameterStoreService;
+
+    beforeEach(() => {
+      service = new ParameterStoreService();
+    });
+
+    it('should create an instance', () => {
+      expect(service).toBeInstanceOf(ParameterStoreService);
+    });
+
+    it('should cache parameter values', async () => {
+      const mockParameter = 'test-value';
+      const mockSend = jest.fn().mockResolvedValue({
+        Parameter: { Value: mockParameter },
+      });
+
+      (service as any).ssmClient = {
+        send: mockSend,
+      };
+
+      const result1 = await service.getParameter('/test/path');
+      expect(result1).toBe(mockParameter);
+      expect(mockSend).toHaveBeenCalledTimes(1);
+
+      const result2 = await service.getParameter('/test/path');
+      expect(result2).toBe(mockParameter);
+      expect(mockSend).toHaveBeenCalledTimes(1);
+    });
+
+    it('should refresh cache after TTL expires', async () => {
+      const mockParameter = 'test-value';
+      const mockSend = jest.fn().mockResolvedValue({
+        Parameter: { Value: mockParameter },
+      });
+
+      (service as any).ssmClient = {
+        send: mockSend,
+      };
+
+      (service as any).cacheTtl = 10;
+
+      await service.getParameter('/test/path');
+      expect(mockSend).toHaveBeenCalledTimes(1);
+
+      await new Promise((resolve) => {
+        setTimeout(resolve, 20);
+      });
+
+      await service.getParameter('/test/path');
+      expect(mockSend).toHaveBeenCalledTimes(2);
+    });
+
+    it('should throw error when parameter is not found', async () => {
+      const mockSend = jest.fn().mockResolvedValue({
+        Parameter: {},
+      });
+
+      (service as any).ssmClient = {
+        send: mockSend,
+      };
+
+      await expect(service.getParameter('/missing/path')).rejects.toThrow(
+        'Parameter /missing/path not found or has no value',
+      );
+    });
+
+    it('should handle SSM errors', async () => {
+      const mockError = new Error('SSM error');
+      const mockSend = jest.fn().mockRejectedValue(mockError);
+
+      (service as any).ssmClient = {
+        send: mockSend,
+      };
+
+      await expect(service.getParameter('/error/path')).rejects.toThrow(
+        'SSM error',
+      );
+    });
+  });
+});

lambdas/pdm-mock-api/src/__tests__/container.test.ts

@@ -0,0 +1,74 @@
+import { createContainer } from 'container';
+
+jest.mock('utils', () => ({
+  logger: {
+    debug: jest.fn(),
+    info: jest.fn(),
+    warn: jest.fn(),
+    error: jest.fn(),
+    child: jest.fn(),
+  },
+}));
+
+describe('Container', () => {
+  let container: ReturnType<typeof createContainer>;
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+    process.env.MOCK_ACCESS_TOKEN = 'test-token';
+    process.env.ACCESS_TOKEN_SSM_PATH = '/test/path';
+    process.env.USE_NON_MOCK_TOKEN = 'false';
+    process.env.LOG_LEVEL = 'INFO';
+
+    container = createContainer();
+  });
+
+  it('should create a container with all required dependencies', () => {
+    expect(container).toBeDefined();
+    expect(container.authenticator).toBeDefined();
+    expect(container.getResourceHandler).toBeDefined();
+    expect(container.createResourceHandler).toBeDefined();
+    expect(container.logger).toBeDefined();
+  });
+
+  it('should create an authenticator function', () => {
+    expect(typeof container.authenticator).toBe('function');
+  });
+
+  it('should create a getResourceHandler function', () => {
+    expect(typeof container.getResourceHandler).toBe('function');
+  });
+
+  it('should create a createResourceHandler function', () => {
+    expect(typeof container.createResourceHandler).toBe('function');
+  });
+
+  it('should provide a logger instance', () => {
+    expect(container.logger).toBeDefined();
+    expect(container.logger.info).toBeDefined();
+    expect(container.logger.warn).toBeDefined();
+    expect(container.logger.error).toBeDefined();
+    expect(container.logger.debug).toBeDefined();
+  });
+
+  it('should create handlers that can be called', async () => {
+    const mockEvent = {
+      pathParameters: { id: 'test-id' },
+      requestContext: { requestId: 'test-request' },
+    };
+
+    const result = await container.getResourceHandler(mockEvent as never);
+    expect(result).toBeDefined();
+    expect(result.statusCode).toBeDefined();
+  });
+
+  it('should create authenticator that can be called', async () => {
+    const mockEvent = {
+      headers: { Authorization: 'Bearer test-token' },
+    };
+
+    const result = await container.authenticator(mockEvent);
+    expect(result).toBeDefined();
+    expect(result.isValid).toBeDefined();
+  });
+});