tests: improved unit tests

packages/batch/src/AsyncBatchProcessor.ts

@@ -24,7 +24,7 @@ class AsyncBatchProcessor extends BasePartialBatchProcessor {
    * @returns response of success or failure
    */
   public processRecord(_record: BaseRecord): SuccessResponse | FailureResponse {
-    throw new Error('Not implemented. Use processAsync() instead.');
+    throw new Error('Not implemented. Use asyncProcess() instead.');
   }
 }
 

packages/batch/src/BasePartialProcessor.ts

@@ -34,6 +34,31 @@ abstract class BasePartialProcessor {
     this.handler = new Function();
   }
 
+  /**
+   * Call instance's handler for each record
+   * @returns List of processed records
+   */
+  public async asyncProcess(): Promise<(SuccessResponse | FailureResponse)[]> {
+    /**
+     * If this is an sync processor, user should have called process instead,
+     * so we call the method early to throw the error early thus failing fast.
+     */
+    if (this.constructor.name === 'BatchProcessor') {
+      await this.asyncProcessRecord(this.records[0]);
+    }
+    this.prepare();
+
+    const processingPromises: Promise<SuccessResponse | FailureResponse>[] =
+      this.records.map((record) => this.asyncProcessRecord(record));
+
+    const processedRecords: (SuccessResponse | FailureResponse)[] =
+      await Promise.all(processingPromises);
+
+    this.clean();
+
+    return processedRecords;
+  }
+
   /**
    * Process a record with an asyncronous handler
    *
@@ -94,31 +119,6 @@ abstract class BasePartialProcessor {
     return processedRecords;
   }
 
-  /**
-   * Call instance's handler for each record
-   * @returns List of processed records
-   */
-  public async processAsync(): Promise<(SuccessResponse | FailureResponse)[]> {
-    /**
-     * If this is an sync processor, user should have called process instead,
-     * so we call the method early to throw the error early thus failing fast.
-     */
-    if (this.constructor.name === 'BatchProcessor') {
-      await this.asyncProcessRecord(this.records[0]);
-    }
-    this.prepare();
-
-    const processingPromises: Promise<SuccessResponse | FailureResponse>[] =
-      this.records.map((record) => this.asyncProcessRecord(record));
-
-    const processedRecords: (SuccessResponse | FailureResponse)[] =
-      await Promise.all(processingPromises);
-
-    this.clean();
-
-    return processedRecords;
-  }
-
   /**
    * Process a record with the handler
    * @param record Record to be processed

packages/batch/src/asyncProcessPartialResponse.ts

@@ -30,7 +30,7 @@ const asyncProcessPartialResponse = async (
 
   processor.register(event.Records, recordHandler, options);
 
-  await processor.processAsync();
+  await processor.asyncProcess();
 
   return processor.response();
 };

packages/batch/tests/helpers/handlers.ts

@@ -80,6 +80,23 @@ const handlerWithContext = (
   return record.body;
 };
 
+const asyncHandlerWithContext = async (
+  record: SQSRecord,
+  options: BatchProcessingOptions
+): Promise<string> => {
+  const context = options.context;
+
+  try {
+    if (context.getRemainingTimeInMillis() == 0) {
+      throw Error('No time remaining.');
+    }
+  } catch (e) {
+    throw Error('Context possibly malformed. Displaying context:\n' + context);
+  }
+
+  return record.body;
+};
+
 export {
   sqsRecordHandler,
   asyncSqsRecordHandler,
@@ -88,4 +105,5 @@ export {
   dynamodbRecordHandler,
   asyncDynamodbRecordHandler,
   handlerWithContext,
+  asyncHandlerWithContext,
 };

packages/batch/tests/unit/AsyncBatchProcessor.test.ts

@@ -1,11 +1,14 @@
 /**
- * Test AsyncAsyncBatchProcessor class
+ * Test AsyncBatchProcessor class
  *
- * @group unit/batch/class/asyncAsyncBatchProcessor
+ * @group unit/batch/class/asyncBatchProcessor
  */
+import type { Context } from 'aws-lambda';
+import { helloworldContext as dummyContext } from '../../../commons/src/samples/resources/contexts';
 import { AsyncBatchProcessor } from '../../src/AsyncBatchProcessor';
 import { EventType } from '../../src/constants';
 import { BatchProcessingError } from '../../src/errors';
+import type { BatchProcessingOptions } from '../../src/types';
 import {
   dynamodbRecordFactory,
   kinesisRecordFactory,
@@ -15,10 +18,12 @@ import {
   asyncDynamodbRecordHandler,
   asyncKinesisRecordHandler,
   asyncSqsRecordHandler,
+  asyncHandlerWithContext,
 } from '../helpers/handlers';
 
-describe('Class: AsyncAsyncBatchProcessor', () => {
+describe('Class: AsyncBatchProcessor', () => {
   const ENVIRONMENT_VARIABLES = process.env;
+  const options: BatchProcessingOptions = { context: dummyContext };
 
   beforeEach(() => {
     jest.clearAllMocks();
@@ -40,7 +45,7 @@ describe('Class: AsyncAsyncBatchProcessor', () => {
 
       // Act
       processor.register(records, asyncSqsRecordHandler);
-      const processedMessages = await processor.processAsync();
+      const processedMessages = await processor.asyncProcess();
 
       // Assess
       expect(processedMessages).toStrictEqual([
@@ -59,7 +64,7 @@ describe('Class: AsyncAsyncBatchProcessor', () => {
 
       // Act
       processor.register(records, asyncSqsRecordHandler);
-      const processedMessages = await processor.processAsync();
+      const processedMessages = await processor.asyncProcess();
 
       // Assess
       expect(processedMessages[1]).toStrictEqual([
@@ -89,7 +94,7 @@ describe('Class: AsyncAsyncBatchProcessor', () => {
       processor.register(records, asyncSqsRecordHandler);
 
       // Assess
-      await expect(processor.processAsync()).rejects.toThrowError(
+      await expect(processor.asyncProcess()).rejects.toThrowError(
         BatchProcessingError
       );
     });
@@ -105,7 +110,7 @@ describe('Class: AsyncAsyncBatchProcessor', () => {
 
       // Act
       processor.register(records, asyncKinesisRecordHandler);
-      const processedMessages = await processor.processAsync();
+      const processedMessages = await processor.asyncProcess();
 
       // Assess
       expect(processedMessages).toStrictEqual([
@@ -124,7 +129,7 @@ describe('Class: AsyncAsyncBatchProcessor', () => {
 
       // Act
       processor.register(records, asyncKinesisRecordHandler);
-      const processedMessages = await processor.processAsync();
+      const processedMessages = await processor.asyncProcess();
 
       // Assess
       expect(processedMessages[1]).toStrictEqual([
@@ -154,7 +159,7 @@ describe('Class: AsyncAsyncBatchProcessor', () => {
       processor.register(records, asyncKinesisRecordHandler);
 
       // Assess
-      await expect(processor.processAsync()).rejects.toThrowError(
+      await expect(processor.asyncProcess()).rejects.toThrowError(
         BatchProcessingError
       );
     });
@@ -170,7 +175,7 @@ describe('Class: AsyncAsyncBatchProcessor', () => {
 
       // Act
       processor.register(records, asyncDynamodbRecordHandler);
-      const processedMessages = await processor.processAsync();
+      const processedMessages = await processor.asyncProcess();
 
       // Assess
       expect(processedMessages).toStrictEqual([
@@ -189,7 +194,7 @@ describe('Class: AsyncAsyncBatchProcessor', () => {
 
       // Act
       processor.register(records, asyncDynamodbRecordHandler);
-      const processedMessages = await processor.processAsync();
+      const processedMessages = await processor.asyncProcess();
 
       // Assess
       expect(processedMessages[1]).toStrictEqual([
@@ -219,7 +224,61 @@ describe('Class: AsyncAsyncBatchProcessor', () => {
       processor.register(records, asyncDynamodbRecordHandler);
 
       // Assess
-      await expect(processor.processAsync()).rejects.toThrowError(
+      await expect(processor.asyncProcess()).rejects.toThrowError(
+        BatchProcessingError
+      );
+    });
+  });
+
+  describe('Batch processing with Lambda context', () => {
+    test('Batch processing when context is provided and handler accepts', async () => {
+      // Prepare
+      const firstRecord = sqsRecordFactory('success');
+      const secondRecord = sqsRecordFactory('success');
+      const records = [firstRecord, secondRecord];
+      const processor = new AsyncBatchProcessor(EventType.SQS);
+
+      // Act
+      processor.register(records, asyncHandlerWithContext, options);
+      const processedMessages = await processor.asyncProcess();
+
+      // Assess
+      expect(processedMessages).toStrictEqual([
+        ['success', firstRecord.body, firstRecord],
+        ['success', secondRecord.body, secondRecord],
+      ]);
+    });
+
+    test('Batch processing when context is provided and handler does not accept', async () => {
+      // Prepare
+      const firstRecord = sqsRecordFactory('success');
+      const secondRecord = sqsRecordFactory('success');
+      const records = [firstRecord, secondRecord];
+      const processor = new AsyncBatchProcessor(EventType.SQS);
+
+      // Act
+      processor.register(records, asyncSqsRecordHandler, options);
+      const processedMessages = await processor.asyncProcess();
+
+      // Assess
+      expect(processedMessages).toStrictEqual([
+        ['success', firstRecord.body, firstRecord],
+        ['success', secondRecord.body, secondRecord],
+      ]);
+    });
+
+    test('Batch processing when malformed context is provided and handler attempts to use', async () => {
+      // Prepare
+      const firstRecord = sqsRecordFactory('success');
+      const secondRecord = sqsRecordFactory('success');
+      const records = [firstRecord, secondRecord];
+      const processor = new AsyncBatchProcessor(EventType.SQS);
+      const badContext = { foo: 'bar' };
+      const badOptions = { context: badContext as unknown as Context };
+
+      // Act
+      processor.register(records, asyncHandlerWithContext, badOptions);
+      await expect(() => processor.asyncProcess()).rejects.toThrowError(
         BatchProcessingError
       );
     });
@@ -231,7 +290,7 @@ describe('Class: AsyncAsyncBatchProcessor', () => {
 
     // Act & Assess
     expect(() => processor.process()).toThrowError(
-      'Not implemented. Use processAsync() instead.'
+      'Not implemented. Use asyncProcess() instead.'
     );
   });
 });

packages/batch/tests/unit/BatchProcessor.test.ts

@@ -278,7 +278,7 @@ describe('Class: BatchProcessor', () => {
     const processor = new BatchProcessor(EventType.SQS);
 
     // Act & Assess
-    await expect(() => processor.processAsync()).rejects.toThrow(
+    await expect(() => processor.asyncProcess()).rejects.toThrow(
       'Not implemented. Use process() instead.'
     );
   });

packages/batch/tests/unit/SqsFifoPartialProcessor.test.ts

@@ -56,41 +56,4 @@ describe('Class: SqsFifoBatchProcessor', () => {
       );
     });
   });
-
-  describe('hronous SQS FIFO batch processing', () => {
-    test('SQS FIFO Batch processor with no failures', () => {
-      // Prepare
-      const firstRecord = sqsRecordFactory('success');
-      const secondRecord = sqsRecordFactory('success');
-      const event = { Records: [firstRecord, secondRecord] };
-      const processor = new SqsFifoPartialProcessor();
-
-      // Act
-      const result = processPartialResponse(event, sqsRecordHandler, processor);
-
-      // Assess
-      expect(result['batchItemFailures']).toStrictEqual([]);
-    });
-
-    test('SQS FIFO Batch processor with failures', () => {
-      // Prepare
-      const firstRecord = sqsRecordFactory('success');
-      const secondRecord = sqsRecordFactory('fail');
-      const thirdRecord = sqsRecordFactory('success');
-      const event = { Records: [firstRecord, secondRecord, thirdRecord] };
-      const processor = new SqsFifoPartialProcessor();
-
-      // Act
-      const result = processPartialResponse(event, sqsRecordHandler, processor);
-
-      // Assess
-      expect(result['batchItemFailures'].length).toBe(2);
-      expect(result['batchItemFailures'][0]['itemIdentifier']).toBe(
-        secondRecord.messageId
-      );
-      expect(result['batchItemFailures'][1]['itemIdentifier']).toBe(
-        thirdRecord.messageId
-      );
-    });
-  });
 });