akamai-edgegrid 3.1.2

package/src/helpers.js

@@ -0,0 +1,159 @@
+// Copyright 2014 Akamai Technologies, Inc. All Rights Reserved
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+const crypto = require('crypto'),
+    moment = require('moment'),
+    logger = require('./logger'),
+    path = require('path'),
+    os = require('os');
+
+module.exports = {
+    createTimestamp: function () {
+        return moment().utc().format('YYYYMMDDTHH:mm:ss+0000');
+    },
+
+    contentHash: function (request, maxBody) {
+        let contentHash = '',
+            preparedBody = request.body || '',
+            isTarball = preparedBody instanceof Uint8Array && request.headers['Content-Type'] === 'application/gzip';
+
+        if (typeof preparedBody === 'object' && !isTarball) {
+            let postDataNew = '',
+                key;
+
+            logger.info('Body content is type Object, transforming to POST data');
+
+            for (key in preparedBody) {
+                postDataNew += key + '=' + encodeURIComponent(JSON.stringify(preparedBody[key])) + '&';
+            }
+
+            // Strip trailing ampersand
+            postDataNew = postDataNew.replace(/&+$/, "");
+
+            preparedBody = postDataNew;
+            request.body = preparedBody; // Is this required or being used?
+        }
+
+        logger.info('Body is \"' + preparedBody + '\"');
+        logger.debug('PREPARED BODY LENGTH', preparedBody.length);
+
+        if (request.method === 'POST' && preparedBody.length > 0) {
+
+            logger.info('Signing content: \"' + preparedBody + '\"');
+
+            // If body data is too large, cut down to max-body size
+            if (preparedBody.length > maxBody) {
+                logger.warn('Data length (' + preparedBody.length + ') is larger than maximum ' + maxBody);
+                if (isTarball)
+                    preparedBody = preparedBody.slice(0, maxBody);
+                else
+                    preparedBody = preparedBody.substring(0, maxBody);
+                logger.info('Body truncated. New value \"' + preparedBody + '\"');
+            }
+
+            logger.debug('PREPARED BODY', preparedBody);
+
+            contentHash = this.base64Sha256(preparedBody);
+            logger.info('Content hash is \"' + contentHash + '\"');
+        }
+
+        return contentHash;
+    },
+
+    dataToSign: function (request, authHeader, maxBody) {
+        const parsedUrl = new URL(request.url),
+            dataToSign = [
+                request.method.toUpperCase(),
+                parsedUrl.protocol.replace(":", ""),
+                parsedUrl.host,
+                parsedUrl.pathname + parsedUrl.search,
+                this.canonicalizeHeaders(request.headersToSign),
+                this.contentHash(request, maxBody),
+                authHeader
+            ];
+
+        const dataToSignStr = dataToSign.join('\t').toString();
+
+        logger.info('Data to sign: "' + dataToSignStr + '" \n');
+
+        return dataToSignStr;
+    },
+
+    extend: function (a, b) {
+        let key;
+
+        for (key in b) {
+            if (!a.hasOwnProperty(key)) {
+                a[key] = b[key];
+            }
+        }
+
+        return a;
+    },
+
+    isRedirect: function (statusCode) {
+        return [
+            300, 301, 302, 303, 307
+        ].indexOf(statusCode) !== -1;
+    },
+
+    base64Sha256: function (data) {
+        const shasum = crypto.createHash('sha256').update(data);
+
+        return shasum.digest('base64');
+    },
+
+    base64HmacSha256: function (data, key) {
+        const encrypt = crypto.createHmac('sha256', key);
+
+        encrypt.update(data);
+
+        return encrypt.digest('base64');
+    },
+
+    /**
+     * Creates a String containing a tab delimited set of headers.
+     * @param  {Object} headers Object containing the headers to add to the set.
+     * @return {String}         String containing a tab delimited set of headers.
+     */
+    canonicalizeHeaders: function (headers) {
+        const formattedHeaders = [];
+        let key;
+
+        for (key in headers) {
+            formattedHeaders.push(key.toLowerCase() + ':' + headers[key].trim().replace(/\s+/g, ' '));
+        }
+
+        return formattedHeaders.join('\t');
+    },
+
+    signingKey: function (timestamp, clientSecret) {
+        const key = this.base64HmacSha256(timestamp, clientSecret);
+
+        logger.info('Signing key: ' + key + '\n');
+
+        return key;
+    },
+
+    signRequest: function (request, timestamp, clientSecret, authHeader, maxBody) {
+        return this.base64HmacSha256(this.dataToSign(request, authHeader, maxBody), this.signingKey(timestamp, clientSecret));
+    },
+
+    resolveHome: function (filePath) {
+        if (filePath[0] === '~') {
+            return path.join(os.homedir(), filePath.slice(1));
+        }
+        return filePath;
+    },
+};

package/src/logger.js

@@ -0,0 +1,26 @@
+// Copyright 2014 Akamai Technologies, Inc. All Rights Reserved
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+const log4js = require('log4js'),
+    logger = log4js.getLogger();
+
+if (!process.env.LOG4JS_CONFIG) {
+  logger.setLevel(log4js.levels.ERROR);
+}
+
+if (process.env.EDGEGRID_ENV === 'test') {
+  logger.level = log4js.levels.OFF;
+}
+
+module.exports = logger;

package/test/src/api_test.js

@@ -0,0 +1,324 @@
+// Copyright 2014 Akamai Technologies, Inc. All Rights Reserved
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+const assert = require('assert'),
+    nock = require('nock'),
+    path = require('path'),
+    Api = require('../../src/api');
+
+describe('Api', function () {
+    beforeEach(function () {
+        this.api = new Api(
+            'clientToken',
+            'clientSecret',
+            'accessToken',
+            'base.com'
+        );
+    });
+
+    // clear env variables which might be set in tests
+    beforeEach(function () {
+        process.env['AKAMAI_HOST'] = '';
+        process.env['AKAMAI_CLIENT_TOKEN'] = '';
+        process.env['AKAMAI_CLIENT_SECRET'] = '';
+        process.env['AKAMAI_ACCESS_TOKEN'] = '';
+    });
+
+    describe('.config', function () {
+        it('reports the client token', function () {
+            assert.strictEqual(this.api.config.client_token, 'clientToken');
+        });
+
+        it('reports the client secret', function () {
+            assert.strictEqual(this.api.config.client_secret, 'clientSecret');
+        });
+
+        it('reports the access token', function () {
+            assert.strictEqual(this.api.config.access_token, 'accessToken');
+        });
+
+        it('reports the API host', function () {
+            assert.strictEqual(this.api.config.host, 'https://base.com');
+        });
+
+        describe('when it is instantiated with an API host that already contains the protocol', function () {
+            it('it does not double declare the protocol', function () {
+                this.api = new Api(
+                    'clientToken',
+                    'clientSecret',
+                    'accessToken',
+                    'https://base.com'
+                );
+
+                assert.strictEqual(this.api.config.host, 'https://base.com');
+            });
+        });
+
+        describe('when it is instantiated with an object', function () {
+            beforeEach(function () {
+                this.api = new Api({
+                    path: path.resolve(__dirname, '../test_edgerc'),
+                    section: 'section'
+                });
+            });
+
+            it('reports the client token from the edgerc associated with the specified section', function () {
+                assert.strictEqual(this.api.config.client_token, 'sectionClientToken');
+            });
+
+            it('reports the client secret from the edgerc associated with the specified section', function () {
+                assert.strictEqual(this.api.config.client_secret, 'sectionClientSecret');
+            });
+
+            it('reports the access token from the edgerc associated with the specified section', function () {
+                assert.strictEqual(this.api.config.access_token, 'sectionAccessToken');
+            });
+
+            it('reports the API host from the edgerc associated with the specified section', function () {
+                assert.strictEqual(this.api.config.host, 'https://sectionexample.luna.akamaiapis.net');
+            });
+
+            describe('when it is instantiated with an object that does not specfy a section', function () {
+                beforeEach(function () {
+                    this.api = new Api({
+                        path: path.resolve(__dirname, '../test_edgerc')
+                    });
+                });
+
+                it('reports the client token from the edgerc associated with the default section', function () {
+                    assert.strictEqual(this.api.config.client_token, 'clientToken');
+                });
+
+                it('reports the client secret from the edgerc associated with the default section', function () {
+                    assert.strictEqual(this.api.config.client_secret, 'clientSecret');
+                });
+
+                it('reports the access token from the edgerc associated with the default section', function () {
+                    assert.strictEqual(this.api.config.access_token, 'accessToken');
+                });
+
+                it('reports the API host from the edgerc associated with the default section', function () {
+                    assert.strictEqual(this.api.config.host, 'https://example.luna.akamaiapis.net');
+                });
+            });
+
+            describe('when it is instantiated with an object that does not specify a path nor a section', function () {
+                beforeEach(function () {
+                    process.env['AKAMAI_HOST'] = 'https://example.luna.akamaiapis.net';
+                    process.env['AKAMAI_CLIENT_TOKEN'] = 'clientToken';
+                    process.env['AKAMAI_CLIENT_SECRET'] = 'clientSecret';
+                    process.env['AKAMAI_ACCESS_TOKEN'] = 'accessToken';
+                    this.api = new Api({});
+                });
+                it('uses config from env variables with default section', function () {
+                    assert.strictEqual(this.api.config.host, "https://example.luna.akamaiapis.net");
+                    assert.strictEqual(this.api.config.client_token, "clientToken");
+                    assert.strictEqual(this.api.config.client_secret, "clientSecret");
+                    assert.strictEqual(this.api.config.access_token, "accessToken");
+                });
+            });
+
+            describe('when it is instantiated with an object that specifies an inadequate path', function () {
+                it('throws the appropriate error', function () {
+                    assert.throws(
+                        function () {
+                            return new Api({
+                                path: ''
+                            });
+                        },
+                        /Either path to '.edgerc' or environment variables with edgerc configuration has to be provided./
+                    );
+                });
+            });
+        });
+    });
+
+    describe('when it is not instantiated with valid credentials', function () {
+        it('throws the appropriate error', function () {
+            assert.throws(
+                function () {
+                    return new Api();
+                },
+                /Insufficient Akamai credentials/
+            );
+        });
+    });
+
+    describe('#auth', function () {
+        it('should be chainable', function () {
+            assert.deepStrictEqual(this.api, this.api.auth({path: '/foo'}));
+        });
+
+        describe('when minimal request options are passed', function () {
+            beforeEach(function () {
+                this.api.auth({
+                    path: '/foo'
+                });
+            });
+
+            it('adds an Authorization header to the request it is passed', function () {
+                assert.strictEqual(typeof this.api.request.headers.Authorization === 'string', true);
+            });
+
+            it('ensures a default Content-Type of application/json', function () {
+                assert.strictEqual(this.api.request.headers['Content-Type'], 'application/json');
+            });
+
+            it('ensures a default GET method', function () {
+                assert.strictEqual(this.api.request.method, 'GET');
+            });
+
+            it('ensures a default empty body', function () {
+                assert.strictEqual(this.api.request.body, '');
+            });
+
+            it('ensures a url is properly declared', function () {
+                assert.strictEqual(this.api.request.url, 'https://base.com/foo');
+            });
+        });
+
+        describe('when more specific request options are passed', function () {
+            beforeEach(function () {
+                this.api.auth({
+                    path: '/foo',
+                    method: 'POST',
+                    body: {
+                        foo: 'bar'
+                    },
+                    somethingArbitrary: 'someValue'
+                });
+            });
+
+            it('adds an Authorization header to the request it is passed', function () {
+                assert.strictEqual(typeof this.api.request.headers.Authorization === 'string', true);
+            });
+
+            it('ensures a default Content-Type of application/json', function () {
+                assert.strictEqual(this.api.request.headers['Content-Type'], 'application/json');
+            });
+
+            it('uses the specified POST method', function () {
+                assert.strictEqual(this.api.request.method, 'POST');
+            });
+
+            it('uses the specified body parsed as a JSON string', function () {
+                console.log("BODY: ", this.api.request.body);
+                assert.strictEqual(this.api.request.body, '{"foo":"bar"}');
+            });
+
+            it('extends the default request options with any others specified', function () {
+                assert.strictEqual(this.api.request.somethingArbitrary, 'someValue');
+            });
+        });
+    });
+
+    describe('#send', function () {
+
+        it('should be chainable', function () {
+            assert.deepStrictEqual(this.api, this.api.auth({path: '/foo'}).send());
+        });
+
+        describe('when authentication is done with a simple options object specifying only a path', function () {
+            beforeEach(function () {
+                nock('https://base.com')
+                    .get('/foo')
+                    .reply(200, {
+                        foo: 'bar'
+                    });
+            });
+
+            it('sends the HTTP GET request created by #auth', function (done) {
+                this.api.auth({
+                    path: '/foo'
+                });
+
+                this.api.send(function (err, resp, body) {
+                    assert.strictEqual(JSON.parse(body).foo, 'bar');
+                    done();
+                });
+            });
+        });
+
+        describe('when authentication is done with a more complex options object specifying only a path', function () {
+            beforeEach(function () {
+                nock('https://base.com')
+                    .post('/foo')
+                    .reply(200, {
+                        foo: 'bar'
+                    });
+            });
+
+            it('sends the HTTP created by #auth', function (done) {
+                this.api.auth({
+                    path: '/foo',
+                    method: 'POST'
+                });
+
+                this.api.send(function (err, resp, body) {
+                    assert.strictEqual(JSON.parse(body).foo, 'bar');
+                    done();
+                });
+            });
+        });
+
+        describe('when the initial request redirects', function () {
+            it('correctly follows the redirect and re-signs the request', function (done) {
+                let authHeader;
+                nock('https://base.com')
+                    .get('/foo')
+                    .reply(function () {
+                        authHeader = this.req.headers["authorization"];
+                        return [
+                            302,
+                            '',
+                            {'location': 'https://base.com/bar'}
+                        ];
+                    })
+                    .get('/bar')
+                    .reply(function () {
+                        assert.notStrictEqual(this.req.headers["authorization"], authHeader);
+                        return [
+                            200,
+                            {someKey: 'value'}
+                        ];
+                    });
+
+                this.api.auth({
+                    path: '/foo',
+                });
+
+                this.api.send(function (err, resp, body) {
+                    assert.strictEqual(JSON.parse(body).someKey, 'value');
+                    done();
+                });
+            });
+        });
+        describe('when the initial request fails', function () {
+            it('correctly handles the error in the callback', function (done) {
+                nock('https://base.com')
+                    .get('/foo')
+                    .replyWithError('something awful happened');
+
+                this.api.auth({
+                    path: '/foo',
+                });
+
+                this.api.send(function (data) {
+                    assert.strictEqual(data.message, 'something awful happened');
+                    done();
+                });
+            });
+        });
+    });
+});

package/test/src/edgerc_test.js

@@ -0,0 +1,154 @@
+// Copyright 2014 Akamai Technologies, Inc. All Rights Reserved
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+const assert = require('assert'),
+    path = require('path'),
+    edgerc = require('../../src/edgerc');
+
+describe('edgerc', function () {
+    beforeEach(function () {
+        process.env['AKAMAI_HOST'] = '';
+        process.env['AKAMAI_CLIENT_TOKEN'] = '';
+        process.env['AKAMAI_CLIENT_SECRET'] = '';
+        process.env['AKAMAI_ACCESS_TOKEN'] = '';
+    });
+    describe('the parsed edgrc file it returns', function () {
+        describe('when it is not passed a second argument indicating config section', function () {
+            beforeEach(function () {
+                this.config = edgerc(path.resolve(__dirname, '../test_edgerc'));
+            });
+
+            it('reports the default host', function () {
+                assert.strictEqual(this.config.host, 'https://example.luna.akamaiapis.net');
+            });
+
+            it('reports the default client_token', function () {
+                assert.strictEqual(this.config.client_token, 'clientToken');
+            });
+
+            it('reports the default client_secret', function () {
+                assert.strictEqual(this.config.client_secret, 'clientSecret');
+            });
+
+            it('reports the default access_token', function () {
+                assert.strictEqual(this.config.access_token, 'accessToken');
+            });
+        });
+
+        describe('when it is passed a second argument indicating config section', function () {
+            beforeEach(function () {
+                this.config = edgerc(path.resolve(__dirname, '../test_edgerc'), 'section');
+            });
+
+            it('reports the host associated with the section', function () {
+                assert.strictEqual(this.config.host, 'https://sectionexample.luna.akamaiapis.net');
+            });
+
+            it('reports the client_token associated with the section', function () {
+                assert.strictEqual(this.config.client_token, 'sectionClientToken');
+            });
+
+            it('reports the client_secret associated with the section', function () {
+                assert.strictEqual(this.config.client_secret, 'sectionClientSecret');
+            });
+
+            it('reports the access_token associated with the section', function () {
+                assert.strictEqual(this.config.access_token, 'sectionAccessToken');
+            });
+        });
+
+        describe('when the section contains a host with the "https://" protocal specified', function () {
+            beforeEach(function () {
+                this.config = edgerc(path.resolve(__dirname, '../test_edgerc'), 'https');
+            });
+
+            it('reports a host with a valid URI string', function () {
+                assert.strictEqual(this.config.host, 'https://example.luna.akamaiapis.net');
+            });
+        });
+
+        describe('when the section passed does not exist', function () {
+            it('throws the proper error', function () {
+                assert.throws(
+                    function () {
+                        return edgerc(path.resolve(__dirname, '../test_edgerc'), 'blah');
+                    },
+                    /An error occurred parsing the .edgerc file. You probably specified an invalid section name./
+                );
+            });
+        });
+
+        describe('when the section has comments', function () {
+            beforeEach(function () {
+                this.config = edgerc(path.resolve(__dirname, '../test_edgerc'), 'comment-test');
+            });
+
+            it('has six configuration items', function () {
+                assert.strictEqual(Object.keys(this.config).length, 6);
+            });
+
+            it('parses a value with a semicolon properly', function () {
+                assert.strictEqual(this.config.client_secret, "client;secret");
+            });
+
+            it('parses a complex value properly', function () {
+                assert.strictEqual(this.config.other, 'The "most" \\\'interesting\\\' ; value in the \\";world\\"');
+            });
+        });
+
+        describe('when the envs are used with default section', function () {
+            beforeEach(function () {
+                process.env['AKAMAI_HOST'] = 'https://example.luna.akamaiapis.net';
+                process.env['AKAMAI_CLIENT_TOKEN'] = 'clientToken';
+                process.env['AKAMAI_CLIENT_SECRET'] = 'clientSecret';
+                process.env['AKAMAI_ACCESS_TOKEN'] = 'accessToken';
+                this.config = edgerc();
+            });
+
+            it('has four configuration items', function () {
+                assert.strictEqual(Object.keys(this.config).length, 4);
+            });
+
+            it('has valid config values', function () {
+                assert.strictEqual(this.config.host, "https://example.luna.akamaiapis.net");
+                assert.strictEqual(this.config.client_token, "clientToken");
+                assert.strictEqual(this.config.client_secret, "clientSecret");
+                assert.strictEqual(this.config.access_token, "accessToken");
+            });
+        });
+
+        describe('when the envs are used with custom section', function () {
+            beforeEach(function () {
+                process.env['AKAMAI_SOME_SECTION_HOST'] = 'https://example.luna.akamaiapis.net';
+                process.env['AKAMAI_SOME_SECTION_CLIENT_TOKEN'] = 'clientToken';
+                process.env['AKAMAI_SOME_SECTION_CLIENT_SECRET'] = 'clientSecret';
+                process.env['AKAMAI_SOME_SECTION_ACCESS_TOKEN'] = 'accessToken';
+                this.config = edgerc(undefined, 'some_section');
+            });
+            afterEach(function () {
+                process.env['AKAMAI_SOME_SECTION_HOST'] = '';
+                process.env['AKAMAI_SOME_SECTION_CLIENT_TOKEN'] = '';
+                process.env['AKAMAI_SOME_SECTION_CLIENT_SECRET'] = '';
+                process.env['AKAMAI_SOME_SECTION_ACCESS_TOKEN'] = '';
+            });
+
+            it('has valid config values', function () {
+                assert.strictEqual(this.config.host, "https://example.luna.akamaiapis.net");
+                assert.strictEqual(this.config.client_token, "clientToken");
+                assert.strictEqual(this.config.client_secret, "clientSecret");
+                assert.strictEqual(this.config.access_token, "accessToken");
+            });
+        });
+    });
+});