@unito/integration-cli 0.55.1

package/dist/src/resources/integrationsPlatform.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateAuthenticated = void 0;
+const tslib_1 = require("tslib");
+const IntegrationsPlatformClient = tslib_1.__importStar(require("../services/integrationsPlatform"));
+const errors_1 = require("../errors");
+const GlobalConfiguration = tslib_1.__importStar(require("./globalConfiguration"));
+async function validateAuthenticated(globalConfiguration, environment) {
+    let apiKey = undefined;
+    if (environment === GlobalConfiguration.Environment.Local) {
+        apiKey = globalConfiguration.apiKeyLocal;
+    }
+    else if (environment === GlobalConfiguration.Environment.Staging) {
+        apiKey = globalConfiguration.apiKeyStaging;
+    }
+    else {
+        apiKey = globalConfiguration.apiKey;
+    }
+    // The API key to talk to the platform is missing. Out!
+    if (!apiKey) {
+        throw new errors_1.MissingApiKey();
+    }
+    // Setup the platform client.
+    IntegrationsPlatformClient.setEnvironment(environment);
+    IntegrationsPlatformClient.setApiKey(apiKey);
+    try {
+        await IntegrationsPlatformClient.getProfile();
+    }
+    catch {
+        throw new errors_1.AuthenticationFailed();
+    }
+}
+exports.validateAuthenticated = validateAuthenticated;

package/dist/src/services/integrationsPlatform.d.ts

@@ -0,0 +1,36 @@
+import IntegrationsPlatform from '@unito/integrations-platform-client';
+import { Environment } from '../resources/globalConfiguration';
+import { Configuration } from '../configurationTypes';
+export type User = IntegrationsPlatform.User;
+export type Credential = IntegrationsPlatform.Credential;
+export type Integration = IntegrationsPlatform.Integration;
+export type IntegrationSummary = IntegrationsPlatform.IntegrationSummary;
+export type IntegrationEvent = IntegrationsPlatform.IntegrationEvent;
+declare const HttpError: typeof IntegrationsPlatform.HttpError;
+export { HttpError };
+export declare const Servers: {
+    local: string;
+    staging: string;
+    production: string;
+};
+export declare function setEnvironment(environment: Environment): void;
+export declare function getApiKey(): string | undefined;
+export declare function setApiKey(apiKey: string | undefined): void;
+export declare function getProfile(): Promise<User>;
+export declare function encryptData(integrationName: string, data: string): Promise<{
+    encryptedData: string;
+}>;
+export declare function decryptData(integrationName: string, data: string): Promise<{
+    decryptedData: string;
+}>;
+export declare function reencryptData(integrationName: string, encryptedData: string, newIntegrationName: string): Promise<{
+    encryptedData: string;
+}>;
+export declare function getIntegration(integrationId: number): Promise<Integration>;
+export declare function getIntegrationByName(integrationName: string): Promise<Integration | null>;
+export declare function getIntegrations(): Promise<IntegrationSummary[]>;
+export declare function publishIntegration(archivePath: string): Promise<Integration>;
+export declare function createIntegration(configuration: Configuration): Promise<Integration>;
+export declare function inviteUserToIntegration(integrationId: number, email: string): Promise<Integration>;
+export declare function getIntegrationEvents(integrationId: number): Promise<IntegrationEvent[]>;
+export declare function updateIntegration(integrationId: number, configuration: Configuration): Promise<Integration>;

package/dist/src/services/integrationsPlatform.js

@@ -0,0 +1,162 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.updateIntegration = exports.getIntegrationEvents = exports.inviteUserToIntegration = exports.createIntegration = exports.publishIntegration = exports.getIntegrations = exports.getIntegrationByName = exports.getIntegration = exports.reencryptData = exports.decryptData = exports.encryptData = exports.getProfile = exports.setApiKey = exports.getApiKey = exports.setEnvironment = exports.Servers = exports.HttpError = void 0;
+const tslib_1 = require("tslib");
+const fs = tslib_1.__importStar(require("fs"));
+const integrations_platform_client_1 = tslib_1.__importDefault(require("@unito/integrations-platform-client"));
+const globalConfiguration_1 = require("../resources/globalConfiguration");
+const { HttpError } = integrations_platform_client_1.default;
+exports.HttpError = HttpError;
+exports.Servers = {
+    [globalConfiguration_1.Environment.Local]: integrations_platform_client_1.default.servers.local,
+    [globalConfiguration_1.Environment.Staging]: integrations_platform_client_1.default.servers.staging,
+    [globalConfiguration_1.Environment.Production]: integrations_platform_client_1.default.servers.production,
+};
+function setEnvironment(environment) {
+    integrations_platform_client_1.default.defaults.fetch = fetch;
+    integrations_platform_client_1.default.defaults.baseUrl = exports.Servers[environment];
+}
+exports.setEnvironment = setEnvironment;
+function getApiKey() {
+    const header = integrations_platform_client_1.default.defaults.headers?.Authorization?.toString();
+    return header?.split(' ')?.at(1);
+}
+exports.getApiKey = getApiKey;
+function setApiKey(apiKey) {
+    if (apiKey) {
+        integrations_platform_client_1.default.defaults.headers = { Authorization: `Bearer ${apiKey}` };
+    }
+    else {
+        integrations_platform_client_1.default.defaults.headers = undefined;
+    }
+}
+exports.setApiKey = setApiKey;
+async function getProfile() {
+    return integrations_platform_client_1.default.getProfile();
+}
+exports.getProfile = getProfile;
+async function encryptData(integrationName, data) {
+    return integrations_platform_client_1.default.encryptData({
+        integrationName,
+        data,
+    });
+}
+exports.encryptData = encryptData;
+async function decryptData(integrationName, data) {
+    return integrations_platform_client_1.default.decryptData({
+        integrationName,
+        data,
+    });
+}
+exports.decryptData = decryptData;
+async function reencryptData(integrationName, encryptedData, newIntegrationName) {
+    return integrations_platform_client_1.default.reencryptData({
+        integrationName,
+        encryptedData,
+        newIntegrationName,
+    });
+}
+exports.reencryptData = reencryptData;
+async function getIntegration(integrationId) {
+    return integrations_platform_client_1.default.getIntegrationById(integrationId);
+}
+exports.getIntegration = getIntegration;
+async function getIntegrationByName(integrationName) {
+    let integration;
+    try {
+        integration = await integrations_platform_client_1.default.getIntegrationByName(integrationName);
+    }
+    catch {
+        return null;
+    }
+    return integration;
+}
+exports.getIntegrationByName = getIntegrationByName;
+async function getIntegrations() {
+    const integrations = [];
+    let page;
+    const limit = 100;
+    let nextPageOffset = 0;
+    do {
+        page = await integrations_platform_client_1.default.getIntegrations({
+            pagination: { offset: nextPageOffset, limit },
+        });
+        nextPageOffset += limit;
+        integrations.push(...page.data);
+    } while (page.data.length >= limit);
+    return integrations;
+}
+exports.getIntegrations = getIntegrations;
+async function publishIntegration(archivePath) {
+    const file = fs.readFileSync(archivePath);
+    const blob = new Blob([file], { type: 'binary' });
+    return await integrations_platform_client_1.default.publishIntegration({ file: blob });
+}
+exports.publishIntegration = publishIntegration;
+async function createIntegration(configuration) {
+    // The creation of an integration is kept to its minimal required fields...
+    const integration = await integrations_platform_client_1.default.createIntegration({ name: configuration.name });
+    // ... as all other non-required fields are updated here.
+    return updateIntegration(integration.id, configuration);
+}
+exports.createIntegration = createIntegration;
+async function inviteUserToIntegration(integrationId, email) {
+    return await integrations_platform_client_1.default.inviteUser(integrationId, { email });
+}
+exports.inviteUserToIntegration = inviteUserToIntegration;
+async function getIntegrationEvents(integrationId) {
+    const { data: events } = await integrations_platform_client_1.default.getIntegrationEvents(integrationId);
+    return events;
+}
+exports.getIntegrationEvents = getIntegrationEvents;
+async function updateIntegration(integrationId, configuration) {
+    const current = await integrations_platform_client_1.default.getIntegrationById(integrationId);
+    // Create authorizations.
+    const authorizationsToCreate = configuration.authorizations
+        ?.filter(configAuthorization => !current.authorizations.some(platformAuthorization => platformAuthorization.name === configAuthorization.name))
+        ?.map(configAuthorization => {
+        // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+        // @ts-ignore schema mismatch between the CLI and the platform (but fine at runtime).
+        const authorizationToCreate = {
+            ...configAuthorization,
+            archived: false,
+        };
+        return authorizationToCreate;
+    }) ?? [];
+    // Archive authorizations.
+    const authorizationsToArchive = current.authorizations
+        .filter(platformAuthorization => !configuration.authorizations?.some(configAuthorization => platformAuthorization.name === configAuthorization.name))
+        .map(platformAuthorization => {
+        const authorizationToArchive = {
+            ...platformAuthorization,
+            archived: true,
+        };
+        return authorizationToArchive;
+    });
+    // Update authorizations.
+    const authorizationsToUpdate = current.authorizations
+        .filter(platformAuthorization => configuration.authorizations?.some(configAuthorization => platformAuthorization.name === configAuthorization.name))
+        .map(platformAuthorization => {
+        const configAuthorization = configuration.authorizations?.find(authorization => platformAuthorization.name === authorization.name);
+        // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+        // @ts-ignore schema mismatch between the CLI and the platform (but fine at runtime).
+        const authorizationToUpdate = {
+            id: platformAuthorization.id,
+            ...(configAuthorization ?? {}),
+            archived: false,
+        };
+        return authorizationToUpdate;
+    });
+    return await integrations_platform_client_1.default.updateIntegration(current.id, {
+        baseUrl: configuration.baseUrl,
+        graphRelativeUrl: configuration.graphRelativeUrl ?? '/',
+        credentialAccountRelativeUrl: configuration.credentialAccountRelativeUrl ?? '/me',
+        webhookParsingRelativeUrl: configuration.webhookParsingRelativeUrl,
+        webhookSubscriptionsRelativeUrl: configuration.webhookSubscriptionsRelativeUrl,
+        webhookAcknowledgeRelativeUrl: configuration.webhookAcknowledgeRelativeUrl,
+        authorizations: authorizationsToCreate.concat(authorizationsToArchive).concat(authorizationsToUpdate),
+        secrets: configuration.secrets,
+        ui: configuration.ui,
+    });
+}
+exports.updateIntegration = updateIntegration;

package/dist/src/services/oauth2Helper.d.ts

@@ -0,0 +1,3 @@
+import { Oauth2Response, Oauth2Payload } from '../oauth2Helper/types';
+export declare function performOAuth2Flow(applicationCredentials: Oauth2Payload): Promise<Oauth2Response>;
+export declare function updateToken(applicationCredentials: Oauth2Payload): Promise<Oauth2Response>;

package/dist/src/services/oauth2Helper.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.updateToken = exports.performOAuth2Flow = void 0;
+const tslib_1 = require("tslib");
+const oauth2Helper_1 = tslib_1.__importDefault(require("../oauth2Helper/oauth2Helper"));
+const errors_1 = require("../errors");
+async function performOAuth2Flow(applicationCredentials) {
+    const oauthHelper = new oauth2Helper_1.default(applicationCredentials);
+    const serverUrl = oauthHelper.startServer();
+    const healthCheck = await fetch(`${serverUrl}/health`);
+    if (healthCheck.status !== 200) {
+        throw new Error('OAuthServer did not start');
+    }
+    await fetch(`${serverUrl}/credentials/new/oauth2/authorize`);
+    await oauthHelper.callbackIsDone();
+    const response = await fetch(`${serverUrl}/credentials/new/oauth2/token`);
+    if (response.status !== 200) {
+        throw new errors_1.FailedToRetrieveAccessTokenError(await response.text());
+    }
+    const credentials = await response.json();
+    oauthHelper.stopServer();
+    if (!credentials.accessToken) {
+        throw new errors_1.FailedToRetrieveAccessTokenError('Access token was not returned');
+    }
+    return credentials;
+}
+exports.performOAuth2Flow = performOAuth2Flow;
+/* istanbul ignore next */
+// No point to test this function as it is just a wrapper around OAuth2Helper
+async function updateToken(applicationCredentials) {
+    const oauthHelper = new oauth2Helper_1.default(applicationCredentials);
+    return oauthHelper.updateToken();
+}
+exports.updateToken = updateToken;

package/dist/test/commands/activity.test.d.ts

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

package/dist/test/commands/activity.test.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const test_1 = require("@oclif/test");
+const sinon_1 = tslib_1.__importDefault(require("sinon"));
+const IntegrationsPlatform = tslib_1.__importStar(require("../../src/services/integrationsPlatform"));
+const IntegrationResource = tslib_1.__importStar(require("../../src/resources/integrations"));
+const IntegrationConfiguration = tslib_1.__importStar(require("../../src/resources/configuration"));
+describe('activity', () => {
+    beforeEach(() => {
+        sinon_1.default.stub(IntegrationResource, 'validateIsIntegrationDirectory');
+        sinon_1.default.stub(IntegrationsPlatform, 'setEnvironment');
+        sinon_1.default.stub(IntegrationsPlatform, 'setApiKey');
+        sinon_1.default
+            .stub(IntegrationsPlatform, 'getIntegrationByName')
+            .resolves({ name: 'integrationName', id: 'foo' });
+        sinon_1.default.stub(IntegrationsPlatform, 'getIntegrationEvents').resolves([
+            { date: '1', text: 'This is a foo', title: 'foo', tags: ['a', 'b', 'c'] },
+            { date: '2', text: 'This is a bar', title: 'bar', tags: ['x', 'y', 'z'] },
+        ]);
+        sinon_1.default.stub(IntegrationConfiguration, 'getConfiguration').resolves({ name: 'integrationName' });
+    });
+    afterEach(() => {
+        sinon_1.default.restore();
+    });
+    test_1.test
+        .stdout()
+        .command(['activity'])
+        .it('displays activity', ctx => {
+        (0, test_1.expect)(ctx.stdout).to.contains('foo');
+        (0, test_1.expect)(ctx.stdout).to.contains('bar');
+    });
+    test_1.test
+        .stdout()
+        .command(['activity', '--number', '1'])
+        .it('displays only specified number of activity entries', ctx => {
+        (0, test_1.expect)(ctx.stdout).to.contains('foo');
+        (0, test_1.expect)(ctx.stdout).to.not.contains('bar');
+    });
+    test_1.test
+        .stdout()
+        .command(['activity', '--environment', 'staging'])
+        .it('displays activity - staging', ctx => {
+        (0, test_1.expect)(ctx.stdout).to.contains('foo');
+        (0, test_1.expect)(ctx.stdout).to.contains('bar');
+    });
+    test_1.test
+        .stdout()
+        .command(['activity', '--environment', 'local'])
+        .it('displays activity - local', ctx => {
+        (0, test_1.expect)(ctx.stdout).to.contains('foo');
+        (0, test_1.expect)(ctx.stdout).to.contains('bar');
+    });
+    test_1.test
+        .stdout()
+        .stub(IntegrationsPlatform, 'getIntegrationByName', () => undefined)
+        .command(['activity'])
+        .catch(error => {
+        (0, test_1.expect)(error.message).to.equal('EEXIT: -1');
+    })
+        .it('handles unpublished integration');
+});

package/dist/test/commands/dev.test.d.ts

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

package/dist/test/commands/dev.test.js

@@ -0,0 +1,139 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const test_1 = require("@oclif/test");
+const sinon_1 = tslib_1.__importDefault(require("sinon"));
+const child_process_1 = tslib_1.__importDefault(require("child_process"));
+const IntegrationDebugger = tslib_1.__importStar(require("@unito/integration-debugger/dist/src/resources/configuration"));
+const IntegrationsPlatform = tslib_1.__importStar(require("../../src/services/integrationsPlatform"));
+const IntegrationsPlatformResource = tslib_1.__importStar(require("../../src/resources/integrationsPlatform"));
+const ConfigurationResource = tslib_1.__importStar(require("../../src/resources/configuration"));
+const IntegrationResource = tslib_1.__importStar(require("../../src/resources/integrations"));
+describe('Dev', () => {
+    const debuggerConfiguration = {
+        ...IntegrationDebugger.getDefaultConfiguration(),
+        credentialPayload: {
+            key: 'value',
+            encryptedToken: `decrypted-me`,
+        },
+    };
+    const cliConfiguration = {
+        name: 'a',
+        baseUrl: 'b',
+        testAccounts: {
+            development: {
+                key: 'value',
+                encryptedToken: `${ConfigurationResource.ENCRYPTION_PREFIX}decrypt-me`,
+            },
+        },
+    };
+    let execSyncStub;
+    let spawnStub;
+    beforeEach(() => {
+        process.env.NODE_MODULES_FOLDER = '/path/to/node_modules';
+        sinon_1.default.stub(IntegrationsPlatform, 'decryptData').resolves({ decryptedData: 'decrypted-me' });
+        sinon_1.default.stub(IntegrationResource, 'validateIsIntegrationDirectory');
+        sinon_1.default.stub(IntegrationsPlatformResource, 'validateAuthenticated');
+        sinon_1.default.stub(ConfigurationResource, 'getConfiguration').resolves(cliConfiguration);
+        sinon_1.default.stub(IntegrationDebugger, 'readConfiguration').resolves(debuggerConfiguration);
+        execSyncStub = sinon_1.default.stub(child_process_1.default, 'execSync');
+        spawnStub = sinon_1.default.stub(child_process_1.default, 'spawn').returns({ on: (..._args) => { } });
+    });
+    afterEach(() => {
+        process.env.NODE_MODULES_FOLDER = undefined;
+        sinon_1.default.restore();
+    });
+    test_1.test
+        .stdout()
+        .command(['dev'])
+        .it('launches the debugger', () => {
+        (0, test_1.expect)(execSyncStub.getCall(0).args.at(0).split(' ').slice(0, 2)).to.deep.equal(['npm', 'install']);
+        (0, test_1.expect)(spawnStub.getCall(0).args.at(0).split(' ').slice(0, 2)).to.deep.equal(['node']);
+    });
+    test_1.test
+        .stdout()
+        .command(['dev'])
+        .it('decrypts credentials', () => {
+        (0, test_1.expect)(spawnStub.getCall(0).args.at(1)).to.include('--credential-payload={"key":"value","encryptedToken":"decrypted-me"}');
+    });
+    test_1.test
+        .stdout()
+        .stub(IntegrationResource, 'validateIsIntegrationDirectory', () => {
+        throw new Error('boom!');
+    })
+        .command(['dev'])
+        .catch(ctx => {
+        (0, test_1.expect)(ctx.message).to.equal('boom!');
+    })
+        .it('handle exception');
+    test_1.test
+        .stdout()
+        .command(['dev', '--verbose'])
+        .it('verbose mode', () => {
+        (0, test_1.expect)(spawnStub.getCall(0).args.at(1)).to.include('--verbose');
+    });
+    test_1.test
+        .stdout()
+        .command(['dev', '--crawlMode=sample'])
+        .it('crawlMode - sample', () => {
+        (0, test_1.expect)(spawnStub.getCall(0).args.at(1)).to.include('--operation-collection-items-per-page=10');
+        (0, test_1.expect)(spawnStub.getCall(0).args.at(1)).to.include('--operation-collection-follow-next-pages=false');
+    });
+    test_1.test
+        .stdout()
+        .command(['dev', '--crawlMode=single'])
+        .it('crawlMode - single', () => {
+        (0, test_1.expect)(spawnStub.getCall(0).args.at(1)).to.include('--operation-collection-items-per-page=1');
+        (0, test_1.expect)(spawnStub.getCall(0).args.at(1)).to.include('--operation-collection-follow-next-pages=false');
+    });
+    test_1.test
+        .stdout()
+        .command(['dev', '--checks', 'foo,bar'])
+        .it('checks', () => {
+        (0, test_1.expect)(spawnStub.getCall(0).args.at(1)).to.include('--checks=foo,bar');
+    });
+    test_1.test
+        .stdout()
+        .stub(ConfigurationResource, 'getConfiguration', () => ({ ...cliConfiguration, graphRelativeUrl: 'foo' }))
+        .command(['dev'])
+        .it('overrides --graph-relative-url', () => {
+        (0, test_1.expect)(spawnStub.getCall(0).args.at(1)).to.include('--graph-relative-url=foo');
+    });
+    test_1.test
+        .stdout()
+        .stub(ConfigurationResource, 'getConfiguration', () => ({
+        ...cliConfiguration,
+        credentialAccountRelativeUrl: 'foo',
+    }))
+        .command(['dev'])
+        .it('overrides --credential-account-relative-url', () => {
+        (0, test_1.expect)(spawnStub.getCall(0).args.at(1)).to.include('--credential-account-relative-url=foo');
+    });
+    test_1.test
+        .stdout()
+        .stub(ConfigurationResource, 'getConfiguration', () => ({ ...cliConfiguration, webhookParsingRelativeUrl: 'foo' }))
+        .command(['dev'])
+        .it('overrides --webhook-parsing-relative-url', () => {
+        (0, test_1.expect)(spawnStub.getCall(0).args.at(1)).to.include('--webhook-parsing-relative-url=foo');
+    });
+    test_1.test
+        .stdout()
+        .stub(ConfigurationResource, 'getConfiguration', () => ({
+        ...cliConfiguration,
+        webhookSubscriptionsRelativeUrl: 'foo',
+    }))
+        .command(['dev'])
+        .it('overrides --webhook-subscriptions-relative-url', () => {
+        (0, test_1.expect)(spawnStub.getCall(0).args.at(1)).to.include('--webhook-subscriptions-relative-url=foo');
+    });
+    test_1.test
+        .stdout()
+        .stub(ConfigurationResource, 'getConfiguration', () => ({
+        ...cliConfiguration,
+        webhookAcknowledgeRelativeUrl: 'bar',
+    }))
+        .command(['dev'])
+        .it('overrides --webhook-acknowledge-relative-url', () => {
+        (0, test_1.expect)(spawnStub.getCall(0).args.at(1)).to.include('--webhook-acknowledge-relative-url=bar');
+    });
+});

package/dist/test/commands/encrypt.test.d.ts

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

package/dist/test/commands/encrypt.test.js

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const test_1 = require("@oclif/test");
+const sinon_1 = tslib_1.__importDefault(require("sinon"));
+const GlobalConfiguration = tslib_1.__importStar(require("../../src/resources/globalConfiguration"));
+const IntegrationsPlatform = tslib_1.__importStar(require("../../src/services/integrationsPlatform"));
+const IntegrationResource = tslib_1.__importStar(require("../../src/resources/integrations"));
+const IntegrationConfiguration = tslib_1.__importStar(require("../../src/resources/configuration"));
+const inquirer_1 = tslib_1.__importDefault(require("inquirer"));
+describe('encrypt', () => {
+    beforeEach(() => {
+        sinon_1.default.stub(IntegrationResource, 'validateIsIntegrationDirectory');
+        sinon_1.default.stub(IntegrationsPlatform, 'setEnvironment');
+        sinon_1.default.stub(IntegrationsPlatform, 'setApiKey');
+        sinon_1.default.stub(IntegrationsPlatform, 'encryptData').resolves({ encryptedData: 'mySuperEncryptedData' });
+        sinon_1.default.stub(inquirer_1.default, 'prompt').resolves({ data: 'mySuperData' });
+        sinon_1.default.stub(IntegrationConfiguration, 'getConfiguration').resolves({ name: 'integrationName' });
+        sinon_1.default.stub(IntegrationsPlatform, 'getProfile').resolves({
+            id: 1,
+            createdAt: '',
+            updatedAt: '',
+            archivedAt: null,
+            email: 'foo@bar.com',
+            defaultUnitoOrganizationId: null,
+            role: 'developer',
+            apiKey: 'foo',
+            termsAcceptedAt: null,
+        });
+    });
+    afterEach(() => {
+        sinon_1.default.restore();
+    });
+    test_1.test
+        .stdout()
+        .stub(GlobalConfiguration, 'read', () => ({ apiKey: 'foo' }))
+        .command(['encrypt'])
+        .it('encrypts data - default', ctx => {
+        (0, test_1.expect)(ctx.stdout).to.contains('Encrypted Data:');
+    });
+    test_1.test
+        .stdout()
+        .stub(GlobalConfiguration, 'read', () => ({ apiKeyLocal: 'foo' }))
+        .command(['encrypt', '--environment=local'])
+        .it('encrypts data - local', ctx => {
+        (0, test_1.expect)(ctx.stdout).to.contains('Encrypted Data:');
+    });
+    test_1.test
+        .stdout()
+        .stub(GlobalConfiguration, 'read', () => ({ apiKeyStaging: 'foo' }))
+        .command(['encrypt', '--environment', 'staging'])
+        .it('encrypts data - staging', ctx => {
+        (0, test_1.expect)(ctx.stdout).to.contains('Encrypted Data:');
+    });
+    test_1.test
+        .stdout()
+        .stub(GlobalConfiguration, 'read', () => ({}))
+        .command(['encrypt'])
+        .exit(-1)
+        .it('missing api key', ctx => {
+        (0, test_1.expect)(ctx.stdout).to.contain('Your API key is not set!\nMake sure to run the login command first');
+    });
+    test_1.test
+        .stdout()
+        .stub(GlobalConfiguration, 'read', () => {
+        throw new Error('boom!');
+    })
+        .command(['encrypt'])
+        .catch(ctx => {
+        (0, test_1.expect)(ctx.message).to.equal('boom!');
+    })
+        .it('handles configuration error');
+});

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

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

package/dist/test/commands/init.test.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const test_1 = require("@oclif/test");
+const inquirer_1 = tslib_1.__importDefault(require("inquirer"));
+const sinon = tslib_1.__importStar(require("sinon"));
+const integrationGenerator_1 = require("../../integrationGenerator");
+const Configuration = tslib_1.__importStar(require("../../src/resources/configuration"));
+describe('init', () => {
+    beforeEach(() => {
+        // eslint-disable-next-line
+        sinon.stub(Configuration, 'getConfiguration').returns({});
+        sinon.stub(Configuration, 'writeConfiguration');
+    });
+    afterEach(() => {
+        sinon.restore();
+    });
+    test_1.test
+        .stub(inquirer_1.default, 'prompt', () => Promise.resolve({ name: 'myIntegration' }))
+        .stub(integrationGenerator_1.Resources.Integration, 'generateIntegrationSkeleton', () => '/my/super/path/myIntegration')
+        .stub(process, 'chdir', () => '')
+        .stdout()
+        .command(['init'])
+        .it('runs init', ctx => {
+        (0, test_1.expect)(ctx.stdout).to.contain('Your integration is available at');
+    });
+    test_1.test
+        .stub(integrationGenerator_1.Resources.Integration, 'generateIntegrationSkeleton', () => '/my/super/path/myIntegration')
+        .stub(process, 'chdir', () => '')
+        .stdout()
+        .command(['init', '-n', 'myIntegration'])
+        .it('runs init with flag', ctx => {
+        (0, test_1.expect)(ctx.stdout).to.contain('Your integration is available at');
+    });
+    test_1.test
+        .stub(integrationGenerator_1.Resources.Integration, 'generateIntegrationSkeleton', () => {
+        throw new Error('boom!');
+    })
+        .stdout()
+        .command(['init', '-n', 'myIntegration'])
+        .catch(ctx => {
+        (0, test_1.expect)(ctx.message).to.equal('boom!');
+    })
+        .it('handle exception');
+});

package/dist/test/commands/invite.test.d.ts

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