@unito/integration-cli 0.55.1

package/dist/test/errors.test.js

@@ -0,0 +1,96 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const chai_1 = require("chai");
+const chalk_1 = tslib_1.__importDefault(require("chalk"));
+const sinon_1 = tslib_1.__importDefault(require("sinon"));
+const core_1 = require("@oclif/core");
+const path_1 = tslib_1.__importDefault(require("path"));
+const errors_1 = require("../src/errors");
+const configuration_1 = require("../src/resources/configuration");
+describe('handleError', () => {
+    let uxLogStub;
+    beforeEach(() => {
+        uxLogStub = sinon_1.default.stub(core_1.ux, 'log');
+    });
+    afterEach(() => {
+        sinon_1.default.restore();
+    });
+    it('should handle NoIntegrationFoundError', () => {
+        const error = new errors_1.NoIntegrationFoundError();
+        const handled = (0, errors_1.handleError)(error);
+        (0, chai_1.expect)(handled).to.be.true;
+        (0, chai_1.expect)(uxLogStub.calledTwice).to.be.true;
+        (0, chai_1.expect)(uxLogStub.firstCall.args[0]).to.equal(chalk_1.default.redBright('Your directory does not seem to contain an integration :('));
+        (0, chai_1.expect)(uxLogStub.secondCall.args[0]).to.include('Make sure you are in the right directory');
+    });
+    it('should handle NoConfigurationFileError', () => {
+        const error = new errors_1.NoConfigurationFileError();
+        const handled = (0, errors_1.handleError)(error);
+        (0, chai_1.expect)(handled).to.be.true;
+        (0, chai_1.expect)(uxLogStub.calledTwice).to.be.true;
+        (0, chai_1.expect)(uxLogStub.firstCall.args[0]).to.equal(chalk_1.default.redBright('This command requires a configuration file for your integration :('));
+        (0, chai_1.expect)(uxLogStub.secondCall.args[0]).to.equal(`This file should be located at ${chalk_1.default.yellowBright(path_1.default.relative(process.cwd(), (0, configuration_1.getConfigurationPath)()))}.`);
+    });
+    it('should handle MissingEnvironmentVariableError', () => {
+        const error = new errors_1.MissingEnvironmentVariableError('VAR_NAME');
+        const handled = (0, errors_1.handleError)(error);
+        (0, chai_1.expect)(handled).to.be.true;
+        (0, chai_1.expect)(uxLogStub.calledTwice).to.be.true;
+        (0, chai_1.expect)(uxLogStub.firstCall.args[0]).to.equal(chalk_1.default.redBright('This command requires a variable which is missing from your environment :('));
+        (0, chai_1.expect)(uxLogStub.secondCall.args[0]).to.equal(`Make sure the environment variable ${chalk_1.default.yellowBright('VAR_NAME')} is defined.`);
+    });
+    it('should return false for unrecognized error', () => {
+        const error = new Error('Unrecognized error');
+        const handled = (0, errors_1.handleError)(error);
+        (0, chai_1.expect)(handled).to.be.false;
+        (0, chai_1.expect)(uxLogStub.called).to.be.false;
+    });
+    it('should handle MissingEnvironmentVariableError', () => {
+        const error = new errors_1.ConfigurationInvalid('VAR_NAME', 'details', 'prettyDetails');
+        const handled = (0, errors_1.handleError)(error);
+        (0, chai_1.expect)(handled).to.be.true;
+        (0, chai_1.expect)(uxLogStub.calledThrice).to.be.true;
+        (0, chai_1.expect)(uxLogStub.firstCall.args[0]).to.equal(chalk_1.default.redBright(`Your ${chalk_1.default.yellowBright(path_1.default.basename((0, configuration_1.getConfigurationPath)()))} is invalid!`));
+        (0, chai_1.expect)(uxLogStub.thirdCall.args[0]).to.equal('prettyDetails');
+    });
+    it('should handle NoRefreshTokenError', () => {
+        const error = new errors_1.NoRefreshTokenError();
+        const handled = (0, errors_1.handleError)(error);
+        (0, chai_1.expect)(handled).to.be.true;
+        (0, chai_1.expect)(uxLogStub.calledOnce).to.be.true;
+        (0, chai_1.expect)(uxLogStub.firstCall.args[0]).to.equal(chalk_1.default.redBright('No refresh token found in your configuration file'));
+    });
+    it('should handle FailedToRetrieveAccessTokenError', () => {
+        const error = new errors_1.FailedToRetrieveAccessTokenError('Credentials invalid');
+        const handled = (0, errors_1.handleError)(error);
+        (0, chai_1.expect)(handled).to.be.true;
+        (0, chai_1.expect)(uxLogStub.calledThrice).to.be.true;
+        (0, chai_1.expect)(uxLogStub.firstCall.args[0]).to.equal(chalk_1.default.redBright('Failed to retrieve access token'));
+        (0, chai_1.expect)(uxLogStub.thirdCall.args[0]).to.equal('Credentials invalid');
+    });
+    it('should handle InvalidRequestContentTypeError', () => {
+        const error = new errors_1.InvalidRequestContentTypeError('Invalid content type');
+        const handled = (0, errors_1.handleError)(error);
+        (0, chai_1.expect)(handled).to.be.true;
+        (0, chai_1.expect)(uxLogStub.calledThrice).to.be.true;
+        (0, chai_1.expect)(uxLogStub.firstCall.args[0]).to.equal(chalk_1.default.redBright('Invalid request content type'));
+        (0, chai_1.expect)(uxLogStub.thirdCall.args[0]).to.equal('Invalid content type');
+    });
+    it('should handle DecryptionAuthenticationError', () => {
+        const error = new errors_1.DecryptionAuthenticationError('secrets');
+        const handled = (0, errors_1.handleError)(error);
+        (0, chai_1.expect)(handled).to.be.true;
+        (0, chai_1.expect)(uxLogStub.calledThrice).to.be.true;
+        (0, chai_1.expect)(uxLogStub.secondCall.args[0]).to.equal(chalk_1.default.yellowBright('Your configuration contains encrypted secrets.'));
+        (0, chai_1.expect)(uxLogStub.thirdCall.args[0]).to.equal('To use them locally, you must be authenticated to Unito.');
+    });
+    it('should handle EntryDecryptionError', () => {
+        const error = new errors_1.EntryDecryptionError('key', 'value', 'staging');
+        const handled = (0, errors_1.handleError)(error);
+        (0, chai_1.expect)(handled).to.be.true;
+        (0, chai_1.expect)(uxLogStub.called).to.be.true;
+        (0, chai_1.expect)(uxLogStub.secondCall.args[0]).to.equal(chalk_1.default.yellowBright('Error decrypting entry:'));
+        (0, chai_1.expect)(uxLogStub.thirdCall.args[0]).to.equal(chalk_1.default.redBright('key: value'));
+    });
+});

package/dist/test/helpers/init.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/test/helpers/init.js

@@ -0,0 +1,6 @@
+"use strict";
+const path = require('path');
+process.env.TS_NODE_PROJECT = path.resolve('test/tsconfig.json');
+process.env.NODE_ENV = 'development';
+global.oclif = global.oclif || {};
+global.oclif.columns = 80;

package/dist/test/mocha.hooks.d.ts

@@ -0,0 +1,2 @@
+/// <reference types="mocha" />
+export declare const mochaHooks: () => Mocha.RootHookObject;

package/dist/test/mocha.hooks.js

@@ -0,0 +1,37 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mochaHooks = void 0;
+const mochaHooks = () => {
+    return {
+        async beforeAll() {
+            // Allow using `chai-as-promised` in all tests.
+            const chai = await Promise.resolve().then(() => __importStar(require('chai')));
+            const chaiAsPromised = await Promise.resolve().then(() => __importStar(require('chai-as-promised')));
+            chai.use(chaiAsPromised.default);
+        },
+    };
+};
+exports.mochaHooks = mochaHooks;

package/dist/test/oauth2Helper/oauth2Helper.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/test/oauth2Helper/oauth2Helper.test.js

@@ -0,0 +1,150 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+/* eslint-disable  @typescript-eslint/no-explicit-any */
+const chai_1 = require("chai");
+const sinon_1 = tslib_1.__importDefault(require("sinon"));
+const oauth2Helper_1 = tslib_1.__importStar(require("../../src/oauth2Helper/oauth2Helper")), oauth2Namespace = oauth2Helper_1;
+const configurationTypes_1 = require("../../src/configurationTypes");
+const errors_1 = require("../../src/errors");
+describe('OAuth2Helper', () => {
+    let oauth2Helper;
+    let openSpy;
+    let fetchStub;
+    beforeEach(() => {
+        const authorizationInfo = {
+            clientId: 'your-client-id',
+            clientSecret: 'your-client-secret',
+            authorizationUrl: 'https://provider.com/oauth/authorize',
+            scopes: [{ name: 'scope1' }, { name: 'scope2' }],
+            tokenUrl: 'https://provider.com/oauth/token',
+            grantType: configurationTypes_1.GrantType.AUTHORIZATION_CODE,
+            requestContentType: configurationTypes_1.RequestContentType.URL_ENCODED,
+            responseContentType: configurationTypes_1.RequestContentType.JSON,
+            tokenRequestParameters: {
+                header: {
+                    Authorization: 'custom',
+                },
+            },
+        };
+        oauth2Helper = new oauth2Helper_1.default(authorizationInfo);
+        fetchStub = sinon_1.default.stub().resolves({ json: sinon_1.default.stub().resolves({}), status: 200 });
+        sinon_1.default.stub(oauth2Helper, 'startServer').returns('http://localhost:5050');
+        sinon_1.default.stub(oauth2Helper, 'stopServer');
+        sinon_1.default.replace(global, 'fetch', fetchStub);
+        sinon_1.default.replace(oauth2Namespace, 'open', { open: (_url) => undefined });
+        openSpy = sinon_1.default.spy(oauth2Namespace.open, 'open');
+    });
+    afterEach(() => {
+        sinon_1.default.restore();
+    });
+    describe('handleAuthorize', () => {
+        it('should open the authorization URL', async () => {
+            const req = {};
+            const res = { json: sinon_1.default.stub() };
+            await oauth2Helper['handleAuthorize'](req, res);
+            sinon_1.default.assert.calledOnce(openSpy);
+            sinon_1.default.assert.calledWith(openSpy, 'https://provider.com/oauth/authorize?client_id=your-client-id&redirect_uri=%2Fcredentials%2Fnew%2Foauth2%2Fcallback&scope=scope1+scope2&response_type=code');
+            sinon_1.default.assert.calledOnce(res.json);
+        });
+        it('should maintain the pre-existing query parameters in authorization URL', async () => {
+            oauth2Helper['providerAuthorizationUrl'] = 'https://provider.com/oauth/authorize?query1=value1&query2=value2';
+            const req = {};
+            const res = { json: sinon_1.default.stub() };
+            await oauth2Helper['handleAuthorize'](req, res);
+            sinon_1.default.assert.calledOnce(openSpy);
+            sinon_1.default.assert.calledWith(openSpy, 'https://provider.com/oauth/authorize?query1=value1&query2=value2&client_id=your-client-id&redirect_uri=%2Fcredentials%2Fnew%2Foauth2%2Fcallback&scope=scope1+scope2&response_type=code');
+            (0, chai_1.expect)(openSpy.firstCall.args[0]).to.includes('query1=value1');
+            (0, chai_1.expect)(openSpy.firstCall.args[0]).to.includes('query2=value2');
+            sinon_1.default.assert.calledOnce(res.json);
+        });
+    });
+    describe('handleCallback', () => {
+        it('should store the authorization code', async () => {
+            const code = 'test-code';
+            const req = { query: { code } };
+            const res = { json: sinon_1.default.stub() };
+            await oauth2Helper['handleCallback'](req, res);
+            (0, chai_1.expect)(oauth2Helper['code']).to.equal(code);
+            sinon_1.default.assert.calledOnce(res.json);
+        });
+    });
+    describe('handleToken', () => {
+        it('should retrieve the access token and return it in the response', async () => {
+            const req = { query: {} };
+            const res = { json: sinon_1.default.stub() };
+            await oauth2Helper['handleToken'](req, res);
+            sinon_1.default.assert.calledOnce(fetchStub);
+            sinon_1.default.assert.calledWith(fetchStub, 'https://provider.com/oauth/token', {
+                headers: {
+                    'Content-type': 'application/x-www-form-urlencoded',
+                    Authorization: 'custom',
+                },
+                body: sinon_1.default.match.string,
+                method: 'POST',
+            });
+            sinon_1.default.assert.calledOnce(res.json);
+        });
+        it('should handle errors and return 500 status', async () => {
+            const req = { query: {} };
+            const res = { status: sinon_1.default.stub().returns({ json: sinon_1.default.stub() }) };
+            fetchStub.rejects(new Error('Failed to retrieve access token'));
+            await oauth2Helper['handleToken'](req, res);
+            sinon_1.default.assert.calledWith(res.status, 500);
+        });
+        it('should return an error 400 if the request content type is not supported', async () => {
+            const req = { query: {} };
+            const res = { status: sinon_1.default.stub().returns({ json: sinon_1.default.stub() }) };
+            oauth2Helper['requestContentType'] = 'random';
+            await oauth2Helper['handleToken'](req, res);
+            sinon_1.default.assert.calledWith(res.status, 400);
+        });
+    });
+    describe('updateToken', () => {
+        it('should throw an error when no refresh token is available', async () => {
+            const response = oauth2Helper.updateToken();
+            await (0, chai_1.expect)(response).to.be.rejectedWith(errors_1.NoRefreshTokenError);
+        });
+        it('should retrieve the access token when a refresh token is available', async () => {
+            const refreshToken = 'test-refresh-token';
+            oauth2Helper['refreshToken'] = refreshToken;
+            const accessToken = 'test-access-token';
+            const fetchResponse = { access_token: accessToken, refresh_token: refreshToken };
+            fetchStub.resolves({ status: 200, json: sinon_1.default.stub().resolves(fetchResponse) });
+            const result = await oauth2Helper.updateToken();
+            (0, chai_1.expect)(result).to.deep.equal({ accessToken, refreshToken });
+            sinon_1.default.assert.calledOnce(fetchStub);
+        });
+        it('should throw an error when failing to refresh the access token', async () => {
+            const refreshToken = 'test-refresh-token';
+            oauth2Helper['refreshToken'] = refreshToken;
+            fetchStub.rejects(new Error('Failed to retrieve access token'));
+            const response = oauth2Helper.updateToken();
+            await (0, chai_1.expect)(response).to.be.rejectedWith(errors_1.FailedToRetrieveAccessTokenError);
+            sinon_1.default.assert.calledOnce(fetchStub);
+        });
+        it("should throw an error if we don't support the request content type", async () => {
+            const refreshToken = 'test-refresh-token';
+            oauth2Helper['refreshToken'] = refreshToken;
+            oauth2Helper['requestContentType'] = 'random';
+            const response = oauth2Helper.updateToken();
+            await (0, chai_1.expect)(response).to.be.rejectedWith(errors_1.InvalidRequestContentTypeError);
+        });
+    });
+    describe('encodeBody', () => {
+        it('should encode body data as URL-encoded when content type is URL_ENCODED', () => {
+            const bodyData = { key1: 'value1', key2: 'value2' };
+            const contentType = configurationTypes_1.RequestContentType.URL_ENCODED;
+            const expectedEncodedBody = 'key1=value1&key2=value2';
+            const encodedBody = oauth2Helper['encodeBody'](bodyData, contentType);
+            (0, chai_1.expect)(encodedBody).to.equal(expectedEncodedBody);
+        });
+        it('should encode body data as JSON when content type is JSON', () => {
+            const bodyData = { key1: 'value1', key2: 'value2' };
+            const contentType = configurationTypes_1.RequestContentType.JSON;
+            const expectedEncodedBody = JSON.stringify(bodyData);
+            const encodedBody = oauth2Helper['encodeBody'](bodyData, contentType);
+            (0, chai_1.expect)(encodedBody).to.equal(expectedEncodedBody);
+        });
+    });
+});

package/dist/test/resources/configuration.test.d.ts

@@ -0,0 +1 @@
+export {};