tests(idempotency): add utility to workspace unit tests and CI (#1160)

* chore: fix package.lock & package

* ci: add idempotency to ci checks on PRs

* refactor: minor styling changes to folder structure, exports, types

* test: unit tests style + added missing

* chore: temporarily excluded makeFunctionIdempotent from coverage report

* refactor: rename npx DynamoDbPersistenceLayer to DynamoDBPersistenceLayer

* refactor: rename npx DynamoDbPersistenceLayer to DynamoDBPersistenceLayer

* refactor: rename npx DynamoDbPersistenceLayer to DynamoDBPersistenceLayer

* chore: revert changes to PersistenceLayerInterface

* Trigger Build

* Update packages/idempotency/src/persistence/PersistenceLayer.ts

Co-authored-by: ijemmy <[email protected]>

Co-authored-by: ijemmy <[email protected]>

Author: dreamorosi

.github/workflows/reusable-run-linting-check-and-unit-tests.yml

@@ -42,11 +42,11 @@ jobs:
         if: steps.cache-node-modules.outputs.cache-hit == 'true'
         run: |
           npm run build -w packages/commons
-          npm run build -w packages/logger & npm run build -w packages/tracer & npm run build -w packages/metrics -w packages/parameters
+          npm run build -w packages/logger & npm run build -w packages/tracer & npm run build -w packages/metrics & npm run build -w packages/parameters & npm run build -w packages/idempotency
       - name: Run linting
-        run: npm run lint -w packages/commons -w packages/logger -w packages/tracer -w packages/metrics -w packages/parameters
+        run: npm run lint -w packages/commons -w packages/logger -w packages/tracer -w packages/metrics -w packages/parameters -w packages/idempotency
       - name: Run unit tests
-        run: npm t -w packages/commons -w packages/logger -w packages/tracer -w packages/metrics -w packages/parameters
+        run: npm t -w packages/commons -w packages/logger -w packages/tracer -w packages/metrics -w packages/parameters -w packages/idempotency
   check-examples:
     runs-on: ubuntu-latest
     env:

package-lock.json

@@ -9,7 +9,8 @@
     "packages/logger",
     "packages/metrics",
     "packages/tracer",
-    "packages/parameters"
+    "packages/parameters",
+    "packages/idempotency"
   ],
   "scripts": {
     "init-environment": "husky install",
@@ -84,4 +85,4 @@
   "dependencies": {
     "hosted-git-info": "^5.0.0"
   }
-}
+}

package.json

@@ -1,7 +1,7 @@
 module.exports = {
   displayName: {
     name: 'AWS Lambda Powertools utility: IDEMPOTENCY',
-    color: 'cyan',
+    color: 'blue',
   },
   'runner': 'groups',
   'preset': 'ts-jest',
@@ -25,6 +25,7 @@ module.exports = {
   'coveragePathIgnorePatterns': [
     '/node_modules/',
     '/types/',
+    'src/makeFunctionIdempotent.ts', // TODO: remove this once makeFunctionIdempotent is implemented
   ],
   'coverageThreshold': {
     'global': {
@@ -38,5 +39,8 @@ module.exports = {
     'json-summary',
     'text',
     'lcov'
+  ],
+  'setupFiles': [
+    '<rootDir>/tests/helpers/populateEnvironmentVariables.ts'
   ]
 };

packages/idempotency/jest.config.js

@@ -13,18 +13,18 @@
     "commit": "commit",
     "test": "npm run test:unit",
     "test:unit": "jest --group=unit --detectOpenHandles --coverage --verbose",
-    "test:e2e:nodejs12x": "RUNTIME=nodejs12x jest --group=e2e",
-    "test:e2e:nodejs14x": "RUNTIME=nodejs14x jest --group=e2e",
-    "test:e2e:nodejs16x": "RUNTIME=nodejs16x jest --group=e2e",
-    "test:e2e": "jest --group=e2e",
+    "test:e2e:nodejs12x": "echo \"Not implemented\"",
+    "test:e2e:nodejs14x": "echo \"Not implemented\"",
+    "test:e2e:nodejs16x": "echo \"Not implemented\"",
+    "test:e2e": "echo \"Not implemented\"",
     "watch": "jest --watch --group=unit",
     "build": "tsc",
     "lint": "eslint --ext .ts --no-error-on-unmatched-pattern src tests",
     "lint-fix": "eslint --fix --ext .ts --no-error-on-unmatched-pattern src tests",
     "package": "mkdir -p dist/ && npm pack && mv *.tgz dist/",
-    "package-bundle": "../../package-bundler.sh logger-bundle ./dist",
+    "package-bundle": "../../package-bundler.sh idempotency-bundle ./dist",
     "prepare": "npm run build",
-    "postversion": "git push --tags"
+    "postversion": "echo \"Not implemented\""
   },
   "homepage": "https://github.com/awslabs/aws-lambda-powertools-typescript/tree/master/packages/idempotency#readme",
   "license": "MIT",
@@ -42,7 +42,7 @@
     "url": "https://github.com/awslabs/aws-lambda-powertools-typescript/issues"
   },
   "dependencies": {
-    "@aws-lambda-powertools/commons": "^1.2.1",
+    "@aws-lambda-powertools/commons": "^1.4.1",
     "@aws-sdk/lib-dynamodb": "^3.170.0"
   },
   "keywords": [
@@ -56,4 +56,4 @@
     "aws-sdk-client-mock": "^2.0.0",
     "aws-sdk-client-mock-jest": "^2.0.0"
   }
-}
+}

packages/idempotency/package.json

@@ -0,0 +1,13 @@
+interface ConfigServiceInterface {
+
+  get(name: string): string
+
+  getServiceName(): string
+
+  getFunctionName(): string
+
+}
+
+export {
+  ConfigServiceInterface
+};

packages/idempotency/src/EnvironmentVariablesService.ts

@@ -0,0 +1,36 @@
+import { ConfigServiceInterface } from './ConfigServiceInterface';
+import { EnvironmentVariablesService as CommonEnvironmentVariablesService } from '@aws-lambda-powertools/commons';
+
+/**
+ * Class EnvironmentVariablesService
+ *
+ * This class is used to return environment variables that are available in the runtime of
+ * the current Lambda invocation.
+ * These variables can be a mix of runtime environment variables set by AWS and
+ * variables that can be set by the developer additionally.
+ *
+ * @class
+ * @extends {CommonEnvironmentVariablesService}
+ * @implements {ConfigServiceInterface}
+ * @see https://docs.aws.amazon.com/lambda/latest/dg/configuration-envvars.html#configuration-envvars-runtime
+ * @see https://awslabs.github.io/aws-lambda-powertools-typescript/latest/#environment-variables
+ */
+class EnvironmentVariablesService extends CommonEnvironmentVariablesService implements ConfigServiceInterface {
+  
+  // Reserved environment variables
+  private functionNameVariable = 'AWS_LAMBDA_FUNCTION_NAME';
+
+  /**
+   * It returns the value of the AWS_LAMBDA_FUNCTION_NAME environment variable.
+   *
+   * @returns {string}
+   */
+  public getFunctionName(): string {
+    return this.get(this.functionNameVariable);
+  }
+
+}
+
+export {
+  EnvironmentVariablesService
+};

packages/idempotency/src/config/ConfigServiceInterface.ts

@@ -0,0 +1 @@
+export * from './EnvironmentVariablesService';

packages/idempotency/src/config/EnvironmentVariablesService.ts

@@ -1,10 +1,11 @@
-/* eslint-disable @typescript-eslint/no-explicit-any */
-import { AnyFunction } from './types/AnyFunction';
-import { IdempotencyOptions } from './IdempotencyOptions';
+import type { AnyFunction } from './types/AnyFunction';
+import type { IdempotencyOptions } from './types/IdempotencyOptions';
 
 const makeFunctionIdempotent = <U>(
   fn: AnyFunction<U>,
   _options: IdempotencyOptions
+  // TODO: revisit this with a more specific type if possible
+  /* eslint-disable @typescript-eslint/no-explicit-any */
 ): (...args: Array<any>) => Promise<U | void> => (...args) => fn(...args);
 
 export { makeFunctionIdempotent };

packages/idempotency/src/config/index.ts

@@ -1,5 +1,6 @@
 import { DynamoDB, DynamoDBServiceException } from '@aws-sdk/client-dynamodb';
-import { DynamoDBDocument, GetCommandOutput } from '@aws-sdk/lib-dynamodb';
+import { DynamoDBDocument } from '@aws-sdk/lib-dynamodb';
+import type { GetCommandOutput } from '@aws-sdk/lib-dynamodb';
 import { DynamoPersistenceConstructorOptions } from '../types/DynamoPersistenceConstructorOptions';
 import { IdempotencyItemAlreadyExistsError, IdempotencyItemNotFoundError } from '../Exceptions';
 import { IdempotencyRecordStatus } from '../types/IdempotencyRecordStatus';
@@ -23,7 +24,7 @@ class DynamoDBPersistenceLayer extends PersistenceLayer {
     this.statusAttr = constructorOptions.statusAttr ?? 'status';
     this.expiryAttr = constructorOptions.expiryAttr ?? 'expiration';
     this.inProgressExpiryAttr = constructorOptions.inProgressExpiryAttr ?? 'in_progress_expiry_attr';
-    this.dataAttr = constructorOptions.data_attr ?? 'data';
+    this.dataAttr = constructorOptions.dataAttr ?? 'data';
   }
 
   protected async _deleteRecord(record: IdempotencyRecord): Promise<void> {

packages/idempotency/src/makeFunctionIdempotent.ts

@@ -1,6 +1,7 @@
 import { BinaryToTextEncoding, createHash, Hash } from 'crypto';
 import { IdempotencyRecordStatus } from '../types/IdempotencyRecordStatus';
-import { EnvironmentVariablesService } from '../EnvironmentVariablesService';
+import type { PersistenceLayerConfigureOptions } from '../types/PersistenceLayer';
+import { EnvironmentVariablesService } from '../config';
 import { IdempotencyRecord } from './IdempotencyRecord';
 import { PersistenceLayerInterface } from './PersistenceLayerInterface';
 
@@ -10,22 +11,32 @@ abstract class PersistenceLayer implements PersistenceLayerInterface {
   private envVarsService!: EnvironmentVariablesService;
 
   private expiresAfterSeconds: number;
-
-  private functionName: string = '';
-
+  
   private hashDigest: BinaryToTextEncoding;
-
+  
   private hashFunction: string;
+  
+  private idempotencyKeyPrefix: string;
 
   public constructor() { 
     this.setEnvVarsService();
     this.expiresAfterSeconds = 60 * 60; //one hour is the default expiration
     this.hashFunction = 'md5';
     this.hashDigest = 'base64';
-        
+    this.idempotencyKeyPrefix = this.getEnvVarsService().getFunctionName();
+
   }
-  public configure(functionName: string = ''): void {
-    this.functionName = this.getEnvVarsService().getLambdaFunctionName() + '.' + functionName;
+
+  /**
+   * Configures the persistence layer by passing the name of the idempotent function. This will be used
+   * in the prefix of the idempotency key
+   * 
+   * @param {PersistenceLayerConfigureOptions} options - configuration object for the persistence layer
+   */
+  public configure(options?: PersistenceLayerConfigureOptions): void {
+    if (options?.functionName && options.functionName.trim() !== '') {
+      this.idempotencyKeyPrefix = `${this.idempotencyKeyPrefix}.${options.functionName}`;
+    }
   }
 
   /**
@@ -136,7 +147,7 @@ abstract class PersistenceLayer implements PersistenceLayerInterface {
       console.warn('No data found for idempotency key');
     }
 
-    return this.functionName + '#' + this.generateHash(JSON.stringify(data));
+    return `${this.idempotencyKeyPrefix}#${this.generateHash(JSON.stringify(data))}`;
   }
 
   /**

packages/idempotency/src/persistence/DynamoDbPersistenceLayer.ts renamed to packages/idempotency/src/persistence/DynamoDBPersistenceLayer.ts

@@ -1,7 +1,8 @@
 import { IdempotencyRecord } from './IdempotencyRecord';
+import type { PersistenceLayerConfigureOptions } from '../types/PersistenceLayer';
 
 interface PersistenceLayerInterface {
-  configure(functionName: string): void
+  configure(options?: PersistenceLayerConfigureOptions): void
   saveInProgress(data: unknown): Promise<void>
   saveSuccess(data: unknown, result: unknown): Promise<void>
   deleteRecord(data: unknown): Promise<void>

packages/idempotency/src/persistence/PersistenceLayer.ts

@@ -1,4 +1,4 @@
-export * from './DynamoDbPersistenceLayer';
+export * from './DynamoDBPersistenceLayer';
 export * from './PersistenceLayer';
 export * from './PersistenceLayerInterface';
 export * from './IdempotencyRecord';

packages/idempotency/src/persistence/PersistenceLayerInterface.ts

@@ -4,7 +4,7 @@ type DynamoPersistenceConstructorOptions = {
   statusAttr?: string
   expiryAttr?: string
   inProgressExpiryAttr?: string
-  data_attr?: string
+  dataAttr?: string
 };
 
 export {

packages/idempotency/src/persistence/index.ts

@@ -1,4 +1,4 @@
-import { PersistenceLayer } from './persistence/PersistenceLayer';
+import { PersistenceLayer } from '../persistence/PersistenceLayer';
 
 type IdempotencyOptions = {
   dataKeywordArgument: string

packages/idempotency/src/types/DynamoPersistenceConstructorOptions.ts

@@ -0,0 +1,7 @@
+type PersistenceLayerConfigureOptions = {
+  functionName?: string
+};
+
+export { 
+  PersistenceLayerConfigureOptions
+};

packages/idempotency/src/IdempotencyOptions.ts renamed to packages/idempotency/src/types/IdempotencyOptions.ts

@@ -1,2 +1,3 @@
 export * from './AnyFunction';
-export * from './IdempotencyRecordStatus';
+export * from './IdempotencyRecordStatus';
+export * from './PersistenceLayer';

packages/idempotency/src/types/PersistenceLayer.ts

@@ -1,2 +1,7 @@
 // Reserved variables
-process.env.AWS_REGION = 'us-east-1';
+process.env._X_AMZN_TRACE_ID = '1-abcdef12-3456abcdef123456abcdef12';
+process.env.AWS_LAMBDA_FUNCTION_NAME = 'my-lambda-function';
+process.env.AWS_EXECUTION_ENV = 'nodejs16.x';
+process.env.AWS_LAMBDA_FUNCTION_MEMORY_SIZE = '128';
+process.env.AWS_REGION = 'eu-west-1';
+process.env._HANDLER = 'index.handler';

packages/idempotency/src/types/index.ts

@@ -0,0 +1,50 @@
+/**
+ * Test EnvironmentVariableService class
+ *
+ * @group unit/idempotency/all
+ */
+import { EnvironmentVariablesService } from '../../../src/config';
+
+describe('Class: EnvironmentVariableService', () => {
+
+  const ENVIRONMENT_VARIABLES = process.env;
+
+  beforeEach(() => {
+    jest.resetModules();
+    process.env = { ...ENVIRONMENT_VARIABLES };
+  });
+
+  afterEach(() => {
+    process.env = ENVIRONMENT_VARIABLES;
+  });
+
+  describe('Method: getFunctionName', () => {
+    
+    test('When called, it gets the Lambda function name from the environment variable', () => {
+      
+      // Prepare
+      const expectedName = process.env.AWS_LAMBDA_FUNCTION_NAME;
+
+      // Act
+      const lambdaName = new EnvironmentVariablesService().getFunctionName();
+
+      // Assess
+      expect(lambdaName).toEqual(expectedName);
+
+    });
+
+    test('When called without the environment variable set, it returns an empty string', () => {
+      
+      // Prepare
+      delete process.env.AWS_LAMBDA_FUNCTION_NAME;
+
+      // Act
+      const lambdaName = new EnvironmentVariablesService().getFunctionName();
+
+      // Assess
+      expect(lambdaName).toEqual('');
+
+    });
+
+  });
+});

packages/idempotency/tests/helpers/populateEnvironmentVariables.ts

@@ -1,19 +1,24 @@
+/**
+  * Test DynamoDBPersistenceLayer class
+ *
+ * @group unit/idempotency/all
+ */
 import { DeleteCommand, DynamoDBDocument, GetCommand, PutCommand, UpdateCommand } from '@aws-sdk/lib-dynamodb';
 import { mockClient } from 'aws-sdk-client-mock';
 import 'aws-sdk-client-mock-jest';
 import { IdempotencyItemAlreadyExistsError, IdempotencyItemNotFoundError } from '../../../src/Exceptions';
-import { DynamoDBPersistenceLayer } from '../../../src/persistence/DynamoDbPersistenceLayer';
+import { DynamoDBPersistenceLayer } from '../../../src/persistence/DynamoDBPersistenceLayer';
 import { IdempotencyRecord } from '../../../src/persistence/IdempotencyRecord';
+import { DynamoPersistenceConstructorOptions } from '../../../src/types/DynamoPersistenceConstructorOptions';
 import { IdempotencyRecordStatus } from '../../../src/types/IdempotencyRecordStatus';
 
-/**
-  * Test DynamoDBPersistenceLayer class
- *
- * @group unit/idempotency/all
- */
+describe('Class: DynamoDBPersistenceLayer', () => {
+
+  const dummyTableName = 'someTable';
+  const dummyKey = 'someKey';
+
+  class TestDynamoDBPersistenceLayer extends DynamoDBPersistenceLayer {
 
-describe('Class: DynamoDbPersistenceLayer', () => {
-  class TestDynamoPersistenceLayer extends DynamoDBPersistenceLayer {
     public _deleteRecord(record: IdempotencyRecord): Promise<void> {
       return super._deleteRecord(record);
     }
@@ -29,31 +34,77 @@ describe('Class: DynamoDbPersistenceLayer', () => {
     public _updateRecord(record: IdempotencyRecord): Promise<void> {
       return super._updateRecord(record);
     }
+
   }
 
   beforeEach(() => {
     jest.clearAllMocks();
   });
 
+  describe('Method: constructor', () => {
+
+    test('when instantiated with minimum options it creates an instance with default values', () => {
+
+      // Prepare
+      const persistenceLayer = new TestDynamoDBPersistenceLayer({ tableName: dummyTableName });
+
+      // Act / Assess
+      expect(persistenceLayer).toEqual(expect.objectContaining({
+        tableName: dummyTableName,
+        keyAttr: 'id',
+        statusAttr: 'status',
+        expiryAttr: 'expiration',
+        inProgressExpiryAttr: 'in_progress_expiry_attr',
+        dataAttr: 'data'
+      }));
+
+    });
+
+    test('when instantiated with specific options it creates an instance with correct values', () => {
+
+      // Prepare
+      const testDynamoDBPersistenceLayerOptions: DynamoPersistenceConstructorOptions = {
+        tableName: dummyTableName,
+        keyAttr: dummyKey,
+        statusAttr: 'someStatusAttr',
+        expiryAttr: 'someExpiryAttr',
+        inProgressExpiryAttr: 'someInProgressExpiryAttr',
+        dataAttr: 'someDataAttr'
+      };
+      const persistenceLayer = new TestDynamoDBPersistenceLayer(testDynamoDBPersistenceLayerOptions);
+
+      // Act / Assess
+      expect(persistenceLayer).toEqual(expect.objectContaining({
+        tableName: dummyTableName,
+        keyAttr: dummyKey,
+        statusAttr: testDynamoDBPersistenceLayerOptions.statusAttr,
+        expiryAttr: testDynamoDBPersistenceLayerOptions.expiryAttr,
+        inProgressExpiryAttr: testDynamoDBPersistenceLayerOptions.inProgressExpiryAttr,
+        dataAttr: testDynamoDBPersistenceLayerOptions.dataAttr
+      }));
+
+    });
+
+  });
+
   describe('Method: _putRecord', () => {
+
     const currentDateInMilliseconds = 1000;
     const currentDateInSeconds = 1;
 
     beforeEach(() => {
       jest.spyOn(Date, 'now').mockReturnValue(currentDateInMilliseconds);
     });
 
-    test('when called with a record that meets conditions, it puts record in dynamo table', async () => {
-      // Prepare
-      const tableName = 'tableName';
-      const persistenceLayer = new TestDynamoPersistenceLayer({ tableName });
+    test('when called with a record that meets conditions, it puts record in DynamoDB table', async () => {
 
-      const key = 'key';
+      // Prepare
+      const persistenceLayer = new TestDynamoDBPersistenceLayer({ tableName: dummyTableName });
       const status = IdempotencyRecordStatus.EXPIRED;
       const expiryTimestamp = 0;
       const inProgressExpiryTimestamp = 0;
       const record = new IdempotencyRecord({
-        idempotencyKey: key, 
+        idempotencyKey: dummyKey, 
         status, 
         expiryTimestamp, 
         inProgressExpiryTimestamp
@@ -65,104 +116,84 @@ describe('Class: DynamoDbPersistenceLayer', () => {
 
       // Assess
       expect(dynamoClient).toReceiveCommandWith(PutCommand, {
-        TableName: tableName,
-        Item: { 'id': key, 'expiration': expiryTimestamp, status: status },
+        TableName: dummyTableName,
+        Item: { 'id': dummyKey, 'expiration': expiryTimestamp, status: status },
         ExpressionAttributeNames: { '#id': 'id', '#expiry': 'expiration', '#status': 'status' },
         ExpressionAttributeValues: { ':now': currentDateInSeconds, ':inprogress': IdempotencyRecordStatus.INPROGRESS },
         ConditionExpression: 'attribute_not_exists(#id) OR #expiry < :now OR NOT #status = :inprogress'
       });
+
     });
 
     test('when called with a record that fails any condition, it throws IdempotencyItemAlreadyExistsError', async () => {
+      
       // Prepare
-      const tableName = 'tableName';
-      const persistenceLayer = new TestDynamoPersistenceLayer({ tableName });
-
-      const key = 'key';
+      const persistenceLayer = new TestDynamoDBPersistenceLayer({ tableName: dummyTableName });
       const status = IdempotencyRecordStatus.EXPIRED;
       const expiryTimestamp = 0;
       const inProgressExpiryTimestamp = 0;
       const record = new IdempotencyRecord({ 
-        idempotencyKey: key, 
+        idempotencyKey: dummyKey, 
         status, 
         expiryTimestamp, 
         inProgressExpiryTimestamp
       });
-
       const dynamoClient = mockClient(DynamoDBDocument).on(PutCommand).rejects({ name: 'ConditionalCheckFailedException' });
 
-      // Act
-      let error: unknown;
-      try {
-        await persistenceLayer._putRecord(record);
-      } catch (e){
-        error = e;
-      }
-
-      // Assess
+      // Act / Assess
+      await expect(persistenceLayer._putRecord(record)).rejects.toThrowError(IdempotencyItemAlreadyExistsError);
       expect(dynamoClient).toReceiveCommandWith(PutCommand, {
-        TableName: tableName,
-        Item: { 'id': key, 'expiration': expiryTimestamp, status: status },
+        TableName: dummyTableName,
+        Item: { 'id': dummyKey, 'expiration': expiryTimestamp, status: status },
         ExpressionAttributeNames: { '#id': 'id', '#expiry': 'expiration', '#status': 'status' },
         ExpressionAttributeValues: { ':now': currentDateInSeconds, ':inprogress': IdempotencyRecordStatus.INPROGRESS },
         ConditionExpression: 'attribute_not_exists(#id) OR #expiry < :now OR NOT #status = :inprogress'
       });
-      expect(error).toBeInstanceOf(IdempotencyItemAlreadyExistsError);
+
     });
 
     test('when encountering an unknown error, it throws the causing error', async () => {
-      // Prepare
-      const tableName = 'tableName';
-      const persistenceLayer = new TestDynamoPersistenceLayer({ tableName });
 
-      const key = 'key';
+      // Prepare
+      const persistenceLayer = new TestDynamoDBPersistenceLayer({ tableName: dummyTableName });
       const status = IdempotencyRecordStatus.EXPIRED;
       const expiryTimestamp = 0;
       const inProgressExpiryTimestamp = 0;
       const record = new IdempotencyRecord({ 
-        idempotencyKey: key, 
+        idempotencyKey: dummyKey, 
         status, 
         expiryTimestamp, 
         inProgressExpiryTimestamp 
       });
-
       const dynamoClient = mockClient(DynamoDBDocument).on(PutCommand).rejects(new Error());
 
-      // Act
-      let error: unknown;
-      try {
-        await persistenceLayer._putRecord(record);
-      } catch (e){
-        error = e;
-      }
-
-      // Assess
+      // Act / Assess
+      await expect(persistenceLayer._putRecord(record)).rejects.toThrow();
       expect(dynamoClient).toReceiveCommandWith(PutCommand, {
-        TableName: tableName,
-        Item: { 'id': key, 'expiration': expiryTimestamp, status: status },
+        TableName: dummyTableName,
+        Item: { 'id': dummyKey, 'expiration': expiryTimestamp, status: status },
         ExpressionAttributeNames: { '#id': 'id', '#expiry': 'expiration', '#status': 'status' },
         ExpressionAttributeValues: { ':now': currentDateInSeconds, ':inprogress': IdempotencyRecordStatus.INPROGRESS },
         ConditionExpression: 'attribute_not_exists(#id) OR #expiry < :now OR NOT #status = :inprogress'
       });
-      expect(error).toBe(error);
+
     });
+
   });
 
   describe('Method: _getRecord', () => {
-    test('when called with a record whose key exists, it gets the correct record', async () => {
-      // Prepare
-      const tableName = 'tableName';
-      const persistenceLayer = new TestDynamoPersistenceLayer({ tableName });
 
-      const key = 'key';
+    test('when called with a record whose key exists, it gets the correct record', async () => {
 
+      // Prepare
+      const persistenceLayer = new TestDynamoDBPersistenceLayer({ tableName: dummyTableName });
       const status = IdempotencyRecordStatus.INPROGRESS;
       const expiryTimestamp = 10;
       const inProgressExpiryTimestamp = 10;
       const responseData = {};
       const dynamoClient = mockClient(DynamoDBDocument).on(GetCommand).resolves({ 
         Item: { 
-          id: key, 
+          id: dummyKey, 
           status, 
           'expiration': expiryTimestamp, 
           'in_progress_expiry_attr': inProgressExpiryTimestamp, 
@@ -172,65 +203,55 @@ describe('Class: DynamoDbPersistenceLayer', () => {
       jest.spyOn(Date, 'now').mockReturnValue(0);
 
       // Act
-      const record: IdempotencyRecord = await persistenceLayer._getRecord(key);
+      const record: IdempotencyRecord = await persistenceLayer._getRecord(dummyKey);
 
       // Assess
       expect(dynamoClient).toReceiveCommandWith(GetCommand, {
-        TableName: tableName, 
+        TableName: dummyTableName, 
         Key: { 
-          id: key 
+          id: dummyKey 
         },
         ConsistentRead: true
       });
       expect(record.getStatus()).toEqual(IdempotencyRecordStatus.INPROGRESS);
-      expect(record.idempotencyKey).toEqual(key);
+      expect(record.idempotencyKey).toEqual(dummyKey);
       expect(record.inProgressExpiryTimestamp).toEqual(inProgressExpiryTimestamp);
       expect(record.responseData).toEqual(responseData);
       expect(record.expiryTimestamp).toEqual(expiryTimestamp);
     });
 
     test('when called with a record whose key does not exist, it throws IdempotencyItemNotFoundError', async () => {
-      // Prepare
-      const tableName = 'tableName';
-      const persistenceLayer = new TestDynamoPersistenceLayer({ tableName });
-  
-      const key = 'key';
 
+      // Prepare
+      const persistenceLayer = new TestDynamoDBPersistenceLayer({ tableName: dummyTableName });
       const dynamoClient = mockClient(DynamoDBDocument).on(GetCommand).resolves({ Item: undefined });
       jest.spyOn(Date, 'now').mockReturnValue(0);
 
-      // Act
-      let error: unknown;
-      try {
-        await persistenceLayer._getRecord(key);
-      } catch (e){
-        error = e;
-      }
-  
-      // Assess
+      // Act / Assess
+      await expect(persistenceLayer._getRecord(dummyKey)).rejects.toThrowError(IdempotencyItemNotFoundError);
       expect(dynamoClient).toReceiveCommandWith(GetCommand, {
-        TableName: tableName, 
+        TableName: dummyTableName, 
         Key: { 
-          id: key 
+          id: dummyKey 
         },
         ConsistentRead: true
       });
-      expect(error).toBeInstanceOf(IdempotencyItemNotFoundError);
+
     });
+
   });
 
   describe('Method: _updateRecord', () => {
+
     test('when called to update a record, it resolves successfully', async () => {
-      // Prepare
-      const tableName = 'tableName';
-      const persistenceLayer = new TestDynamoPersistenceLayer({ tableName });
 
-      const key = 'key';
+      // Prepare
+      const persistenceLayer = new TestDynamoDBPersistenceLayer({ tableName: dummyTableName });
       const status = IdempotencyRecordStatus.EXPIRED;
       const expiryTimestamp = 0;
       const inProgressExpiryTimestamp = 0;
       const record = new IdempotencyRecord({
-        idempotencyKey: key, 
+        idempotencyKey: dummyKey, 
         status, 
         expiryTimestamp, 
         inProgressExpiryTimestamp
@@ -242,27 +263,28 @@ describe('Class: DynamoDbPersistenceLayer', () => {
 
       // Assess
       expect(dynamoClient).toReceiveCommandWith(UpdateCommand, {
-        TableName: tableName, 
-        Key: { id: key },
+        TableName: dummyTableName, 
+        Key: { id: dummyKey },
         UpdateExpression: 'SET #status = :status, #expiry = :expiry',
         ExpressionAttributeNames: { '#status': 'status', '#expiry': 'expiration' },
         ExpressionAttributeValues: { ':status': IdempotencyRecordStatus.EXPIRED,':expiry': expiryTimestamp },
       });
+
     });
+
   });
 
   describe('Method: _deleteRecord', () => {
+
     test('when called with a valid record, record is deleted', async () => {
-      // Prepare
-      const tableName = 'tableName';
-      const persistenceLayer = new TestDynamoPersistenceLayer({ tableName });
 
-      const key = 'key';
+      // Prepare
+      const persistenceLayer = new TestDynamoDBPersistenceLayer({ tableName: dummyTableName });
       const status = IdempotencyRecordStatus.EXPIRED;
       const expiryTimestamp = 0;
       const inProgressExpiryTimestamp = 0;
       const record = new IdempotencyRecord({ 
-        idempotencyKey: key, 
+        idempotencyKey: dummyKey, 
         status, 
         expiryTimestamp, 
         inProgressExpiryTimestamp
@@ -274,9 +296,12 @@ describe('Class: DynamoDbPersistenceLayer', () => {
 
       // Assess
       expect(dynamoClient).toReceiveCommandWith(DeleteCommand, {
-        TableName: tableName, 
-        Key: { id: key }
+        TableName: dummyTableName, 
+        Key: { id: dummyKey }
       });
+
     });
+
   });
+
 });

packages/idempotency/tests/unit/EnvironmentVariableService.test.ts

@@ -1,11 +1,12 @@
-import { IdempotencyInvalidStatusError } from '../../../src/Exceptions';
-import { IdempotencyRecord } from '../../../src/persistence/IdempotencyRecord';
-import { IdempotencyRecordStatus } from '../../../src/types/IdempotencyRecordStatus';
 /**
  * Test IdempotencyRecord class
  *
  * @group unit/idempotency/all
  */
+import { IdempotencyInvalidStatusError } from '../../../src/Exceptions';
+import { IdempotencyRecord } from '../../../src/persistence/IdempotencyRecord';
+import { IdempotencyRecordStatus } from '../../../src/types/IdempotencyRecordStatus';
+
 const mockIdempotencyKey = '123';
 const mockData = undefined;
 const mockInProgressExpiry = 123;

packages/idempotency/tests/unit/config/EnvironmentVariableService.test.ts

@@ -4,7 +4,6 @@
  * @group unit/idempotency/all
  */
 import { createHash, Hash } from 'crypto';
-import { EnvironmentVariablesService } from '../../../src/EnvironmentVariablesService';
 import { IdempotencyRecord, PersistenceLayer } from '../../../src/persistence';
 import { IdempotencyRecordStatus } from '../../../src/types/IdempotencyRecordStatus';
 
@@ -16,7 +15,10 @@ const cryptoUpdateMock = jest.fn();
 const cryptoDigestMock = jest.fn();
 const mockDigest = 'hashDigest';
 
-describe('Class: Persistence Layer', ()=> {
+describe('Class: PersistenceLayer', () => {
+
+  const dummyData = 'someData';
+  const idempotentFunctionName = 'foo';
 
   const deleteRecord = jest.fn();
   const getRecord = jest.fn();
@@ -34,102 +36,146 @@ describe('Class: Persistence Layer', ()=> {
     protected _updateRecord = updateRecord;
   }
 
-  describe('Method: saveInProgress', ()=> {
-    beforeEach(()=> {
-      putRecord.mockClear();
-      (createHash as jest.MockedFunction<typeof createHash>).mockReturnValue(
-        {
-          update: cryptoUpdateMock,
-          digest: cryptoDigestMock.mockReturnValue(mockDigest)
-        } as unknown as Hash
-      );
+  describe('Method: configure', () => {
+
+    test('when called without options it maintains the default value for the key prefix', () => {
+
+      // Prepare
+      const persistenceLayer: PersistenceLayer = new PersistenceLayerTestClass();
+      persistenceLayer.configure();
+
+      expect(persistenceLayer).toEqual(expect.objectContaining({
+        idempotencyKeyPrefix: process.env.AWS_LAMBDA_FUNCTION_NAME,
+      }));
+
     });
 
-    test('When called, it saves an IN_PROGRESS idempotency record via _putRecord()', async ()=> {
-      const data = 'someData';
+    test('when called with an empty option object it maintains the default value for the key prefix', () => {
+
+      // Prepare
       const persistenceLayer: PersistenceLayer = new PersistenceLayerTestClass();
+      persistenceLayer.configure({});
 
-      await persistenceLayer.saveInProgress(data);
+      expect(persistenceLayer).toEqual(expect.objectContaining({
+        idempotencyKeyPrefix: process.env.AWS_LAMBDA_FUNCTION_NAME,
+      }));
 
-      const savedIdempotencyRecord: IdempotencyRecord = putRecord.mock.calls[0][0];
-      expect(savedIdempotencyRecord.getStatus()).toBe(IdempotencyRecordStatus.INPROGRESS);   
     });
 
-    test('When called, it creates an idempotency key from the function name and a digest of the md5 hash of the data', async ()=> {
-      const data = 'someData';
-      const lambdaFunctionName = 'LambdaName';
-      jest.spyOn(EnvironmentVariablesService.prototype, 'getLambdaFunctionName').mockReturnValue(lambdaFunctionName);
+    test('when called with an empty string as functionName it maintains the default value for the key prefix', () => {
 
-      const functionName = 'functionName';
+      // Prepare
+      const persistenceLayer: PersistenceLayer = new PersistenceLayerTestClass();
+      persistenceLayer.configure({ functionName: '' });
 
-      const expectedIdempotencyKey = lambdaFunctionName + '.' + functionName + '#' + mockDigest;
+      expect(persistenceLayer).toEqual(expect.objectContaining({
+        idempotencyKeyPrefix: process.env.AWS_LAMBDA_FUNCTION_NAME,
+      }));
+
+    });
+
+    test('when called with a valid functionName it concatenates the key prefix correctly', () => {
+
+      // Prepare
+      const expectedIdempotencyKeyPrefix = `${process.env.AWS_LAMBDA_FUNCTION_NAME}.${idempotentFunctionName}`;
       const persistenceLayer: PersistenceLayer = new PersistenceLayerTestClass();
-      persistenceLayer.configure(functionName);
+      persistenceLayer.configure({ functionName: idempotentFunctionName });
 
-      await persistenceLayer.saveInProgress(data);
+      expect(persistenceLayer).toEqual(expect.objectContaining({
+        idempotencyKeyPrefix: expectedIdempotencyKeyPrefix
+      }));
 
-      const savedIdempotencyRecord: IdempotencyRecord = putRecord.mock.calls[0][0];
+    });
 
-      expect(createHash).toHaveBeenCalledWith(
-        expect.stringMatching('md5'),
-      );
-      expect(cryptoUpdateMock).toHaveBeenCalledWith(expect.stringMatching(data));
-      expect(cryptoDigestMock).toHaveBeenCalledWith(
-        expect.stringMatching('base64')
+  });
+
+  describe('Method: saveInProgress', () => {
+
+    beforeEach(() => {
+      putRecord.mockClear();
+      (createHash as jest.MockedFunction<typeof createHash>).mockReturnValue(
+        {
+          update: cryptoUpdateMock,
+          digest: cryptoDigestMock.mockReturnValue(mockDigest)
+        } as unknown as Hash
       );
-      expect(savedIdempotencyRecord.idempotencyKey).toEqual(expectedIdempotencyKey);
+
     });
 
-    test('When called without a function name, it creates an idempotency key from the Lambda name only and a digest of the md5 hash of the data', async ()=> {
-      const data = 'someData';
-      const lambdaFunctionName = 'LambdaName';
-      jest.spyOn(EnvironmentVariablesService.prototype, 'getLambdaFunctionName').mockReturnValue(lambdaFunctionName);
+    test('when called, it saves an IN_PROGRESS idempotency record via _putRecord()', async () => {
 
-      const expectedIdempotencyKey = lambdaFunctionName + '.' + '#' + mockDigest;
+      // Prepare
       const persistenceLayer: PersistenceLayer = new PersistenceLayerTestClass();
-      persistenceLayer.configure();
 
-      await persistenceLayer.saveInProgress(data);
+      // Act
+      await persistenceLayer.saveInProgress(dummyData);
 
+      // Assess
       const savedIdempotencyRecord: IdempotencyRecord = putRecord.mock.calls[0][0];
+      expect(savedIdempotencyRecord.getStatus()).toBe(IdempotencyRecordStatus.INPROGRESS);   
+
+    });
 
+    test('when called, it creates an idempotency key from the function name and a digest of the md5 hash of the data', async () => {
+      
+      // Prepare
+      const expectedIdempotencyKey = `${process.env.AWS_LAMBDA_FUNCTION_NAME}.${idempotentFunctionName}#${mockDigest}`;
+      const persistenceLayer: PersistenceLayer = new PersistenceLayerTestClass();
+      persistenceLayer.configure({ functionName: idempotentFunctionName });
+
+      // Act
+      await persistenceLayer.saveInProgress(dummyData);
+
+      // Assess
+      const savedIdempotencyRecord: IdempotencyRecord = putRecord.mock.calls[0][0];
       expect(createHash).toHaveBeenCalledWith(
         expect.stringMatching('md5'),
       );
-      expect(cryptoUpdateMock).toHaveBeenCalledWith(expect.stringMatching(data));
+      expect(cryptoUpdateMock).toHaveBeenCalledWith(expect.stringMatching(dummyData));
       expect(cryptoDigestMock).toHaveBeenCalledWith(
         expect.stringMatching('base64')
       );
       expect(savedIdempotencyRecord.idempotencyKey).toEqual(expectedIdempotencyKey);
+
     });
 
-    test('When called, it sets the expiry timestamp to one hour in the future', async ()=> {
+    test('when called, it sets the expiry timestamp to one hour in the future', async () => {
+
+      // Prepare
       const persistenceLayer: PersistenceLayer = new PersistenceLayerTestClass();
-      const data = 'someData';
       const currentMillisTime = 3000;
       const currentSeconds = currentMillisTime / 1000;
       const oneHourSeconds = 60 * 60;
       jest.spyOn(Date, 'now').mockReturnValue(currentMillisTime);
 
-      await persistenceLayer.saveInProgress(data);
+      // Act
+      await persistenceLayer.saveInProgress(dummyData);
 
+      // Assess
       const savedIdempotencyRecord: IdempotencyRecord = putRecord.mock.calls[0][0];
       expect(savedIdempotencyRecord.expiryTimestamp).toEqual(currentSeconds + oneHourSeconds);
 
     });
 
-    test('When called without data, it logs a warning', async ()=> {
-      const consoleSpy = jest.spyOn(console, 'warn');
+    test('when called without data, it logs a warning', async () => {
+
+      // Prepare
+      const consoleSpy = jest.spyOn(console, 'warn').mockImplementation(() => ({}));
       const persistenceLayer: PersistenceLayer = new PersistenceLayerTestClass();
 
+      // Act
       await persistenceLayer.saveInProgress('');
+      
+      // Assess
       expect(consoleSpy).toHaveBeenCalled();
+
     });
 
   });
 
-  describe('Method: saveSuccess', ()=> {
-    beforeEach(()=> {
+  describe('Method: saveSuccess', () => {
+
+    beforeEach(() => {
       updateRecord.mockClear();
       (createHash as jest.MockedFunction<typeof createHash>).mockReturnValue(
         {
@@ -139,64 +185,69 @@ describe('Class: Persistence Layer', ()=> {
       );
     });
 
-    test('When called, it updates the idempotency record status to COMPLETED', async () => {
-      const data = 'someData';
+    test('when called, it updates the idempotency record status to COMPLETED', async () => {
+
+      // Prepare
       const result = {};
       const persistenceLayer: PersistenceLayer = new PersistenceLayerTestClass();
 
-      await persistenceLayer.saveSuccess(data, result);
+      // Act
+      await persistenceLayer.saveSuccess(dummyData, result);
 
+      // Assess
       const savedIdempotencyRecord: IdempotencyRecord = updateRecord.mock.calls[0][0];
       expect(savedIdempotencyRecord.getStatus()).toBe(IdempotencyRecordStatus.COMPLETED);
 
     });
 
-    test('When called, it generates the idempotency key from the function name and a digest of the md5 hash of the data', async ()=> {
-      const data = 'someData';
-      const result = {};
-      const lambdaFunctionName = 'LambdaName';
-      jest.spyOn(EnvironmentVariablesService.prototype, 'getLambdaFunctionName').mockReturnValue(lambdaFunctionName);
-
-      const functionName = 'functionName';
+    test('when called, it generates the idempotency key from the function name and a digest of the md5 hash of the data', async () => {
 
-      const expectedIdempotencyKey = lambdaFunctionName + '.' + functionName + '#' + mockDigest;
+      // Prepare
+      const result = {};
+      const expectedIdempotencyKey = `${process.env.AWS_LAMBDA_FUNCTION_NAME}.${idempotentFunctionName}#${mockDigest}`;
       const persistenceLayer: PersistenceLayer = new PersistenceLayerTestClass();
-      persistenceLayer.configure(functionName);
+      persistenceLayer.configure({ functionName: idempotentFunctionName });
 
-      await persistenceLayer.saveSuccess(data, result);
+      // Act
+      await persistenceLayer.saveSuccess(dummyData, result);
 
+      // Assess
       const savedIdempotencyRecord: IdempotencyRecord = updateRecord.mock.calls[0][0];
-
       expect(createHash).toHaveBeenCalledWith(
         expect.stringMatching('md5'),
       );
-      expect(cryptoUpdateMock).toHaveBeenCalledWith(expect.stringMatching(data));
+      expect(cryptoUpdateMock).toHaveBeenCalledWith(expect.stringMatching(dummyData));
       expect(cryptoDigestMock).toHaveBeenCalledWith(
         expect.stringMatching('base64')
       );
       expect(savedIdempotencyRecord.idempotencyKey).toEqual(expectedIdempotencyKey);
+
     });
 
-    test('When called, it sets the expiry timestamp to one hour in the future', async ()=> {
+    test('when called, it sets the expiry timestamp to one hour in the future', async () => {
+
+      // Prepare
       const persistenceLayer: PersistenceLayer = new PersistenceLayerTestClass();
-      const data = 'someData';
       const result = {};
       const currentMillisTime = 3000;
       const currentSeconds = currentMillisTime / 1000;
       const oneHourSeconds = 60 * 60;
       jest.spyOn(Date, 'now').mockReturnValue(currentMillisTime);
 
-      await persistenceLayer.saveSuccess(data, result);
+      // Act
+      await persistenceLayer.saveSuccess(dummyData, result);
 
+      // Assess
       const savedIdempotencyRecord: IdempotencyRecord = updateRecord.mock.calls[0][0];
       expect(savedIdempotencyRecord.expiryTimestamp).toEqual(currentSeconds + oneHourSeconds);
 
     });
 
   });
 
-  describe('Method: getRecord', ()=> {
-    beforeEach(()=> {
+  describe('Method: getRecord', () => {
+
+    beforeEach(() => {
       putRecord.mockClear();
       (createHash as jest.MockedFunction<typeof createHash>).mockReturnValue(
         {
@@ -205,24 +256,26 @@ describe('Class: Persistence Layer', ()=> {
         } as unknown as Hash
       );
     });
-    test('When called, it gets the record for the idempotency key for the data passed in', ()=> {
-      const persistenceLayer: PersistenceLayer = new PersistenceLayerTestClass();
-      const data = 'someData';
-      const lambdaFunctionName = 'LambdaName';
-      jest.spyOn(EnvironmentVariablesService.prototype, 'getLambdaFunctionName').mockReturnValue(lambdaFunctionName);
 
-      const functionName = 'functionName';
-      const expectedIdempotencyKey = lambdaFunctionName + '.' + functionName + '#' + mockDigest;
-      persistenceLayer.configure(functionName);
+    test('when called, it gets the record for the idempotency key for the data passed in', () => {
 
-      persistenceLayer.getRecord(data);
+      // Prepare
+      const persistenceLayer: PersistenceLayer = new PersistenceLayerTestClass();
+      const expectedIdempotencyKey = `${process.env.AWS_LAMBDA_FUNCTION_NAME}.${idempotentFunctionName}#${mockDigest}`;
+      persistenceLayer.configure({ functionName: idempotentFunctionName });
+
+      // Act
+      persistenceLayer.getRecord(dummyData);
 
+      // Assess
       expect(getRecord).toHaveBeenCalledWith(expectedIdempotencyKey);
+
     });
   });
 
-  describe('Method: deleteRecord', ()=> {
-    beforeEach(()=> {
+  describe('Method: deleteRecord', () => {
+
+    beforeEach(() => {
       putRecord.mockClear();
       (createHash as jest.MockedFunction<typeof createHash>).mockReturnValue(
         {
@@ -232,20 +285,20 @@ describe('Class: Persistence Layer', ()=> {
       );
     });
 
-    test('When called, it deletes the record with the idempotency key for the data passed in', ()=> {
-      const persistenceLayer: PersistenceLayer = new PersistenceLayerTestClass();
-      const data = 'someData';
-      const lambdaFunctionName = 'LambdaName';
-      jest.spyOn(EnvironmentVariablesService.prototype, 'getLambdaFunctionName').mockReturnValue(lambdaFunctionName);
+    test('when called, it deletes the record with the idempotency key for the data passed in', () => {
 
-      const functionName = 'functionName';
-      const expectedIdempotencyKey = lambdaFunctionName + '.' + functionName + '#' + mockDigest;
-      persistenceLayer.configure(functionName);
+      // Prepare
+      const persistenceLayer: PersistenceLayer = new PersistenceLayerTestClass();
+      const expectedIdempotencyKey = `${process.env.AWS_LAMBDA_FUNCTION_NAME}.${idempotentFunctionName}#${mockDigest}`;
+      persistenceLayer.configure({ functionName: idempotentFunctionName });
 
-      persistenceLayer.deleteRecord(data);
+      // Act
+      persistenceLayer.deleteRecord(dummyData);
+      
+      // Assess
       const deletedIdempotencyRecord: IdempotencyRecord = deleteRecord.mock.calls[0][0];
-
       expect(deletedIdempotencyRecord.idempotencyKey).toEqual(expectedIdempotencyKey);
+
     });
   });
 });

packages/idempotency/tests/unit/persistence/DynamoDbPersistenceLayer.test.ts

@@ -30,7 +30,6 @@
   "license": "MIT-0",
   "main": "./lib/index.js",
   "types": "./lib/index.d.ts",
-  "devDependencies": {},
   "files": [
     "lib"
   ],
@@ -41,7 +40,9 @@
   "bugs": {
     "url": "https://github.com/awslabs/aws-lambda-powertools-typescript/issues"
   },
-  "dependencies": {},
+  "dependencies": {
+    "@aws-sdk/util-base64-node": "^3.209.0"
+  },
   "keywords": [
     "aws",
     "lambda",
@@ -51,4 +52,4 @@
     "serverless",
     "nodejs"
   ]
-}
+}