Merge branch 'release/1.2.2'

Author: diana.ionita

package-lock.json

@@ -1,6 +1,6 @@
 {
   "name": "serverless-api-gateway-caching",
-  "version": "1.2.1",
+  "version": "1.2.2",
   "description": "A plugin for the serverless framework which helps with configuring caching for API Gateway endpoints.",
   "main": "src/apiGatewayCachingPlugin.js",
   "scripts": {

package.json

@@ -15,7 +15,8 @@ const getApiGatewayMethodNameFor = (path, httpMethod) => {
   let gatewayResourceName = pathElements
     .map(element => {
       element = element.toLowerCase();
-      element = element.replace('+', '');
+      element = element.replaceAll('+', '');
+      element = element.replaceAll('_', '');
       if (element.startsWith('{')) {
         element = element.substring(element.indexOf('{') + 1, element.indexOf('}')) + "Var";
       }
@@ -37,11 +38,7 @@ const addPathParametersCacheConfig = (settings, serverless) => {
     if (!method) {
       serverless.cli.log(`[serverless-api-gateway-caching] The method ${resourceName} couldn't be found in the
                            compiled CloudFormation template. Caching settings will not be updated for this endpoint.`);
-      const index = settings.endpointSettings.indexOf(endpointSettings);
-      if (index != -1) {
-        settings.endpointSettings.splice(index, 1);
-      }
-      return;
+      continue;
     }
     if (!method.Properties.Integration.CacheKeyParameters) {
       method.Properties.Integration.CacheKeyParameters = [];

src/pathParametersCache.js

@@ -121,6 +121,64 @@ describe('Configuring path parameter caching', () => {
     });
   });
 
+  describe('when one endpoint has cache key parameters and a path parameter containing underscore', () => {
+    let cacheKeyParameters, method;
+    let functionWithoutCachingName, functionWithCachingName;
+    before(() => {
+      functionWithoutCachingName = 'list-all-cats';
+      let functionWithoutCaching = given.a_serverless_function(functionWithoutCachingName)
+        .withHttpEndpoint('get', '/cats');
+
+      functionWithCachingName = 'get-cat-by-paw-id';
+      cacheKeyParameters = [{ name: 'request.path.paw_id' }, { name: 'request.header.Accept-Language' }];
+      let functionWithCaching = given.a_serverless_function(functionWithCachingName)
+        .withHttpEndpoint('get', '/cat/{paw_id}', { enabled: true, cacheKeyParameters });
+
+      serverless = given.a_serverless_instance(serviceName)
+        .withApiGatewayCachingConfig(true, '0.5', 45)
+        .forStage(stage)
+        .withFunction(functionWithCaching)
+        .withFunction(functionWithoutCaching);
+
+      when_configuring_path_parameters(serverless);
+    });
+
+    describe('on the method corresponding with the endpoint with cache key parameters', () => {
+      before(() => {
+        method = serverless.getMethodResourceForFunction(functionWithCachingName);
+      });
+
+      it('should configure them as request parameters', () => {
+        for (let parameter of cacheKeyParameters) {
+          expect(method.Properties.RequestParameters)
+            .to.deep.include({
+              [`method.${parameter.name}`]: {}
+            });
+        }
+      });
+
+      it('should set integration request parameters', () => {
+        for (let parameter of cacheKeyParameters) {
+          expect(method.Properties.Integration.RequestParameters)
+            .to.deep.include({
+              [`integration.${parameter.name}`]: `method.${parameter.name}`
+            });
+        }
+      });
+
+      it('should set integration cache key parameters', () => {
+        for (let parameter of cacheKeyParameters) {
+          expect(method.Properties.Integration.CacheKeyParameters)
+            .to.include(`method.${parameter.name}`);
+        }
+      });
+
+      it('should set a cache namespace', () => {
+        expect(method.Properties.Integration.CacheNamespace).to.exist;
+      });
+    });
+  });
+
   describe('when one endpoint has cache key parameters', () => {
     let cacheKeyParameters, functionWithCachingName;
     before(() => {