Merge pull request #166 from screwdriver-cd/user-tokens

feat: Get a user by token value

README.md

@@ -417,6 +417,7 @@ factory.create(config).then(model => {
 
 #### Get
 Get a user based on id. Can pass the generatedId for the user, or the username, and the id will be determined automatically.
+Can also pass a Screwdriver access token, and will get the user associated with that token.
 ```js
 factory.get(id).then(model => {
     // do stuff with user model
@@ -425,12 +426,17 @@ factory.get(id).then(model => {
 factory.get({ username }).then(model => {
     // do stuff with user model
 });
+
+factory.get({ token }).then(model => {
+    // do stuff with user model
+});
 ```
 
 | Parameter        | Type  |  Description |
 | :-------------   | :---- | :-------------|
 | id | String | The unique ID for the build |
 | config.username | String | User name |
+| config.accessToken | String | A user access token value |
 
 ### User Model
 ```js

lib/tokenFactory.js

@@ -61,7 +61,7 @@ class TokenFactory extends BaseFactory {
      * @return {Promise}
      */
     get(config) {
-        if (config && config.value) {
+        if (config.value) {
             config.hash = generateToken.hashValue(config.value);
             delete config.value;
         }

lib/userFactory.js

@@ -64,6 +64,38 @@ class UserFactory extends BaseFactory {
         });
     }
 
+    /**
+     * Get a user model by name, id, or personal access token
+     * @method get
+     * @param   {Mixed}     config
+     * @param   {String}    [config.username]       Username of the user to look up
+     * @param   {String}    [config.accessToken]    Access token of the user to look up
+     * @return  {Promise}
+     */
+    get(config) {
+        if (!config.accessToken) {
+            return super.get(config);
+        }
+
+        // Lazy load factory dependency to prevent circular dependency issues
+        // https://nodejs.org/api/modules.html#modules_cycles
+        /* eslint-disable global-require */
+        const TokenFactory = require('./tokenFactory');
+        /* eslint-enable global-require */
+        const tokenFactory = TokenFactory.getInstance();
+
+        return tokenFactory.get({ value: config.accessToken })
+            .then((token) => {
+                if (!token) {
+                    return token;
+                }
+
+                token.lastUsed = (new Date()).toISOString();
+
+                return token.update().then(() => this.get(token.userId));
+            });
+    }
+
     /**
      * Get an instance of the UserFactory
      * @method getInstance

test/lib/userFactory.test.js

@@ -5,13 +5,15 @@ const mockery = require('mockery');
 const sinon = require('sinon');
 
 sinon.assert.expose(assert, { prefix: '' });
+require('sinon-as-promised');
 
 describe('User Factory', () => {
     const password = 'totallySecurePassword';
     let UserFactory;
     let datastore;
     let hashaMock;
     let ironMock;
+    let tokenFactoryMock;
     let factory;
     let User;
 
@@ -35,9 +37,15 @@ describe('User Factory', () => {
             seal: sinon.stub(),
             defaults: 'defaults'
         };
+        tokenFactoryMock = {
+            get: sinon.stub()
+        };
 
         mockery.registerMock('screwdriver-hashr', hashaMock);
         mockery.registerMock('iron', ironMock);
+        mockery.registerMock('./tokenFactory', {
+            getInstance: sinon.stub().returns(tokenFactoryMock)
+        });
 
         // eslint-disable-next-line global-require
         User = require('../../lib/user');
@@ -96,6 +104,59 @@ describe('User Factory', () => {
         });
     });
 
+    describe('get a user by access token', () => {
+        const accessToken = 'an access token goes here';
+        const now = 1111;
+        const tokenMock = {
+            userId: 123,
+            lastUsed: null,
+            update: sinon.stub()
+        };
+        let sandbox;
+
+        beforeEach(() => {
+            sandbox = sinon.sandbox.create();
+            sandbox.useFakeTimers(now);
+            tokenFactoryMock.get.resolves(tokenMock);
+            tokenMock.update.resolves(tokenMock);
+        });
+
+        afterEach(() => {
+            sandbox.restore();
+        });
+
+        it('should return a user and update the last used field of the token', () => {
+            const expected = {
+                id: 123,
+                username: 'frodo'
+            };
+
+            datastore.get.resolves(expected);
+
+            return factory.get({ accessToken })
+                .then((user) => {
+                    assert.isOk(user);
+                    assert.calledWith(tokenFactoryMock.get, { value: accessToken });
+                    assert.calledOnce(tokenMock.update);
+                    assert.equal(tokenMock.lastUsed, (new Date(now)).toISOString());
+                });
+        });
+
+        it('should return null if the user doesn\'t exist', () => {
+            datastore.get.resolves(null);
+
+            return factory.get({ accessToken })
+                .then(user => assert.isNull(user));
+        });
+
+        it('should return null if the token doesn\'t exist', () => {
+            tokenFactoryMock.get.resolves(null);
+
+            return factory.get({ accessToken })
+                .then(user => assert.isNull(user));
+        });
+    });
+
     describe('getInstance', () => {
         let config;