Merge pull request #49 from autodesk-forks/add-account-api-token-support

Add account api token support

Author: rtfpessoa

bin/codacy-coverage.js

@@ -19,6 +19,9 @@
         .usage('[options]')
         .option('-f, --format [value]', 'Coverage input format')
         .option('-t, --token [value]', 'Codacy Project API Token')
+        .option('-a, --accountToken [value]', 'Codacy Account Token')
+        .option('-u, --username [value]', 'Codacy Username/Organization')
+        .option('-n, --projectName [value]', 'Codacy Project Name')
         .option('-c, --commit [value]', 'Commit SHA hash')
         .option('-l, --language [value', 'Project Language')
         .option('-e, --endpoint [value]', 'Codacy API Endpoint')
@@ -32,8 +35,8 @@
         debug: program.debug
     });
 
-    loggerImpl.info(util.format('Started with: token [%j], commitId [%j], language [%j], endpoint [%j], format [%j], path prefix [%j], verbose [%j], debug [%j]',
-        program.token, program.commit, program.language, program.endpoint, program.format, program.prefix, program.verbose, program.debug));
+    loggerImpl.info(util.format('Started with: token [%j], accountToken [%j], username [%j], projectName [%j], commitId [%j], language [%j], endpoint [%j], format [%j], path prefix [%j], verbose [%j], debug [%j]',
+        program.token, program.accountToken, program.username, program.projectName, program.commit, program.language, program.endpoint, program.format, program.prefix, program.verbose, program.debug));
 
     process.stdin.on('end', function () {
         loggerImpl.trace('Received file through stdin');

lib/handleInput.js

@@ -4,6 +4,9 @@
         opts = opts || {};
 
         var token = opts.token || process.env.CODACY_PROJECT_TOKEN || process.env.CODACY_REPO_TOKEN;
+        var accountToken = opts.accountToken || process.env.CODACY_ACCOUNT_TOKEN;
+        var username = opts.username;
+        var projectName = opts.projectName;
         var commit = opts.commit;
         var format = opts.format || 'lcov';
         var pathPrefix = opts.prefix || '';
@@ -15,21 +18,31 @@
             debug: opts.debug
         });
 
-        if (!token) {
+        if (!token && !accountToken) {
             return Promise.reject(new Error('Token is required'));
         }
 
-        loggerImpl.info(util.format('Handling input for: token [%j], commitId [%j], language [%j], endpoint [%j], format [%j], path prefix [%j], verbose [%j], debug [%j]',
-            token, commit, language, opts.endpoint, format, pathPrefix, opts.verbose, opts.debug));
+        if (accountToken) {
+            if (!username) {
+                return Promise.reject(new Error('When using an account token, a username is required.'));
+            }
+            if (!projectName) {
+                return Promise.reject(new Error('When using an account token, a project name is required.'));
+            }
+        }
+
+        loggerImpl.info(util.format('Handling input for: token [%j], accountToken [%j], username [%j], projectName [%j], commitId [%j], language [%j], endpoint [%j], format [%j], path prefix [%j], verbose [%j], debug [%j]',
+            token, accountToken, username, projectName, commit, language, opts.endpoint, format, pathPrefix, opts.verbose, opts.debug));
 
         // Parse the coverage data for the given format and retrieve the commit id if we don't have it.
         return Promise.all([parser.getParser(format).parse(pathPrefix, input), getGitData.getCommitId(commit)]).spread(function (parsedCoverage, commitId) {
             // Now that we've parse the coverage data to the correct format, send it to Codacy.
             loggerImpl.trace(parsedCoverage);
             loggerImpl.debug('Sending coverage');
             return reporter({
-                endpoint: opts.endpoint
-            }).sendCoverage(token, commitId, language, parsedCoverage);
+                endpoint: opts.endpoint,
+                accountToken: accountToken
+            }).sendCoverage(token, commitId, language, parsedCoverage, accountToken, username, projectName);
         });
     };
 }(require('./coverageParser'), require('./reporter'), require('./getGitData'), require('./logger'), require('bluebird'), require('util')));

lib/reporter.js

@@ -6,6 +6,9 @@
     });
     var tokenValidation = Joi.string().required().min(1).example('1234567890');//TODO: Revisit this validation to see if we can better validate the values
     var commitIdValidation = Joi.string().required().min(1).example('1234567890'); //TODO: Revisit this validation to see if we can better validate the values
+    var accountTokenValidation = Joi.string().required().min(1).example('1234567890');
+    var usernameValidation = Joi.string().required().min(1).example('1234567890');
+    var projectNameValidation = Joi.string().required().min(1).example('1234567890');
     var coverageDataValidation = Joi.object({
         total: Joi.number().integer().required().min(0).max(100),
         fileReports: Joi.array().required().items(Joi.object({
@@ -23,7 +26,7 @@
         coffee: 'coffeescript'
     };
 
-    function sendByLanguage(endpoint, commitId, token, data) {
+    function sendByLanguage(endpoint, commitId, token, data, accountToken, username, projectName) {
         var reportsByLanguage = lodash.groupBy(data.fileReports, function(elem) {
             return languageMap[lodash.head(lodash.takeRight(elem.filename.split('.'), 1))] || 'javascript';
         });
@@ -44,7 +47,7 @@
             dataPerLanguage.fileReports = fileReports;
             dataPerLanguage.total = Math.floor(finalCoverage);
 
-            return sendLanguage(endpoint, commitId, language, token, dataPerLanguage);
+            return sendLanguage(endpoint, commitId, language, token, dataPerLanguage, accountToken, username, projectName);
         });
 
         return Promise.all(languageResponses)
@@ -65,8 +68,9 @@
             });
     }
 
-    function sendForLanguage(endpoint, commitId, language, token, data) {
-        return sendLanguage(endpoint, commitId, language, token, data)
+
+    function sendForLanguage(endpoint, commitId, language, token, data, accountToken, username, projectName) {
+        return sendLanguage(endpoint, commitId, language, token, data, accountToken, username, projectName)
             .then(function(err) {
                 if (err) {
                     return Promise.reject(err);
@@ -77,18 +81,21 @@
             });
     }
 
-    function sendLanguage(endpoint, commitId, language, token, data) {
+    function sendLanguage(endpoint, commitId, language, token, data, accountToken, username, projectName) {
         var url = endpoint.replace(':commitId', commitId).replace(':language', language);
+        // jscs:disable
+        var headers = accountToken ? {api_token: accountToken} : {project_token: token};
+        // jscs:enable
+        if (accountToken) {
+            url = url.replace(':username', username).replace(':projectName', projectName);
+        }
+
         logger.trace(util.format('Sending POST to %s', url));
         return request({
             url: url,
             method: 'POST',
             json: data,
-            headers: {
-                // jscs:disable
-                project_token: token
-                // jscs:enable
-            },
+            headers: headers,
             resolveWithFullResponse: true
         }).then(function(res) {
             if (res.statusCode !== 200) {
@@ -116,29 +123,42 @@
             throw optionsValid.error;
         }
 
-        var endpoint = (options.endpoint || 'https://api.codacy.com') + '/2.0/coverage/:commitId/:language';
+        var endpointPostfix = options.accountToken ? '/2.0/:username/:projectName/commit/:commitId/coverage/:language' : '/2.0/coverage/:commitId/:language';
+
+        var endpoint = (options.endpoint || 'https://api.codacy.com') + endpointPostfix;
+
         logger.debug('Setting up reporter communicating to: ' + endpoint);
 
         return {
-            sendCoverage: function sendCoverage(token, commitId, language, data) {
+            sendCoverage: function sendCoverage(token, commitId, language, data, accountToken, username, projectName) {
                 logger.trace(util.format('Sending Coverage for token [%s] and commitId [%s]', token, commitId));
                 var tokenValid = Joi.validate(token, tokenValidation);
                 var commitIdValid = Joi.validate(commitId, commitIdValidation);
                 var dataValid = Joi.validate(data, coverageDataValidation, {
                     stripUnknown: true
                 });
-                var validationErr = tokenValid.error || commitIdValid.error || dataValid.error;
+                var validationErr = commitIdValid.error || dataValid.error;
+
+                if (accountToken) {
+                    var accountTokenValid = Joi.validate(accountToken, accountTokenValidation);
+                    var usernameValid = Joi.validate(username, usernameValidation);
+                    var projectNameValid = Joi.validate(projectName, projectNameValidation);
+
+                    validationErr = validationErr || accountTokenValid.error || usernameValid.error || projectNameValid.error;
+                } else {
+                    validationErr = validationErr || tokenValid.error;
+                }
 
                 if (validationErr) {
                     logger.error(validationErr);
                     return Promise.reject(validationErr);
                 }
 
                 if (language) {
-                    return sendForLanguage(endpoint, commitId, language, token, data);
+                    return sendForLanguage(endpoint, commitId, language, token, data, accountToken, username, projectName);
                 }
 
-                return sendByLanguage(endpoint, commitId, token, data);
+                return sendByLanguage(endpoint, commitId, token, data, accountToken, username, projectName);
             }
         };
     };

test/cli.js

@@ -62,8 +62,8 @@
                     return done(new Error('Should return with error'));
                 }
 
-                expect(res).to.match(/Started with: token \["1234"], commitId \["4321"], language \[undefined], endpoint \["something"], format \["lcov"], path prefix \["asdf\/"], verbose \[true], debug \[true]/);
-                expect(res).to.match(/Handling input for: token \["1234"], commitId \["4321"], language \[undefined], endpoint \["something"], format \["lcov"], path prefix \["asdf\/"], verbose \[true], debug \[true]/);
+                expect(res).to.match(/Started with: token \["1234"], accountToken \[undefined], username \[undefined], projectName \[undefined], commitId \["4321"], language \[undefined], endpoint \["something"], format \["lcov"], path prefix \["asdf\/"], verbose \[true], debug \[true]/);
+                expect(res).to.match(/Handling input for: token \["1234"], accountToken \[undefined], username \[undefined], projectName \[undefined], commitId \["4321"], language \[undefined], endpoint \["something"], format \["lcov"], path prefix \["asdf\/"], verbose \[true], debug \[true]/);
                 expect(err.code).to.equal(1);
                 done();
             });

test/helper.js

@@ -45,9 +45,25 @@
         });
     }
 
+    function setupMockAccountApiEndpoint(apiToken, commitId, username, projectName, bodyValidator) {
+        return new Promise(function (resolve) {
+            expect(apiToken).to.be.ok();
+            expect(commitId).to.be.ok();
+            expect(username).to.be.ok();
+            expect(projectName).to.be.ok();
+            expect(bodyValidator).to.be.ok();
+            return resolve(nock('https://api.codacy.com')
+                .post('/2.0/' + username + '/' + projectName + '/commit/' + commitId + '/coverage' + '/javascript', function(body) {
+                    var result = bodyValidator.validate(body);
+                    return !result.error;
+                }).reply(200));
+        });
+    }
+
     module.exports = {
         setupMockEndpoint: setupMockEndpoint,
         setupLangMockEndpoint: setupLangMockEndpoint,
+        setupMockAccountApiEndpoint: setupMockAccountApiEndpoint,
         chai: chai,
         clearEnvironmentVariables: function () {
             process.env.CODACY_GIT_COMMIT = '';

test/reporter.js

@@ -49,6 +49,20 @@
                     });
                 });
         });
+        it('should be able to use the account api mock end-point', function() {
+            return helper.setupMockAccountApiEndpoint('1234', '4321', 'username', 'project-name', bodyValidator)
+                .then(function() {
+                    return expect(request({
+                        url: 'https://api.codacy.com/2.0/username/project-name/commit/4321/coverage/javascript',
+                        method: 'POST',
+                        json: sampleCoverageData,
+                        resolveWithFullResponse: true
+                    }).promise()).to.eventually.satisfy(function (res) {
+                        expect(res.statusCode).to.equal(200);
+                        return true;
+                    });
+                });
+        });
         it('shouldn\'t be able to create a reporter with invalid options', function () {
             return expect(function () {
                 reporter({endpoint: 1});
@@ -78,6 +92,22 @@
                         .to.eventually.be.rejectedWith(Error, 'Expected Successful Status Code, but got [418]');
                 });
         });
+        it('should be able to report data with an api token', function() {
+            return helper.setupMockAccountApiEndpoint('1234', '4321', 'username', 'project-name', bodyValidator)
+                .then(function() {
+                    return expect(reporter({accountToken: '1234'})
+                        .sendCoverage(null, '4321', 'javascript', sampleCoverageData, '1234', 'username', 'project-name'))
+                        .to.eventually.be.fulfilled();
+                });
+        });
+        it('should not report data without a project name', function() {
+            return helper.setupMockAccountApiEndpoint('1234', '4321', 'username', 'project-name', bodyValidator)
+                .then(function() {
+                    return expect(reporter({accountToken: '1234'})
+                        .sendCoverage(null, '4321', 'javascript', sampleCoverageData, '1234', null, 'project-name'))
+                        .to.eventually.be.rejected();
+                });
+        });
     });
 
 }(require('joi'), require('request-promise'), require('../lib/reporter'), require('./helper')));