codefresh 0.78.2

package/lib/interface/cli/commands/step/get.cmd.js

@@ -0,0 +1,131 @@
+const debug = require('debug')('codefresh:cli:get:step');
+const Command = require('../../Command');
+const CFError = require('cf-errors');
+const _ = require('lodash');
+const DEFAULTS = require('../../defaults');
+const { prepareKeyValueFromCLIEnvOption } = require('../../helpers/general');
+const Output = require('../../../../output/Output');
+const { sdk } = require('../../../../logic');
+const StepType = require('../../../../logic/entities/StepType');
+const StepTypeVersion = require('../../../../logic/entities/StepTypeVersion');
+
+const getRoot = require('../root/get.cmd');
+
+
+const command = new Command({
+    command: 'step-types [id..]',
+    aliases: ['step-type'],
+    parent: getRoot,
+    description: 'Get a specific step or an array of steps',
+    webDocs: {
+        category: 'Steps',
+        title: 'Get Step',
+    },
+    builder: (yargs) => {
+        return yargs
+            .positional('id', {
+                describe: 'Step name/id',
+            })
+            .option('name', {
+                describe: 'Filter by name pattern',
+            })
+            .option('free-text', {
+                describe: 'Filter by multiple criteria: name, description, tags',
+                alias: 'text',
+            })
+            .option('tag', {
+                describe: 'Filter by a tag',
+                alias: 't',
+                default: [],
+            })
+            .option('category', {
+                describe: 'Filter by category',
+                alias: 'c',
+                default: [],
+            })
+            .option('stage', {
+                describe: 'Filter by stage',
+                choices: ['graduated', 'incubating'],
+            })
+            .option('official', {
+                describe: 'Filter only official steps',
+                boolean: true,
+            })
+            .option('public', {
+                describe: 'Filter only public steps',
+                boolean: true,
+            })
+            .option('private', {
+                describe: 'Filter only private steps',
+                boolean: true,
+            })
+            .option('limit', {
+                describe: 'Limit amount of returned results',
+                default: DEFAULTS.GET_LIMIT_RESULTS,
+            })
+            .option('versions', {
+                describe: 'Get only typed-step versions',
+                default: false,
+                boolean: true,
+            })
+            .option('page', {
+                describe: 'Paginated page',
+                default: DEFAULTS.GET_PAGINATED_PAGE,
+            });
+    },
+    handler: async (argv) => {
+        const { id: ids, name } = argv;
+        const limit = argv.limit;
+        const offset = (argv.page - 1) * limit;
+        const isPublic = argv.public;
+        const isPrivate = argv.private;
+        const category = argv.category;
+        const stage = argv.stage;
+        const official = argv.official;
+        const tag = argv.tag;
+        const freeText = argv['free-text'];
+        const onlyVersions = argv.versions;
+
+        if (onlyVersions) {
+            const res = await sdk.steps.getStepVersions({ name: ids[0] });
+            Output.print(_.map(res, StepTypeVersion.fromResponse));
+        } else if (!_.isEmpty(ids)) {
+            const steps = [];
+            for (const id of ids) {
+                try {
+                    const currStep = await sdk.steps.get({ name: id });
+                    steps.push(StepType.fromResponse(currStep));
+                } catch (err) {
+                    if (steps.length) {
+                        Output.print(steps);
+                    }
+
+                    debug(err.toString());
+                    const message = err.toString().includes('not find') ? `Step-type '${id}' was not found.` : 'Error occurred';
+                    throw new CFError({
+                        cause: err,
+                        message,
+                    });
+                }
+            }
+            Output.print(steps);
+        } else {
+            const steps = await sdk.steps.list({
+                limit,
+                offset,
+                id: name,
+                public: isPublic,
+                private: isPrivate,
+                category,
+                stage,
+                official,
+                tag,
+                freeText,
+            });
+            Output.print(_.map(_.get(steps, 'docs'), StepType.fromResponse));
+        }
+    },
+});
+
+module.exports = command;
+

package/lib/interface/cli/commands/step/get.completion.js

@@ -0,0 +1,14 @@
+const _ = require('lodash');
+const steps = () => require('../../../../logic').sdk.steps;
+const StepType = require('../../../../logic/entities/StepType');
+const { authContextWrapper } = require('../../completion/helpers');
+
+const positionalHandler = async ({word, argv}) => {
+    const stps = await steps().list({ limit: 25, offset: 0 });
+    return _.map(_.get(stps, 'docs'), StepType.fromResponse).map(p => p.name);
+};
+
+module.exports = {
+    positionalHandler: authContextWrapper(positionalHandler),
+};
+

package/lib/interface/cli/commands/step/step.sdk.spec.js

@@ -0,0 +1,67 @@
+const getCmd = require('./get.cmd').toCommand();
+const deleteCmd = require('./delete.cmd').toCommand();
+const { positionalHandler } = require('./get.completion');
+
+jest.mock('../../helpers/validation'); // eslint-disable-line
+
+jest.mock('../../completion/helpers', () => { // eslint-disable-line
+    return {
+        authContextWrapper: func => func,
+    };
+});
+
+jest.mock('../../../../logic/entities/StepType', () => { // eslint-disable-line
+    return {
+        fromResponse: res => res,
+    };
+});
+
+const request = require('requestretry');
+
+const DEFAULT_RESPONSE = request.__defaultResponse();
+
+describe('step', () => {
+    beforeEach(async () => {
+        request.__reset();
+        request.mockClear();
+        await configureSdk(); // eslint-disable-line
+    });
+
+    describe('commands', () => {
+        describe('get', () => {
+            it('should handle getting given id', async () => {
+                const argv = { id: ['some id'] };
+                await getCmd.handler(argv);
+                await verifyResponsesReturned([DEFAULT_RESPONSE]); // eslint-disable-line
+            });
+
+            it('should handle getting all', async () => {
+                const argv = {};
+                const response = { statusCode: 200, body: { docs: [DEFAULT_RESPONSE.body] } };
+                request.__setResponse(response);
+                await getCmd.handler(argv);
+                await verifyResponsesReturned([response]); // eslint-disable-line
+            });
+        });
+
+        // decided to follow unit tests modularity concept
+        describe('delete', () => {
+            it('should handle deletion given name', async () => {
+                const argv = { name: 'some name' };
+                await deleteCmd.handler(argv);
+                await verifyResponsesReturned([DEFAULT_RESPONSE]); // eslint-disable-line
+            });
+        });
+    });
+
+    describe('completions', () => {
+        describe('get', () => {
+            it('should handle getting completion', async () => {
+                const response = { statusCode: 200, body: { docs: [{ name: 'some pip' }] } };
+                request.__setResponse(response);
+                await positionalHandler({});
+                await verifyResponsesReturned([response]); // eslint-disable-line
+            });
+        });
+    });
+});

package/lib/interface/cli/commands/systemRuntimeEnvironments/apply.cmd.js

@@ -0,0 +1,69 @@
+const Command = require('../../Command');
+const CFError = require('cf-errors');
+const _ = require('lodash');
+const applyRoot = require('../root/apply.cmd');
+const { crudFilenameOption } = require('../../helpers/general');
+const sysRe = require('../../helpers/sys-re');
+
+
+const command = new Command({
+    command: 'system-runtime-environments [name]',
+    aliases: ['sys-re', 'system-runtime-environment'],
+    parent: applyRoot,
+    description: 'apply changes to runtime-environments resource',
+    onPremCommand: true,
+    usage: 'Use apply to patch an existing context',
+    webDocs: {
+        title: 'Apply System Runtime-Environments',
+        weight: 90,
+    },
+    builder: (yargs) => {
+        crudFilenameOption(yargs);
+        return yargs
+            .positional('name', {
+                describe: 'Runtime environments name',
+            })
+            .option('default', {
+                describe: 'Set the chosen runtime environment as default',
+            })
+            .option('extends', {
+                describe: 'Set the runtime environments you want to extends from',
+                type: Array,
+                default: [],
+            })
+            .option('plan', {
+                describe: 'Set the plan of system plan runtime environment',
+            })
+            .option('description', {
+                alias: 'd',
+                describe: 'Description of the new runtime environment',
+            })
+            .example('codefresh patch system-runtime-environments -f ./re.yml', 'Apply changes to a system runtime environment');
+    },
+    handler: async (argv) => {
+        const options = {};
+        const body = argv.filename || {};
+        options.name = _.get(body, 'metadata.name') || argv.name;
+        options.plan = _.get(body, 'plan') || argv.plan;
+        options.extend = _.get(body, 'extends') || argv.extends;
+        options.description = _.get(body, 'description') || argv.description;
+        if (!options.name) {
+            throw new CFError('Missing name in metadata');
+        }
+        if (argv.default) {
+            try {
+                await sysRe.setDefault(options);
+                console.log(`Runtime-Environment: '${options.name}' set as a default.`);
+            } catch (err) {
+                throw (err);
+            }
+        } else {
+            await sysRe.update(options, body);
+            console.log(`Runtime-Environment: '${options.name}' patched.`);
+        }
+    },
+});
+
+
+module.exports = command;
+

package/lib/interface/cli/commands/systemRuntimeEnvironments/delete.cmd.js

@@ -0,0 +1,44 @@
+const Command = require('../../Command');
+const deleteRoot = require('../root/delete.cmd');
+const sysRe = require('../../helpers/sys-re');
+
+
+const command = new Command({
+    command: 'system-runtime-environments [name]',
+    aliases: ['sys-re','system-runtime-environment'],
+    parent: deleteRoot,
+    description: 'Delete a runtime-environment',
+    onPremCommand: true,
+    webDocs: {
+        title: 'Delete System Runtime-Environments',
+    },
+    builder: (yargs) => {
+        return yargs
+            .positional('name', {
+                describe: 'Runtime environment name',
+            })
+            .option('plan', {
+                describe: 'Runtime environment plan',
+            })
+            .option('force', {
+                describe: 'Delete runtime environment in force mode',
+                type: 'boolean',
+            });
+    },
+    handler: async (argv) => {
+        const { name, plan, force } = argv;
+        try {
+            await sysRe.delete({ name, plan, force });
+            console.log(`Runtime-Environment '${name}' deleted.`);
+        } catch (error) {
+            console.log(`Cannot delete Runtime-Environment: ${name}`);
+            throw error;
+        }
+
+
+    },
+});
+
+
+module.exports = command;
+

package/lib/interface/cli/commands/systemRuntimeEnvironments/diff.cmd.js

@@ -0,0 +1,74 @@
+const Command = require('../../Command');
+const jsdiff = require('diff');
+const sysRe = require('../../helpers/sys-re');
+require('colors');
+
+const diffRoot = require('../root/diff.cmd');
+
+
+const command = new Command({
+    command: 'system-runtime-environments [first-re-name] [first-re-version] [second-re-name] [second-re-version]',
+    aliases: ['sys-re','system-runtime-environment'],
+    parent: diffRoot,
+    description: 'Show diff between two runtime environments configuration',
+    onPremCommand: true,
+    webDocs: {
+        title: 'Diff System Runtime-Environments',
+    },
+    builder: (yargs) => {
+        return yargs
+            .option('first-name', {
+                describe: 'First runtime environment name',
+            })
+            .option('first-version', {
+                describe: 'First runtime environment version',
+            })
+            .option('first-plan', {
+                describe: 'Plan of the first runtime environment (relevant only when it is a system plan runtime environment)',
+            })
+            .option('second-name', {
+                describe: 'Second runtime environment name',
+            })
+            .option('second-version', {
+                describe: 'Second runtime environment version',
+            })
+            .option('second-plan', {
+                describe: 'Plan of the second runtime environment (relevant only when it is a system plan runtime environment)',
+            });
+    },
+    handler: async (argv) => {
+        const firstEnvName = argv['first-name'];
+        const firstEnvVersion = argv['first-version'];
+        const secondEnvName = argv['second-name'];
+        const secondEnvVersion = argv['second-version'];
+        const firstPlan = argv['first-plan'];
+        const secondPlan = argv['second-plan'];
+
+        const firstEnv = await sysRe.get({
+            name: firstEnvName,
+            version: firstEnvVersion,
+            plan: firstPlan,
+        });
+
+        const secondEnv = await sysRe.get({
+            name: secondEnvName,
+            version: secondEnvVersion,
+            plan: secondPlan,
+        });
+
+        const firstEnvJson = JSON.stringify(firstEnv, null, '\t');
+        const secondEnvJson = JSON.stringify(secondEnv, null, '\t');
+
+        const diff = jsdiff.diffJson(firstEnvJson, secondEnvJson);
+
+        diff.forEach((part) => {
+            const color = part.added ? 'green' : part.removed ? 'red' : 'white';
+            process.stderr.write(part.value[color]);
+        });
+
+        console.log();
+    },
+});
+
+module.exports = command;
+

package/lib/interface/cli/commands/systemRuntimeEnvironments/get.cmd.js

@@ -0,0 +1,103 @@
+const Command = require('../../Command');
+const _ = require('lodash');
+const RuntimeEnvironments = require('../../../../logic/entities/RuntimeEnvironments');
+const Output = require('../../../../output/Output');
+const DEFAULTS = require('../../defaults');
+const sysRe = require('../../helpers/sys-re');
+
+const getRoot = require('../root/get.cmd');
+
+
+const command = new Command({
+    command: 'system-runtime-environments [name]',
+    aliases: ['sys-re', 'system-runtime-environment'],
+    parent: getRoot,
+    description: 'Get a runtime environments configuration',
+    onPremCommand: true,
+    webDocs: {
+        title: 'Get System Runtime-Environments',
+    },
+    builder: (yargs) => {
+        return yargs
+            .positional('name', {
+                describe: 'Runtime environments name',
+            })
+            .option('version', {
+                describe: 'Runtime environments version',
+            })
+            .option('history', {
+                describe: 'Return all the history of the specific runtime environments',
+                type: 'boolean',
+            })
+            .option('successors', {
+                describe: 'Return all the successors of specific runtime environment',
+                type: 'boolean',
+                alias: 's',
+            })
+            .option('limit', {
+                describe: 'Limit amount of returned results',
+                default: DEFAULTS.GET_LIMIT_RESULTS,
+            })
+            .option('page', {
+                describe: 'Paginated page',
+                default: DEFAULTS.GET_PAGINATED_PAGE,
+            })
+            .option('extend', {
+                describe: 'Return an extend runtime environment ',
+                type: 'boolean',
+                default: false,
+            })
+            .option('plan', {
+                describe: 'Set the plan of system plan runtime environment',
+            })
+            .option('account', {
+                describe: 'id of the account we want to view his runtime environments',
+            })
+            .option('accountIds', {
+                describe: 'array of accounts ids to view theirs runtime environments',
+                array: true,
+                default: [],
+            });
+    },
+    handler: async (argv) => {
+        const { name, version, history, extend, limit, page, plan, successors, account, accountIds } = argv;
+        const offset = (page - 1) * limit;
+        if (history) {
+            const allHistory = await sysRe.get({
+                name,
+                history,
+                plan,
+            });
+            console.log(JSON.stringify(allHistory, null, '\t'));
+        } else if (successors) {
+            const allSuccessors = await sysRe.get({
+                name,
+                successors,
+                plan,
+            });
+            console.log(JSON.stringify(allSuccessors, null, '\t'));
+        } else if (name) {
+            const currRuntimeEnvironments = await sysRe.get({
+                name,
+                version,
+                extend,
+                plan,
+            });
+            Output.print(RuntimeEnvironments.fromResponse(currRuntimeEnvironments));
+        } else {
+            let re = await sysRe.list({
+                limit,
+                offset,
+                account,
+                accountIds: accountIds,
+            });
+            if (!_.isEmpty(accountIds)) {
+                re = _.flatten(_.map(re, ({ runtimeEnvironments }) => runtimeEnvironments));
+            }
+            Output.print(_.map(re, RuntimeEnvironments.fromResponse));
+        }
+    },
+});
+
+module.exports = command;
+

package/lib/interface/cli/commands/systemRuntimeEnvironments/systemRuntimeEnvironments.sdk.spec.js

@@ -0,0 +1,128 @@
+const getCmd = require('./get.cmd').toCommand();
+const applyCmd = require('./apply.cmd').toCommand();
+const diffCmd = require('./diff.cmd').toCommand();
+const deleteCmd = require('./delete.cmd').toCommand();
+
+jest.mock('../../../../logic/entities/RuntimeEnvironments');
+
+const request = require('requestretry');
+
+const DEFAULT_RESPONSE = request.__defaultResponse();
+
+describe('system runtime environment commands', () => {
+    beforeEach(async () => {
+        request.__reset();
+        request.mockClear();
+        await configureSdk(); // eslint-disable-line
+    });
+
+    describe('get', () => {
+        it('should handle getting all account for history', async () => {
+            const argv = { name: 'some name', plan: 'plan', history: true };
+            await getCmd.handler(argv);
+            await verifyResponsesReturned([DEFAULT_RESPONSE]); // eslint-disable-line
+        });
+
+        it('should handle getting all sys re for history', async () => {
+            const argv = { name: 'system/', plan: 'plan', history: true };
+            await getCmd.handler(argv);
+            await verifyResponsesReturned([DEFAULT_RESPONSE]); // eslint-disable-line
+        });
+
+        it('should handle getting by name for account', async () => {
+            const argv = { name: 'some name', plan: 'plan' };
+            await getCmd.handler(argv);
+            await verifyResponsesReturned([DEFAULT_RESPONSE]); // eslint-disable-line
+        });
+
+        it('should handle getting by name sys re', async () => {
+            const argv = { name: 'system/', plan: 'plan' };
+            await getCmd.handler(argv);
+            await verifyResponsesReturned([DEFAULT_RESPONSE]); // eslint-disable-line
+        });
+
+        it('should handle getting all account', async () => {
+            const argv = { account: true };
+            const response = {
+                statusCode: 200,
+                body: [DEFAULT_RESPONSE.body],
+            };
+            request.__setResponse(response);
+            await getCmd.handler(argv);
+            await verifyResponsesReturned([response]); // eslint-disable-line
+        });
+
+        it('should handle getting all sys re', async () => {
+            const argv = {};
+            const response = {
+                statusCode: 200,
+                body: [DEFAULT_RESPONSE.body],
+            };
+            request.__setResponse(response);
+            await getCmd.handler(argv);
+            await verifyResponsesReturned([response]); // eslint-disable-line
+        });
+    });
+
+    describe('apply', () => {
+        it('should handle setting default for account', async () => {
+            const argv = { name: 'some name', plan: 'plan', extends: ['parent'], default: true, account: true };
+            await applyCmd.handler(argv);
+            await verifyResponsesReturned([DEFAULT_RESPONSE]); // eslint-disable-line
+        });
+
+        it('should handle setting default sys re', async () => {
+            const argv = { name: 'system/', plan: 'plan', extends: ['parent'], default: true };
+            await applyCmd.handler(argv);
+            await verifyResponsesReturned([DEFAULT_RESPONSE]); // eslint-disable-line
+        });
+
+        it('should handle patching given name for account', async () => {
+            const argv = { name: 'some name', plan: 'plan', extends: ['parent']};
+            await applyCmd.handler(argv);
+            await verifyResponsesReturned([DEFAULT_RESPONSE]); // eslint-disable-line
+        });
+
+        it('should handle patching given name sys re', async () => {
+            const argv = { name: 'system/', plan: 'plan', extends: ['parent']};
+            await applyCmd.handler(argv);
+            await verifyResponsesReturned([DEFAULT_RESPONSE]); // eslint-disable-line
+        });
+    });
+
+    describe('delete', () => {
+        it('should handle deletion for account', async () => {
+            const argv = { name: 'some name', plan: 'plan' };
+            await deleteCmd.handler(argv);
+            await verifyResponsesReturned([DEFAULT_RESPONSE]); // eslint-disable-line
+        });
+
+        it('should handle deletion', async () => {
+            const argv = { name: 'system/' };
+            await deleteCmd.handler(argv);
+            await verifyResponsesReturned([DEFAULT_RESPONSE]); // eslint-disable-line
+        });
+    });
+
+    describe('diff', () => {
+        it('should handle diff given name for account', async () => {
+            const argv = {
+                'first-name': 'first name',
+                'second-name': 'second name',
+                'first-plan': 'first plan',
+                'second-plan': 'second plan',
+            };
+            await diffCmd.handler(argv);
+            await verifyResponsesReturned([DEFAULT_RESPONSE, DEFAULT_RESPONSE]); // eslint-disable-line
+        });
+
+        it('should handle diff given name sys re', async () => {
+            const argv = {
+                'first-name': 'system/',
+                'second-name': 'system/',
+            };
+            await diffCmd.handler(argv);
+            await verifyResponsesReturned([DEFAULT_RESPONSE, DEFAULT_RESPONSE]); // eslint-disable-line
+        });
+    });
+});

package/lib/interface/cli/commands/team/add.user.cmd.js

@@ -0,0 +1,39 @@
+const Command = require('../../Command');
+const applyRoot = require('../root/apply.cmd');
+const { sdk } = require('../../../../logic');
+
+
+const command = new Command({
+    command: 'teams',
+    aliases: ['team', 'tm'],
+    parent: applyRoot,
+    description: 'Assign user to a team',
+    usage: 'Use patch command and pass user id and team id  to assign user to a team',
+    webDocs: {
+        category: 'Teams',
+        title: 'Add user',
+    },
+    builder: (yargs) => {
+        return yargs
+            .option('team-id', {
+                describe: 'Id team in which to add a user',
+                alias: 't',
+                required: true,
+            })
+            .option('user-id', {
+                describe: 'Id of a user to add him in team',
+                alias: 'u',
+                required: true,
+            })
+            .example('codefresh patch tm -u [userID] -t [teamID]', 'Assign user to team');
+    },
+    handler: async (argv) => {
+        const { teamId, userId } = argv;
+        await sdk.teams.addUser({ teamId, userId });
+        console.log(`User: ${userId} was assigned to team: ${teamId}`);
+    },
+});
+
+
+module.exports = command;
+