Add more index tests

Author: thenikso

index.js

@@ -60,9 +60,12 @@ module.exports = function(options) {
         const authSource = getObjectPath(['authorizer', 'identitySource'], e);
         const authValidatorExp = getObjectPath(['authorizer', 'identityValidationExpression'], e);
         const authCacheTtl = getObjectPath(['authorizer', 'resultTtlInSeconds'], e);
+        const authorizerArn = getObjectPath(['authorizer', 'arn'], e);
+        const authorizerName = getObjectPath(['authorizer', 'name'], e);
         const authorizerFunction = (
-          getObjectPath(getObjectPath(['authorizer', 'arn'], e) || '', httpConfig.authorizers) ||
-          getObjectPath(getObjectPath(['authorizer', 'name'], e) || '', slsHandlers)
+          (authorizerArn && getObjectPath(authorizerArn, httpConfig.authorizers)) ||
+          (authorizerName && getObjectPath(authorizerName, slsHandlers)) ||
+          (authorizerName && getObjectPath(`${funcConf.handler.split('.')[0]}.${authorizerName}`, slsHandlers))
         );
         // Prepare callback
         const callbacks = [

tests/index.test.js

@@ -21,35 +21,37 @@ describe('serverlessify', () => {
     let req;
     let res;
     let next;
-    const testConf = {
-      service: 'test-service',
-      functions: {
-        'test-function': {
-          handler: 'test-handler.test-function-handler',
-          events: [
-            {
-              http: {
-                path: 'test-path',
-                method: 'GET',
-              },
-            },
-          ],
-        },
-      },
-    };
-    const testHandler = sinon.spy();
-    const testHandlers = {
-      'test-handler': {
-        'test-function-handler': testHandler,
-      },
-    };
+    let testConf;
+    let testHandler;
+    let testHandlers;
 
     beforeEach(() => {
       httpEventHandler = sinon.spy();
       sls = serverlessify({
         http: { eventHandler: httpEventHandler },
       });
-      testHandler.reset();
+      testConf = {
+        service: 'test-service',
+        functions: {
+          'test-function': {
+            handler: 'test-handler.test-function-handler',
+            events: [
+              {
+                http: {
+                  path: 'test-path',
+                  method: 'GET',
+                },
+              },
+            ],
+          },
+        },
+      };
+      testHandler = sinon.spy();
+      testHandlers = {
+        'test-handler': {
+          'test-function-handler': testHandler,
+        },
+      };
       req = {
         method: 'test-req-method',
         headers: { 'test-req-header': 'test-req-header-value' },
@@ -115,5 +117,67 @@ describe('serverlessify', () => {
       reqDecorateCb(req, res, next);
       expect(req.lambda.event.principalId).to.equal('test-principal-id');
     });
+
+    it('should wrap a lambda with a wrapper function', () => {
+      const wrappedLambda = sinon.spy();
+      const wrapLambda = sinon.stub().returns(wrappedLambda);
+      sls = serverlessify({
+        http: {
+          eventHandler: httpEventHandler,
+          wrapLambda,
+        },
+      });
+      sls(testConf, testHandlers);
+      const callbacks = httpEventHandler.firstCall.args[2];
+      const lambdaCb = callbacks[1];
+      req.lambda = {
+        event: 'test-req-event',
+        context: 'test-req-context',
+      };
+      lambdaCb(req, res);
+      expect(wrapLambda).to.have.been.calledWith(testHandler);
+      expect(wrappedLambda).to.have.been.calledWith(
+        req.lambda.event,
+        req.lambda.context
+      );
+      expect(testHandler).to.have.callCount(0);
+    });
+
+    it('should add an authorization step with a local function', () => {
+      testConf.functions['test-function'].events[0].http.authorizer = {
+        name: 'test-authorizer',
+      };
+      const testAuthorizer = sinon.spy();
+      testHandlers['test-handler']['test-authorizer'] = testAuthorizer;
+      sls(testConf, testHandlers);
+      const callbacks = httpEventHandler.firstCall.args[2];
+      expect(callbacks).to.be.an('array');
+      expect(callbacks).to.have.lengthOf(4);
+    });
+
+    it('should add an authorization step with a global authorizer', () => {
+      testConf.functions['test-function'].events[0].http.authorizer = {
+        arn: 'test-authorizer-arn',
+      };
+      const testAuthorizer = sinon.spy();
+      sls = serverlessify({
+        http: {
+          eventHandler: httpEventHandler,
+          authorizers: {
+            'test-authorizer-arn': testAuthorizer,
+          },
+        },
+      });
+      sls(testConf, testHandlers);
+      const callbacks = httpEventHandler.firstCall.args[2];
+      expect(callbacks).to.be.an('array');
+      expect(callbacks).to.have.lengthOf(4);
+    });
+
+    it('should expose added functions via getFunction', () => {
+      sls(testConf, testHandlers);
+      const f = sls.getFunction('test-handler', 'test-function');
+      expect(f).to.exists;
+    });
   });
 });