fix(1030): Add method to call generating build JWT API and replace temporal JWT (#42)

* add temporal JWT

* add unit test

* remove unnecessay file

* delete package-lock.json

* fix test

* fix test

* delete try/catch

* fix to return value

* fix test

* fix test

* fix JSDoc

* strictSSL true

* fix test

* delete json

Author: sakka2

index.js

@@ -4,6 +4,8 @@
 const Joi = require('joi');
 const dataSchema = require('screwdriver-data-schema');
 const executorSchema = dataSchema.plugins.executor;
+const request = require('requestretry');
+const DEFAULT_BUILD_TIMEOUT = 90; // in minutes
 
 /**
  * Validate the config using the schema
@@ -121,6 +123,39 @@ class Executor {
     stats() {
         return {};
     }
+
+    /**
+     * Get JWT for build by using temporal JWT via API
+     * @method exchangeTokenForBuild
+     * @param  {Object}  config          A configuration object
+     * @param  {String}  config.apiUrl   Base URL for Screwdriver API
+     * @param  {String}  config.buildId  Build ID
+     * @param  {String}  config.token    Temporal JWT
+     * @param  {String}  buildTimeout    Build timeout value which will be JWT expires time
+     * @return {Promise}
+     */
+    async exchangeTokenForBuild(config, buildTimeout = DEFAULT_BUILD_TIMEOUT) {
+        if (isFinite(buildTimeout) === false) {
+            throw new Error(`Invalid buildTimeout value: ${buildTimeout}`);
+        }
+
+        const options = {
+            uri: `${config.apiUri}/v4/builds/${config.buildId}/token`,
+            method: 'POST',
+            body: { buildTimeout },
+            headers: { Authorization: `Bearer ${config.token}` },
+            strictSSL: true,
+            json: true
+        };
+
+        const response = await request(options);
+
+        if (response.statusCode !== 200) {
+            throw new Error(`Failed to exchange build token: ${JSON.stringify(response.body)}`);
+        }
+
+        return response.body.token;
+    }
 }
 
 module.exports = Executor;

package.json

@@ -41,10 +41,12 @@
     "eslint": "^4.19.1",
     "eslint-config-screwdriver": "^3.0.0",
     "jenkins-mocha": "^4.0.0",
-    "mockery": "^2.0.0"
+    "mockery": "^2.0.0",
+    "sinon": "^2.3.1"
   },
   "dependencies": {
     "joi": "^13.0.0",
+    "requestretry": "^1.13.0",
     "screwdriver-data-schema": "^18.20.0"
   }
 }

test/index.test.js

@@ -1,13 +1,16 @@
 'use strict';
 
 const { assert } = require('chai');
+const sinon = require('sinon');
 const mockery = require('mockery');
 const Joi = require('joi');
+const DEFAULT_BUILD_TIMEOUT = 90; // in minutes
 
 describe('index test', () => {
     let instance;
     let schemaMock;
     let Executor;
+    let requestMock;
 
     before(() => {
         mockery.enable({
@@ -24,10 +27,14 @@ describe('index test', () => {
                     stop: Joi.object().required(),
                     startPeriodic: Joi.object().required(),
                     stopPeriodic: Joi.object().required(),
-                    status: Joi.object().required()
+                    status: Joi.object().required(),
+                    exchangeTokenForBuild: Joi.object().required()
                 }
             }
         };
+        requestMock = sinon.stub();
+        mockery.registerMock('requestretry', requestMock);
+
         mockery.registerMock('screwdriver-data-schema', schemaMock);
 
         // eslint-disable-next-line global-require
@@ -151,4 +158,77 @@ describe('index test', () => {
             assert.equal(data.buildId, 'a');
         });
     });
+
+    describe('exchangeTokenForBuild', () => {
+        let postConfig;
+        let options;
+        let buildTimeout;
+        let fakeResponse;
+
+        beforeEach(() => {
+            postConfig = {
+                buildId: 111,
+                apiUri: 'https://dummy.com',
+                token: 'dummyTemporalToken'
+            };
+            buildTimeout = 150;
+            options = {
+                uri: `${postConfig.apiUri}/v4/builds/${postConfig.buildId}/token`,
+                method: 'POST',
+                body: { buildTimeout },
+                headers: { Authorization: `Bearer ${postConfig.token}` },
+                strictSSL: true,
+                json: true
+            };
+            fakeResponse = {
+                statusCode: 200,
+                body: {
+                    token: 'dummyBuildToken'
+                }
+            };
+        });
+
+        it('succeeds to exchange temporal JWT to build JWT', async () => {
+            requestMock.withArgs(options).resolves(fakeResponse);
+
+            await instance.exchangeTokenForBuild(postConfig, buildTimeout).then((buildToken) => {
+                assert.equal(fakeResponse.body.token, buildToken);
+            });
+        });
+
+        it('succeeds to exchange temporal JWT to build JWT without buildTimeout args', async () => {
+            options.body.buildTimeout = DEFAULT_BUILD_TIMEOUT;
+            requestMock.withArgs(options).resolves(fakeResponse);
+
+            await instance.exchangeTokenForBuild(postConfig).then((buildToken) => {
+                assert.equal(fakeResponse.body.token, buildToken);
+            });
+        });
+
+        it('returns error if buildTimeout value is invalid', async () => {
+            buildTimeout = 'aaa';
+            const returnMessage = `Invalid buildTimeout value: ${buildTimeout}`;
+
+            await instance.exchangeTokenForBuild(postConfig, buildTimeout).then(() => {
+                throw new Error('did not fail');
+            }, (err) => {
+                assert.equal(err.message, returnMessage);
+            });
+        });
+
+        it('returns error if response code is not 200', async () => {
+            fakeResponse.statusCode = 409;
+
+            const returnMessage =
+            `Failed to exchange build token: ${JSON.stringify(fakeResponse.body)}`;
+
+            requestMock.withArgs(options).resolves(fakeResponse);
+
+            await instance.exchangeTokenForBuild(postConfig, buildTimeout).then(() => {
+                throw new Error('did not fail');
+            }, (err) => {
+                assert.equal(err.message, returnMessage);
+            });
+        });
+    });
 });