adding Promise handling to jwtFromRequest result, type checking on result and error handling for new functionality.

lib/strategy.js

@@ -89,46 +89,57 @@ JwtStrategy.JwtVerifier = require('./verify_jwt');
  */
 JwtStrategy.prototype.authenticate = function(req, options) {
     var self = this;
+    var promise = null;
+    var tokenOrPromise = self._jwtFromRequest(req);
 
-    var token = self._jwtFromRequest(req);
-
-    if (!token) {
+    if (!tokenOrPromise) {
         return self.fail(new Error("No auth token"));
     }
-
-    this._secretOrKeyProvider(req, token, function(secretOrKeyError, secretOrKey) {
-        if (secretOrKeyError) {
-            self.fail(secretOrKeyError)
-        } else {
-            // Verify the JWT
-            JwtStrategy.JwtVerifier(token, secretOrKey, self._verifOpts, function(jwt_err, payload) {
-                if (jwt_err) {
-                    return self.fail(jwt_err);
-                } else {
-                    // Pass the parsed token to the user
-                    var verified = function(err, user, info) {
-                        if(err) {
-                            return self.error(err);
-                        } else if (!user) {
-                            return self.fail(info);
-                        } else {
-                            return self.success(user, info);
-                        }
-                    };
-
-                    try {
-                        if (self._passReqToCallback) {
-                            self._verify(req, payload, verified);
-                        } else {
-                            self._verify(payload, verified);
+    if (typeof tokenOrPromise === "string") {
+        promise = Promise.resolve(tokenOrPromise);
+    } else if (tokenOrPromise instanceof Promise) {
+        promise = tokenOrPromise;
+    } else {
+        return self.fail(new Error("token must be of type string | Promise<string>"));
+    }
+    promise.then(token => {
+        if (typeof token !== "string") {
+            return self.fail(new Error("token must be of type string"));
+        }
+        this._secretOrKeyProvider(req, token, function(secretOrKeyError, secretOrKey) {
+            if (secretOrKeyError) {
+                self.fail(secretOrKeyError)
+            } else {
+                // Verify the JWT
+                JwtStrategy.JwtVerifier(token, secretOrKey, self._verifOpts, function(jwt_err, payload) {
+                    if (jwt_err) {
+                        return self.fail(jwt_err);
+                    } else {
+                        // Pass the parsed token to the user
+                        var verified = function(err, user, info) {
+                            if(err) {
+                                return self.error(err);
+                            } else if (!user) {
+                                return self.fail(info);
+                            } else {
+                                return self.success(user, info);
+                            }
+                        };
+
+                        try {
+                            if (self._passReqToCallback) {
+                                self._verify(req, payload, verified);
+                            } else {
+                                self._verify(payload, verified);
+                            }
+                        } catch(ex) {
+                            self.error(ex);
                         }
-                    } catch(ex) {
-                        self.error(ex);
                     }
-                }
-            });
-        }
-    });
+                });
+            }
+        });
+    }).catch(err => self.fail(new Error(err)));
 };
 
 

test/strategy-requests-test.js

@@ -119,6 +119,76 @@ describe('Strategy', function() {
         });
 
     });
+
+    describe('returning Promise instead of string when getting JWT from request', function() {
+
+        var info;
+
+        before(function(done) {
+            strategy = new Strategy({jwtFromRequest: function(r) {return r}, secretOrKey: 'secret'}, function(jwt_payload, next) {
+                // Return values aren't important in this case
+                return next(null, {}, {});
+            });
+
+            mockVerifier.reset();
+
+            chai.passport.use(strategy)
+                .fail(function(i) {
+                    info = i
+                    done();
+                })
+                .req(function(req) {
+                    req.body = {}
+                })
+                .authenticate();
+        });
+
+
+        it('should fail authentication', function() {
+            expect(info).to.be.an.object;
+            expect(info.message).to.equal("token must be of type string | Promise<string>");
+        });
+
+
+        it('Should not try to verify anything', function() {
+            sinon.assert.notCalled(mockVerifier);
+        });
+
+    });
+
+    describe('returning Promise not resolving a string when getting JWT from request', function() {
+
+        var info;
+
+        before(function(done) {
+            strategy = new Strategy({jwtFromRequest: function(r) {return Promise.resolve()}, secretOrKey: 'secret'}, function(jwt_payload, next) {
+                // Return values aren't important in this case
+                return next(null, {}, {});
+            });
+
+            mockVerifier.reset();
+
+            chai.passport.use(strategy)
+                .fail(function(i) {
+                    info = i
+                    done();
+                })
+                .req(function(req) {
+                    req.body = {}
+                })
+                .authenticate();
+        });
+
+
+        it('should fail authentication', function() {
+            expect(info).to.be.an.object;
+            expect(info.message).to.equal("token must be of type string");
+        });
+
+        it('Should not try to verify anything', function() {
+            sinon.assert.notCalled(mockVerifier);
+        });
 
+    });
 
 });