tests(parameters): additional integration tests to DynamoDBProvider (#1285)

dreamorosi · web-flow · commit db215dd80c9a · 2023-02-10T20:10:12.000+01:00
diff --git a/packages/parameters/tests/e2e/dynamoDBProvider.class.test.functionCode.ts b/packages/parameters/tests/e2e/dynamoDBProvider.class.test.functionCode.ts
@@ -1,11 +1,15 @@
 import { Context } from 'aws-lambda';
 import { DynamoDBProvider } from '../../src/dynamodb';
+import {
+  DynamoDBGetOptionsInterface,
+  DynamoDBGetMultipleOptionsInterface,
+} from '../../src/types';
 import { TinyLogger } from '../helpers/tinyLogger';
-// # TODO: Uncomment code below once #1222 is fixed
-/*
 import { middleware } from '../helpers/sdkMiddlewareRequestCounter';
 import { DynamoDBClient } from '@aws-sdk/client-dynamodb';
-*/
+
+// We use a custom logger to log pure JSON objects to stdout
+const logger = new TinyLogger();
 
 const tableGet = process.env.TABLE_GET ?? 'my-table';
 const tableGetMultiple = process.env.TABLE_GET_MULTIPLE ?? 'my-table';
@@ -15,9 +19,6 @@ const keyAttr = process.env.KEY_ATTR ?? 'id';
 const sortAttr = process.env.SORT_ATTR ?? 'sk';
 const valueAttr = process.env.VALUE_ATTR ?? 'value';
 
-// We use a custom logger to log pure JSON objects to stdout
-const logger = new TinyLogger();
-
 // Provider test 1, 5, 6
 const providerGet = new DynamoDBProvider({
   tableName: tableGet,
@@ -39,163 +40,122 @@ const providerGetMultipleCustomKeys = new DynamoDBProvider({
   sortAttr,
   valueAttr,
 });
-// # TODO: Uncomment code below once #1222 is fixed
-/* 
+
 // Provider test 8, 9
 const customClient = new DynamoDBClient({});
-providerWithMiddleware.middlewareStack.use(middleware);
+customClient.middlewareStack.use(middleware);
 const providerWithMiddleware = new DynamoDBProvider({
-  awsSdkV3Client: customClient
+  awsSdkV3Client: customClient,
+  tableName: tableGet,
 });
-*/
 
-export const handler = async (_event: unknown, _context: Context): Promise<void> => {
-  // Test 1 - get a single parameter with default options (keyAttr: 'id', valueAttr: 'value')
+// Helper function to call get() and log the result
+const _call_get = async (
+  paramName: string,
+  testName: string,
+  provider: DynamoDBProvider,
+  options?: DynamoDBGetOptionsInterface,
+): Promise<void> => {
   try {
-    const parameterValue = await providerGet.get('my-param');
+    const parameterValue = await provider.get(paramName, options);
     logger.log({
-      test: 'get',
+      test: testName,
       value: parameterValue
     });
   } catch (err) {
     logger.log({
-      test: 'get',
+      test: testName,
       error: err.message
     });
   }
+};
 
-  // Test 2 - get multiple parameters with default options (keyAttr: 'id', sortAttr: 'sk', valueAttr: 'value')
+// Helper function to call getMultiple() and log the result
+const _call_get_multiple = async (
+  paramPath: string,
+  testName: string,
+  provider: DynamoDBProvider,
+  options?: DynamoDBGetMultipleOptionsInterface,
+): Promise<void> => {
   try {
-    const parametersValues = await providerGetMultiple.getMultiple('my-params');
+    const parameterValues = await provider.getMultiple(
+      paramPath,
+      options
+    );
     logger.log({
-      test: 'get-multiple',
-      value: parametersValues
+      test: testName,
+      value: parameterValues
     });
   } catch (err) {
     logger.log({
-      test: 'get-multiple',
+      test: testName,
       error: err.message
     });
   }
+};
+
+export const handler = async (_event: unknown, _context: Context): Promise<void> => {
+  // Test 1 - get a single parameter with default options (keyAttr: 'id', valueAttr: 'value')
+  await _call_get('my-param', 'get', providerGet);
+  
+  // Test 2 - get multiple parameters with default options (keyAttr: 'id', sortAttr: 'sk', valueAttr: 'value')
+  await _call_get_multiple('my-params', 'get-multiple', providerGetMultiple);
   
   // Test 3 - get a single parameter with custom options (keyAttr: 'key', valueAttr: 'val')
-  try {
-    const parameterValueCustom = await providerGetCustomKeys.get('my-param');
-    logger.log({
-      test: 'get-custom',
-      value: parameterValueCustom
-    });
-  } catch (err) {
-    logger.log({
-      test: 'get-custom',
-      error: err.message
-    });
-  }
+  await _call_get('my-param', 'get-custom', providerGetCustomKeys);
 
   // Test 4 - get multiple parameters with custom options (keyAttr: 'key', sortAttr: 'sort', valueAttr: 'val')
-  try {
-    const parametersValuesCustom = await providerGetMultipleCustomKeys.getMultiple('my-params');
-    logger.log({
-      test: 'get-multiple-custom',
-      value: parametersValuesCustom
-    });
-  } catch (err) {
-    logger.log({
-      test: 'get-multiple-custom',
-      error: err.message
-    });
-  }
+  await _call_get_multiple('my-params', 'get-multiple-custom', providerGetMultipleCustomKeys);
 
   // Test 5 - get a single parameter with json transform
-  try {
-    const parameterValueJson = await providerGet.get('my-param-json', {
-      transform: 'json'
-    });
-    logger.log({
-      test: 'get-json-transform',
-      value: typeof parameterValueJson // should be object
-    });
-  } catch (err) {
-    logger.log({
-      test: 'get-json-transform',
-      error: err.message
-    });
-  }
+  await _call_get('my-param-json', 'get-json-transform', providerGet, {
+    transform: 'json'
+  });
   
   // Test 6 - get a single parameter with binary transform
-  try {
-    const parameterValueBinary = await providerGet.get('my-param-binary', {
-      transform: 'binary'
-    });
-    logger.log({
-      test: 'get-binary-transform',
-      value: typeof parameterValueBinary // should be string
-    });
-  } catch (err) {
-    logger.log({
-      test: 'get-binary-transform',
-      error: err.message
-    });
-  }
+  await _call_get('my-param-binary', 'get-binary-transform', providerGet, {
+    transform: 'binary'
+  });
 
   // Test 7 - get multiple parameters with auto transform
-  try {
-    const parametersValuesAuto = await providerGetMultiple.getMultiple('my-encoded-params', {
-      transform: 'auto'
-    });
-    if (!parametersValuesAuto) throw new Error('parametersValuesAuto is undefined');
-    
-    logger.log({
-      test: 'get-multiple-auto-transform',
-      value:
-        `${typeof parametersValuesAuto['config.json']},${typeof parametersValuesAuto['key.binary']}` // should be object,string
-    });
-  } catch (err) {
-    logger.log({
-      test: 'get-multiple-auto-transform',
-      error: err.message
-    });
-  }
+  await _call_get_multiple('my-encoded-params', 'get-multiple-auto-transform', providerGetMultiple, {
+    transform: 'auto'
+  });
 
-  // # TODO: Uncomment code below once #1222 is fixed
-  /**
-   * Test 8 - get a parameter twice, second time should be cached
-   *  
-   * Should only make 1 request, we use middleware to count requests
-   */
-  /*
+  // Test 8
+  // get parameter twice with middleware, which counts the number of requests, we check later if we only called DynamoDB once
   try {
+    providerWithMiddleware.clearCache();
+    middleware.counter = 0;
     await providerWithMiddleware.get('my-param');
     await providerWithMiddleware.get('my-param');
     logger.log({
-      test: 'get-cache-request-count',
-      value: middleware.requestCount
+      test: 'get-cached',
+      value: middleware.counter // should be 1
     });
   } catch (err) {
     logger.log({
-      test: 'get-cache-request-count',
+      test: 'get-cached',
       error: err.message
     });
   }
-  */
 
-  /**
-   * Test 9 - get a parameter once more but with forceFetch = true
-   * 
-   * Request count should increase to 2, we use middleware to count requests
-   */
-  /*
+  // Test 9
+  // get parameter twice, but force fetch 2nd time, we count number of SDK requests and check that we made two API calls
   try {
+    providerWithMiddleware.clearCache();
+    middleware.counter = 0;
+    await providerWithMiddleware.get('my-param');
     await providerWithMiddleware.get('my-param', { forceFetch: true });
     logger.log({
-      test: 'get-force-fetch-request-count',
-      value: middleware.requestCount
+      test: 'get-forced',
+      value: middleware.counter // should be 2
     });
   } catch (err) {
     logger.log({
-      test: 'get-force-fetch-request-count',
+      test: 'get-forced',
       error: err.message
     });
   }
-  */
+
 };
diff --git a/packages/parameters/tests/e2e/dynamoDBProvider.class.test.ts b/packages/parameters/tests/e2e/dynamoDBProvider.class.test.ts
@@ -374,7 +374,7 @@ describe(`parameters E2E tests (dynamoDBProvider) for runtime: ${runtime}`, () =
 
       expect(testLog).toStrictEqual({
         test: 'get-json-transform',
-        value: 'object',
+        value: { foo: 'bar' },
       });
 
     });
@@ -387,7 +387,7 @@ describe(`parameters E2E tests (dynamoDBProvider) for runtime: ${runtime}`, () =
 
       expect(testLog).toStrictEqual({
         test: 'get-binary-transform',
-        value: 'string', // as opposed to Uint8Array
+        value: 'baz',
       });
 
     });
@@ -400,15 +400,40 @@ describe(`parameters E2E tests (dynamoDBProvider) for runtime: ${runtime}`, () =
 
       expect(testLog).toStrictEqual({
         test: 'get-multiple-auto-transform',
-        value: 'object,string',
+        value: {
+          'config.json': { foo: 'bar' },
+          'key.binary': 'baz',
+        },
+      });
+
+    });
+    
+    // Test 8 - Get a parameter twice and check that the value is cached.
+    it('should retrieve multiple parameters with auto transforms', async () => {
+
+      const logs = invocationLogs[0].getFunctionLogs();
+      const testLog = InvocationLogs.parseFunctionLog(logs[7]);
+
+      expect(testLog).toStrictEqual({
+        test: 'get-cached',
+        value: 1,
       });
 
     });
 
-    // TODO: implement tests for the following cases once #1222 is merged:
-    // Test 8 - get a parameter twice, second time should be cached
-    // Test 9 - get a parameter once more but with forceFetch = true
+    // Test 9 - Get a cached parameter and force retrieval.
+    it('should retrieve multiple parameters with auto transforms', async () => {
 
+      const logs = invocationLogs[0].getFunctionLogs();
+      const testLog = InvocationLogs.parseFunctionLog(logs[8]);
+
+      expect(testLog).toStrictEqual({
+        test: 'get-forced',
+        value: 2,
+      });
+
+    });
+    
   });
 
   afterAll(async () => {
