add tests

Author: npalm

lambdas/functions/webhook/src/ConfigLoader.test.ts

@@ -2,6 +2,7 @@ import { getParameter } from '@aws-github-runner/aws-ssm-util';
 import { ConfigWebhook, ConfigWebhookEventBridge, ConfigDispatcher } from './ConfigLoader';
 import { mocked } from 'jest-mock';
 import { logger } from '@aws-github-runner/aws-powertools-util';
+import { MatcherConfig, RunnerMatcherConfig } from './sqs';
 
 jest.mock('@aws-github-runner/aws-ssm-util');
 
@@ -93,7 +94,7 @@ describe('ConfigLoader Tests', () => {
   describe('ConfigWebhook', () => {
     it('should load config successfully', async () => {
       process.env.REPOSITORY_ALLOW_LIST = '["repo1", "repo2"]';
-      process.env.WORKFLOW_JOB_EVENT_SECONDARY_QUEUE = 'secondary-queue';
+      process.env.SQS_WORKFLOW_JOB_QUEUE = 'secondary-queue';
       process.env.PARAMETER_RUNNER_MATCHER_CONFIG_PATH = '/path/to/matcher/config';
       process.env.PARAMETER_GITHUB_APP_WEBHOOK_SECRET = '/path/to/webhook/secret';
       const matcherConfig = [
@@ -209,18 +210,17 @@ describe('ConfigLoader Tests', () => {
       process.env.REPOSITORY_ALLOW_LIST = '["repo1", "repo2"]';
       process.env.PARAMETER_RUNNER_MATCHER_CONFIG_PATH = '/path/to/matcher/config';
 
-      const matcherConfig = [
+      const matcherConfig: RunnerMatcherConfig[] = [
         {
-          id: '1',
-          arn: 'arn:aws:sqs:us-east-1:123456789012:queue1',
-          fifo: false,
+          arn: 'arn:aws:sqs:eu-central-1:123456:npalm-default-queued-builds',
+          fifo: true,
+          id: 'https://sqs.eu-central-1.amazonaws.com/123456/npalm-default-queued-builds',
           matcherConfig: {
-            labelMatchers: [['label1', 'label2']],
             exactMatch: true,
+            labelMatchers: [['default', 'example', 'linux', 'self-hosted', 'x64']],
           },
         },
       ];
-
       mocked(getParameter).mockImplementation(async (paramPath: string) => {
         if (paramPath === '/path/to/matcher/config') {
           return JSON.stringify(matcherConfig);
@@ -243,5 +243,20 @@ describe('ConfigLoader Tests', () => {
         'Failed to load config: Failed to load parameter for matcherConfig from path undefined: Parameter undefined not found',
       );
     });
+
+    it('should throw an error if runner matcher config is empty.', async () => {
+      process.env.REPOSITORY_ALLOW_LIST = '["repo1", "repo2"]';
+      process.env.PARAMETER_RUNNER_MATCHER_CONFIG_PATH = '/path/to/matcher/config';
+
+      mocked(getParameter).mockImplementation(async (paramPath: string) => {
+        if (paramPath === '/path/to/matcher/config') {
+          return JSON.stringify('');
+        }
+        return '';
+      });
+
+      await expect(ConfigDispatcher.load()).rejects.toThrow('ailed to load config: Matcher config is empty');
+
+    });
   });
 });

lambdas/functions/webhook/src/ConfigLoader.ts

@@ -86,7 +86,7 @@ export class ConfigWebhook extends BaseConfig {
 
   async loadConfig(): Promise<void> {
     this.loadEnvVar(process.env.REPOSITORY_ALLOW_LIST, 'repositoryAllowList', []);
-    this.loadEnvVar(process.env.WORKFLOW_JOB_EVENT_SECONDARY_QUEUE, 'workflowJobEventSecondaryQueue', '');
+    this.loadEnvVar(process.env.SQS_WORKFLOW_JOB_QUEUE, 'workflowJobEventSecondaryQueue', '');
 
     await Promise.all([
       this.loadParameter<MatcherConfig[]>(process.env.PARAMETER_RUNNER_MATCHER_CONFIG_PATH, 'matcherConfig'),
@@ -110,9 +110,15 @@ export class ConfigWebhookEventBridge extends BaseConfig {
 export class ConfigDispatcher extends BaseConfig {
   repositoryAllowList: string[] = [];
   matcherConfig: RunnerMatcherConfig[] = [];
+  workflowJobEventSecondaryQueue: string = ''; // Deprecated, not loaded
 
   async loadConfig(): Promise<void> {
     this.loadEnvVar(process.env.REPOSITORY_ALLOW_LIST, 'repositoryAllowList', []);
     await this.loadParameter<MatcherConfig[]>(process.env.PARAMETER_RUNNER_MATCHER_CONFIG_PATH, 'matcherConfig');
+
+    // check matcherConfig object is not empty
+    if (this.matcherConfig.length === 0) {
+      this.configLoadingErrors.push('Matcher config is empty');
+    }
   }
 }

lambdas/functions/webhook/src/ConfigResolver.ts

@@ -1,11 +1,15 @@
 import { logger } from '@aws-github-runner/aws-powertools-util';
 import { APIGatewayEvent, Context } from 'aws-lambda';
 import { mocked } from 'jest-mock';
+import { WorkflowJobEvent } from '@octokit/webhooks-types';
 
-import { githubWebhook } from './lambda';
-import { handle } from './webhook';
+import { dispatchToRunners, eventBridgeWebhook, githubWebhook } from './lambda';
+import { handle, publishOnEventBridge } from './webhook';
 import ValidationError from './ValidationError';
 import { getParameter } from '@aws-github-runner/aws-ssm-util';
+import { dispatch } from './runners/dispatch';
+import { EventWrapper } from './types';
+import { rejects } from 'assert';
 
 const event: APIGatewayEvent = {
   body: JSON.stringify(''),
@@ -73,40 +77,132 @@ const context: Context = {
   },
 };
 
+
+jest.mock('./runners/dispatch');
 jest.mock('./webhook');
 jest.mock('@aws-github-runner/aws-ssm-util');
 
-describe('Test scale up lambda wrapper.', () => {
+describe('Test webhook lambda wrapper.', () => {
   beforeEach(() => {
+    // We mock all SSM request to resolve to a non empty array. Since we mock all implemeantions
+    // relying on the config opbject that is enought to test the handlers.
     const mockedGet = mocked(getParameter);
-    mockedGet.mockResolvedValue('[]');
+    mockedGet.mockResolvedValue('["abc"]');
+    jest.clearAllMocks();
   });
-  it('Happy flow, resolve.', async () => {
-    const mock = mocked(handle);
-    mock.mockImplementation(() => {
-      return new Promise((resolve) => {
-        resolve({ body: 'test', statusCode: 200 });
+
+  describe('Test webhook lambda wrapper.', () => {
+    it('Happy flow, resolve.', async () => {
+      const mock = mocked(handle);
+      mock.mockImplementation(() => {
+        return new Promise((resolve) => {
+          resolve({ body: 'test', statusCode: 200 });
+        });
       });
+
+      const result = await githubWebhook(event, context);
+      expect(result).toEqual({ body: 'test', statusCode: 200 });
     });
 
-    const result = await githubWebhook(event, context);
-    expect(result).toEqual({ body: 'test', statusCode: 200 });
+    it('An expected error, resolve.', async () => {
+      const mock = mocked(handle);
+      mock.mockRejectedValue(new ValidationError(400, 'some error'));
+
+      const result = await githubWebhook(event, context);
+      expect(result).toMatchObject({ body: 'some error', statusCode: 400 });
+    });
+
+    it('Errors are not thrown.', async () => {
+      const mock = mocked(handle);
+      const logSpy = jest.spyOn(logger, 'error');
+      mock.mockRejectedValue(new Error('some error'));
+      const result = await githubWebhook(event, context);
+      expect(result).toMatchObject({ body: 'Check the Lambda logs for the error details.', statusCode: 500 });
+      expect(logSpy).toHaveBeenCalledTimes(1);
+    });
   });
 
-  it('An expected error, resolve.', async () => {
-    const mock = mocked(handle);
-    mock.mockRejectedValue(new ValidationError(400, 'some error'));
 
-    const result = await githubWebhook(event, context);
-    expect(result).toMatchObject({ body: 'some error', statusCode: 400 });
+
+  describe('Lmmbda eventBridgeWebhook.', () => {
+    beforeEach(() => {
+      process.env.EVENT_BUS_NAME = 'test';
+    });
+
+    it('Happy flow, resolve.', async () => {
+      const mock = mocked(publishOnEventBridge);
+      mock.mockImplementation(() => {
+        return new Promise((resolve) => {
+          resolve({ body: 'test', statusCode: 200 });
+        });
+      });
+
+      const result = await eventBridgeWebhook(event, context);
+      expect(result).toEqual({ body: 'test', statusCode: 200 });
+    });
+
+
+    it('Reject events .', async () => {
+      const mock = mocked(publishOnEventBridge);
+      mock.mockRejectedValue(new Error('some error'));
+
+      mock.mockRejectedValue(new ValidationError(400, 'some error'));
+
+      const result = await eventBridgeWebhook(event, context);
+      expect(result).toMatchObject({ body: 'some error', statusCode: 400 });
+    });
+
+    it('Errors are not thrown.', async () => {
+      const mock = mocked(publishOnEventBridge);
+      const logSpy = jest.spyOn(logger, 'error');
+      mock.mockRejectedValue(new Error('some error'));
+      const result = await eventBridgeWebhook(event, context);
+      expect(result).toMatchObject({ body: 'Check the Lambda logs for the error details.', statusCode: 500 });
+      expect(logSpy).toHaveBeenCalledTimes(1);
+    });
   });
 
-  it('Errors are not thrown.', async () => {
-    const mock = mocked(handle);
-    const logSpy = jest.spyOn(logger, 'error');
-    mock.mockRejectedValue(new Error('some error'));
-    const result = await githubWebhook(event, context);
-    expect(result).toMatchObject({ body: 'Check the Lambda logs for the error details.', statusCode: 500 });
-    expect(logSpy).toHaveBeenCalledTimes(1);
+  describe('Lmmbda dispatchToRunners.', () => {
+    it('Happy flow, resolve.', async () => {
+      const mock = mocked(dispatch);
+      mock.mockImplementation(() => {
+        return new Promise((resolve) => {
+          resolve({ body: 'test', statusCode: 200 });
+        });
+      });
+
+      const testEvent = {
+        'detail-type': 'workflow_job',
+      } as unknown as EventWrapper<WorkflowJobEvent>;
+
+      await expect(dispatchToRunners(testEvent, context)).resolves.not.toThrow();
+    });
+
+    it('Rejects non workflow_job events.', async () => {
+      const mock = mocked(dispatch);
+      mock.mockImplementation(() => {
+        return new Promise((resolve) => {
+          resolve({ body: 'test', statusCode: 200 });
+        });
+      });
+
+      const testEvent = {
+        'detail-type': 'non_workflow_job',
+      } as unknown as EventWrapper<WorkflowJobEvent>;
+
+      await expect(dispatchToRunners(testEvent, context)).rejects.toThrow('Incorrect Event detail-type only workflow_job is accepted');
+    });
+
+
+    it('Rejects any event causing an error.', async () => {
+      const mock = mocked(dispatch);
+      mock.mockRejectedValue(new Error('some error'));
+
+      const testEvent = {
+        'detail-type': 'workflow_job',
+      } as unknown as EventWrapper<WorkflowJobEvent>;
+
+      await expect(dispatchToRunners(testEvent, context)).rejects.toThrow();
+    });
   });
 });

lambdas/functions/webhook/src/lambda.test.ts

@@ -2,13 +2,13 @@ import middy from '@middy/core';
 import { logger, setContext, captureLambdaHandler, tracer } from '@aws-github-runner/aws-powertools-util';
 import { APIGatewayEvent, Context } from 'aws-lambda';
 
-import { handle, publishOnEventBridge, dispatchToRunners } from './webhook';
-import { Config } from './ConfigResolver';
+import { handle, publishOnEventBridge } from './webhook';
 import { IncomingHttpHeaders } from 'http';
 import ValidationError from './ValidationError';
 import { EventWrapper } from './types';
 import { WorkflowJobEvent } from '@octokit/webhooks-types';
-import { ConfigWebhook, ConfigWebhookEventBridge } from './ConfigLoader';
+import { ConfigDispatcher, ConfigWebhook, ConfigWebhookEventBridge } from './ConfigLoader';
+import { dispatch } from './runners/dispatch';
 
 export interface Response {
   statusCode: number;
@@ -19,13 +19,11 @@ middy(githubWebhook).use(captureLambdaHandler(tracer));
 
 export async function githubWebhook(event: APIGatewayEvent, context: Context): Promise<Response> {
   setContext(context, 'lambda.ts');
-  const config = await Config.load();
-
   logger.logEventIfEnabled(event);
-  logger.debug('Loading config', { config });
 
   let result: Response;
   try {
+    const config: ConfigWebhook = await ConfigWebhook.load();
     result = await handle(headersToLowerCase(event.headers), event.body as string, config);
   } catch (e) {
     logger.error(`Failed to handle webhook event`, { error: e });
@@ -46,13 +44,11 @@ export async function githubWebhook(event: APIGatewayEvent, context: Context): P
 
 export async function eventBridgeWebhook(event: APIGatewayEvent, context: Context): Promise<Response> {
   setContext(context, 'lambda.ts');
-  const config: ConfigWebhookEventBridge = await ConfigWebhookEventBridge.load();
-
   logger.logEventIfEnabled(event);
-  logger.debug('Loading config', { config });
 
   let result: Response;
   try {
+    const config: ConfigWebhookEventBridge = await ConfigWebhookEventBridge.load();
     result = await publishOnEventBridge(headersToLowerCase(event.headers), event.body as string, config);
   } catch (e) {
     logger.error(`Failed to handle webhook event`, { error: e });
@@ -71,17 +67,22 @@ export async function eventBridgeWebhook(event: APIGatewayEvent, context: Contex
   return result;
 }
 
-export async function workflowJob(event: EventWrapper<WorkflowJobEvent>, context: Context): Promise<void> {
+export async function dispatchToRunners(event: EventWrapper<WorkflowJobEvent>, context: Context): Promise<void> {
   setContext(context, 'lambda.ts');
-  const config = await Config.load();
-
   logger.logEventIfEnabled(event);
-  logger.debug('Loading config', { config });
+
+  const eventType = event['detail-type'];
+  if (eventType != 'workflow_job') {
+    logger.debug('Wrong event type received. Unable to process event', { event });
+    throw new Error('Incorrect Event detail-type only workflow_job is accepted');
+  }
 
   try {
-    await dispatchToRunners(event, config);
+    const config: ConfigDispatcher = await ConfigDispatcher.load();
+    await dispatch(event.detail, eventType, config);
   } catch (e) {
     logger.error(`Failed to handle webhook event`, { error: e });
+    throw e;
   }
 }