codefresh 0.78.2

package/lib/interface/cli/commands/trigger/event/delete.cmd.js

@@ -0,0 +1,34 @@
+require('debug')('codefresh:cli:delete:trigger-event');
+
+const Command = require('../../../Command');
+const deleteRoot = require('../../root/delete.cmd');
+const { sdk } = require('../../../../../logic');
+
+const command = new Command({
+    command: 'trigger-event [event-uri]',
+    aliases: ['te'],
+    parent: deleteRoot,
+    description: 'Delete `trigger-event`',
+    webDocs: {
+        category: 'Triggers',
+        title: 'Delete Trigger Event',
+    },
+    builder: (yargs) => {
+        yargs
+            .positional('event-uri', {
+                describe: 'trigger-event URI',
+            })
+            .option('context', {
+                describe: 'context with credentials required to setup event on remote system',
+            })
+            .example('codefresh delete trigger-event --context dockerhub registry:dockerhub:codefresh:fortune:push', 'Delete registry/dockerhub trigger-event');
+    },
+    handler: async (argv) => {
+        const { 'event-uri': event, context } = argv;
+        await sdk.triggers.events.delete({ event, context });
+        console.log(`Trigger event: ${argv['event-uri']} was successfully deleted.`);
+    },
+});
+
+module.exports = command;
+

package/lib/interface/cli/commands/trigger/event/get.cmd.js

@@ -0,0 +1,59 @@
+require('debug')('codefresh:cli:get:trigger-event');
+const _ = require('lodash');
+const Command = require('../../../Command');
+const Output = require('../../../../../output/Output');
+const getRoot = require('../../root/get.cmd');
+const { sdk } = require('../../../../../logic');
+const TriggerEvent = require('../../../../../logic/entities/TriggerEvent');
+
+
+const command = new Command({
+    command: 'trigger-events [event-uri]',
+    aliases: ['trigger-event', 'te'],
+    parent: getRoot,
+    description: 'Get `trigger-event`',
+    webDocs: {
+        category: 'Triggers',
+        title: 'Get Trigger Event',
+    },
+    builder: (yargs) => {
+        yargs
+            .positional('event-uri', {
+                describe: 'trigger-event URI)',
+            })
+            .option('type', {
+                describe: 'trigger-event type',
+                default: '',
+            })
+            .option('kind', {
+                describe: 'trigger-event kind',
+                default: '',
+            })
+            .option('filter', {
+                describe: 'trigger-event URI filter (regex)',
+                default: '',
+            })
+            .option('public', {
+                describe: 'get public trigger-event(s)',
+                default: true,
+                type: 'boolean',
+            })
+            .example('codefresh get trigger-event registry:dockerhub:codefresh:fortune:push', 'Get DockerHub codefresh/fortune push `trigger-event`')
+            .example('codefresh get trigger-event --type registry --kind dockerhub --filter *codefresh', 'Get all DockerHub codefresh/* push `trigger-events`');
+    },
+    handler: async (argv) => {
+        const uri = argv['event-uri'];
+        const { type, kind, filter, public: isPublic } = argv;
+        let events;
+        if (typeof uri === 'undefined') {
+            events = await sdk.triggers.events.list({ type, kind, filter, public: isPublic });
+        } else {
+            events = [await sdk.triggers.events.get({ event: uri })];
+        }
+
+        Output.print(_.map(events, TriggerEvent.fromResponse));
+    },
+});
+
+module.exports = command;
+

package/lib/interface/cli/commands/trigger/event/trigger-event.sdk.spec.js

@@ -0,0 +1,51 @@
+const getCmd = require('./get.cmd').toCommand();
+const deleteCmd = require('./delete.cmd').toCommand();
+const createCmd = require('./create.cmd').toCommand();
+
+jest.mock('../../../../../logic/entities/TriggerEvent');
+
+const request = require('requestretry');
+
+const DEFAULT_RESPONSE = request.__defaultResponse();
+
+describe('trigger event commands', () => {
+    beforeEach(async () => {
+        request.__reset();
+        request.mockClear();
+        await configureSdk(); // eslint-disable-line
+    });
+
+    describe('get', () => {
+        it('should handle getting by event uri', async () => {
+            const argv = { 'event-uri': 'uri', context: 'context' };
+            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', 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('create', () => {
+        it('should handle creation', async () => {
+            const argv = {};
+            await createCmd.handler(argv);
+            await verifyResponsesReturned([DEFAULT_RESPONSE]); // eslint-disable-line
+        });
+    });
+
+    describe('delete', () => {
+        it('should handle deletion given name', async () => {
+            const argv = { 'event-uri': 'uri', context: 'context' };
+            await deleteCmd.handler(argv);
+            await verifyResponsesReturned([DEFAULT_RESPONSE]); // eslint-disable-line
+        });
+    });
+});

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

@@ -0,0 +1,47 @@
+require('debug')('codefresh:cli:get:triggers');
+const _ = require('lodash');
+const Command = require('../../Command');
+const Output = require('../../../../output/Output');
+const getRoot = require('../root/get.cmd');
+const { sdk } = require('../../../../logic');
+const Trigger = require('../../../../logic/entities/Trigger');
+
+const command = new Command({
+    command: 'triggers',
+    aliases: ['trigger', 't'],
+    parent: getRoot,
+    description: 'Get triggers, optionally filtered by pipeline or event.',
+    usage: 'Only cron/registry triggers are supported (for git triggers use `codefresh get pip <pip-name> -o json`)',
+    webDocs: {
+        category: 'Triggers',
+        title: 'Get Triggers',
+    },
+    builder: (yargs) => {
+        yargs
+            .option('pipeline', {
+                describe: 'pipeline id',
+                alias: 'p',
+            })
+            .option('event-uri', {
+                describe: 'event URI',
+                alias: 'e',
+            });
+    },
+    handler: async (argv) => {
+        const { 'event-uri': event, pipeline } = argv;
+
+        let triggers;
+        if (pipeline) {
+            triggers = await sdk.triggers.getPipelineTriggers({ pipeline });
+        } else if (event) {
+            triggers = await sdk.triggers.getEventTriggers({ event });
+        } else {
+            triggers = await sdk.triggers.list();
+        }
+
+        Output.print(_.map(triggers, Trigger.fromResponse));
+    },
+});
+
+module.exports = command;
+

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

@@ -0,0 +1,73 @@
+const mockedDelete = jest.fn();
+const getCmd = require('./get.cmd').toCommand();
+const deleteCmd = require('./delete.cmd').toCommand();
+const createCmd = require('./create.cmd').toCommand();
+
+jest.mock('../../../../logic/entities/Trigger');
+
+const request = require('requestretry');
+
+const DEFAULT_RESPONSE = request.__defaultResponse();
+
+
+describe('trigger commands', () => {
+    beforeEach(async () => {
+        request.__reset();
+        request.mockClear();
+        await configureSdk(); // eslint-disable-line
+        // eslint-disable-next-line global-require
+        const sdk = require('../../../../logic/sdk');
+        sdk.triggers.delete = mockedDelete;
+    });
+
+    describe('get', () => {
+        it('should handle getting pipeline triggers', async () => {
+            const argv = { 'event-uri': 'uri' };
+            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 event triggers', async () => {
+            const argv = { pipeline: 'pipeline' };
+            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', 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('create', () => {
+        it('should handle creation', async () => {
+            const argv = { 'event-uri': 'uri', pipeline: 'pipeline' };
+            await createCmd.handler(argv);
+            await verifyResponsesReturned([DEFAULT_RESPONSE]); // eslint-disable-line
+        });
+    });
+
+    describe('delete', () => {
+        it('should handle deletion given name', async () => {
+            const argv = { 'event-uri': 'uri', pipeline: 'pipeline' };
+            await deleteCmd.handler(argv);
+            expect(mockedDelete).toHaveBeenCalledWith({ event: 'uri', pipeline: 'pipeline' });
+        });
+        it('should encode trigger name', async () => {
+            const cronUri = 'cron:codefresh:0 0 1 1 1/1 ?:test:0b3fdb693d73';
+            const argv = { 'event-uri': cronUri, pipeline: 'pipeline' };
+            await deleteCmd.handler(argv);
+            expect(mockedDelete).toHaveBeenCalledWith({
+                event: encodeURIComponent(cronUri),
+                pipeline: 'pipeline',
+            });
+        });
+    });
+});

package/lib/interface/cli/commands/trigger/type/get.cmd.js

@@ -0,0 +1,54 @@
+require('debug')('codefresh:cli:get:trigger-types');
+
+const Command = require('../../../Command');
+const _ = require('lodash');
+const Output = require('../../../../../output/Output');
+const getRoot = require('../../root/get.cmd');
+const { sdk } = require('../../../../../logic');
+const TriggerType = require('../../../../../logic/entities/TriggerType');
+
+const command = new Command({
+    command: 'trigger-types',
+    aliases: ['trigger-type', 'tt'],
+    parent: getRoot,
+    description: 'Get a list of available trigger-types',
+    webDocs: {
+        category: 'Triggers',
+        title: 'Get Trigger Types',
+    },
+    builder: (yargs) => {
+        yargs
+            .option('type', {
+                describe: 'filter by a specific trigger type (e.g. `registry`, `cron`)',
+            })
+            .option('kind', {
+                describe: 'filter by a specific trigger kind (e.g. `dockerhub`, `cfcr`, `gcr`, `acr`); only some `trigger-types` may have kinds',
+            })
+            .example('codefresh get trigger-types --type registry', 'Get Docker registry trigger types');
+    },
+    handler: async (argv) => {
+        const { type, kind } = argv;
+
+        let types;
+        if (type && kind) {
+            types = [await sdk.triggers.types.get({ type, kind })];
+        } else {
+            types = await sdk.triggers.types.list();
+            types = _.filter(types, (t) => {
+                if (type && kind) {
+                    return t.type === type && t.kind === kind;
+                } else if (type) {
+                    return t.type === type;
+                } else if (kind) {
+                    return t.kind === kind;
+                } else {
+                    return true;
+                }
+            });
+        }
+        Output.print(_.map(types, TriggerType.fromResponse));
+    },
+});
+
+module.exports = command;
+

package/lib/interface/cli/commands/trigger/type/trigger-type.sdk.spec.js

@@ -0,0 +1,33 @@
+const getCmd = require('./get.cmd').toCommand();
+
+jest.mock('../../../../../logic/entities/TriggerType');
+
+const request = require('requestretry');
+
+const DEFAULT_RESPONSE = request.__defaultResponse();
+
+describe('trigger type commands', () => {
+    beforeEach(async () => {
+        request.__reset();
+        request.mockClear();
+        await configureSdk(); // eslint-disable-line
+    });
+
+    describe('get', () => {
+        it('should handle getting by type and kind', async () => {
+            const argv = { type: 'type', kind: 'kind' };
+            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', async () => {
+            const argv = {};
+            const response = { statusCode: 200, body: [DEFAULT_RESPONSE.body] };
+            request.__setResponse(response);
+            await getCmd.handler(argv);
+            await verifyResponsesReturned([response]); // eslint-disable-line
+        });
+    });
+});

package/lib/interface/cli/commands/workflow/approve.cmd.js

@@ -0,0 +1,31 @@
+const Command = require('../../Command');
+const yargs = require('yargs');
+const _ = require('lodash');
+const { sdk } = require('../../../../logic');
+
+const approveBuildCmd = new Command({
+    root: true,
+    command: 'approve <buildId>',
+    description: 'Approve a pending-approval workflow',
+    usage: 'approve <$BUILD_ID>',
+    webDocs: {
+        category: 'Builds',
+        title: 'Approve',
+        weight: 100,
+    },
+    builder: (yargs) => {
+        return yargs
+            .positional('buildId', {
+                describe: 'Build\'s id',
+                required: true,
+            });
+    },
+    handler: async (argv) => {
+        const { buildId } = argv;
+        await sdk.workflows.getBuild({ buildId, noAccount: false });
+        await sdk.workflows.approve({ buildId });
+        console.log(`Workflow ${buildId} has been approved.`);
+    },
+});
+
+module.exports = approveBuildCmd;

package/lib/interface/cli/commands/workflow/approve.cmd.spec.js

@@ -0,0 +1,47 @@
+let approveCmd = require('./approve.cmd');
+
+approveCmd.requiresAuthentication = false;
+
+approveCmd = approveCmd.toCommand();
+
+
+jest.mock('../../helpers/validation', () => { // eslint-disable-line
+    return {
+        validatePipelineSpec: () => ({ valid: true }),
+    };
+});
+
+const request = require('requestretry');
+
+const DEFAULT_RESPONSE = request.__defaultResponse();
+
+describe('Approve pending-approval workflow', () => {
+    beforeEach(async () => {
+        request.__reset();
+        request.mockClear();
+        await configureSdk(); // eslint-disable-line
+    });
+
+    describe('Positive', () => {
+        it('should approve a pending-approval workflow', async () => {
+            const argv = {
+                buildId: 'buildId',
+            };
+            const response = { statusCode: 200, body: [DEFAULT_RESPONSE.body] };
+            request.__setResponse(response);
+            await approveCmd.handler(argv);
+            await verifyResponsesReturned([response, response]); // eslint-disable-line
+        });
+    });
+
+    describe('Negative', () => {
+        it('should approve a pending-approval workflow', async () => {
+            const argv = {
+                buildId: 'buildId',
+            };
+            const response = { statusCode: 404, body: [DEFAULT_RESPONSE.body] };
+            request.__setResponse(response);
+            await expect(approveCmd.handler(argv)).rejects.toThrow();
+        });
+    });
+});

package/lib/interface/cli/commands/workflow/deny.cmd.js

@@ -0,0 +1,31 @@
+const Command = require('../../Command');
+const yargs = require('yargs');
+const _ = require('lodash');
+const { sdk } = require('../../../../logic');
+
+const denyBuildCmd = new Command({
+    root: true,
+    command: 'deny <buildId>',
+    description: 'Deny a pending-approval workflow',
+    usage: 'deny <$BUILD_ID>',
+    webDocs: {
+        category: 'Builds',
+        title: 'Deny',
+        weight: 100,
+    },
+    builder: (yargs) => {
+        return yargs
+            .positional('buildId', {
+                describe: 'Build\'s id',
+                required: true,
+            });
+    },
+    handler: async (argv) => {
+        const { buildId } = argv;
+        await sdk.workflows.getBuild({ buildId, noAccount: false });
+        await sdk.workflows.deny({ buildId });
+        console.log(`Workflow ${buildId} has been denied.`);
+    },
+});
+
+module.exports = denyBuildCmd;

package/lib/interface/cli/commands/workflow/deny.cmd.spec.js

@@ -0,0 +1,47 @@
+let denyCmd = require('./deny.cmd');
+
+denyCmd.requiresAuthentication = false;
+
+denyCmd = denyCmd.toCommand();
+
+
+jest.mock('../../helpers/validation', () => { // eslint-disable-line
+    return {
+        validatePipelineSpec: () => ({ valid: true }),
+    };
+});
+
+const request = require('requestretry');
+
+const DEFAULT_RESPONSE = request.__defaultResponse();
+
+describe('Deny pending-approval workflow', () => {
+    beforeEach(async () => {
+        request.__reset();
+        request.mockClear();
+        await configureSdk(); // eslint-disable-line
+    });
+
+    describe('Positive', () => {
+        it('should deny a pending-approval workflow', async () => {
+            const argv = {
+                buildId: 'buildId',
+            };
+            const response = { statusCode: 200, body: [DEFAULT_RESPONSE.body] };
+            request.__setResponse(response);
+            await denyCmd.handler(argv);
+            await verifyResponsesReturned([response, response]); // eslint-disable-line
+        });
+    });
+
+    describe('Negative', () => {
+        it('should deny a pending-approval workflow', async () => {
+            const argv = {
+                buildId: 'buildId',
+            };
+            const response = { statusCode: 404, body: [DEFAULT_RESPONSE.body] };
+            request.__setResponse(response);
+            await expect(denyCmd.handler(argv)).rejects.toThrow();
+        });
+    });
+});

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

@@ -0,0 +1,161 @@
+const Command = require('../../Command');
+const CFError = require('cf-errors');
+const _ = require('lodash');
+const DEFAULTS = require('../../defaults');
+const Output = require('../../../../output/Output');
+const getRoot = require('../root/get.cmd');
+const Promise = require('bluebird');
+const { sdk } = require('../../../../logic');
+const Workflow = require('../../../../logic/entities/Workflow');
+
+const command = new Command({
+    command: 'builds [id..]',
+    aliases: ['build'],
+    parent: getRoot,
+    description: 'Get a specific build or an array of builds',
+    usage: 'Passing [id] argument will cause a retrieval of a specific build.\n In case of not passing [id] argument, a list will be returned',
+    webDocs: {
+        category: 'Builds',
+        title: 'Get Build',
+    },
+    builder: (yargs) => {
+        return yargs
+            .positional('id', {
+                describe: 'Build id',
+            })
+            .option('limit', {
+                alias: 'l',
+                describe: 'Limit amount of returned results',
+                default: DEFAULTS.GET_LIMIT_RESULTS,
+            })
+            .option('page', {
+                alias: 'p',
+                describe: 'Paginated page',
+                default: DEFAULTS.GET_PAGINATED_PAGE,
+            })
+            .option('status', {
+                alias: 's',
+                describe: 'Filter results by statuses',
+                type: Array,
+                choices: ['running', 'success', 'error', 'terminated', 'terminating', 'pending-approval', 'delayed', 'pending', 'elected'],
+            })
+            .option('trigger', {
+                alias: 't',
+                describe: 'Filter results by triggers',
+                type: Array,
+                choices: ['build', 'launch-image', 'launch-composition'],
+            })
+            .option('pipeline-id', {
+                alias: 'pid',
+                describe: 'Filter results by pipeline id',
+                type: Array,
+                default: [],
+            })
+            .option('pipeline-name', {
+                alias: 'pipeline',
+                describe: 'Filter results by pipeline name',
+                type: Array,
+                default: [],
+            })
+            .option('branch', {
+                alias: 'b',
+                describe: 'Filter results by branch',
+                type: Array,
+                default: [],
+            })
+            .option('commit-id', {
+                alias: ['revision', 'r', 'sha'],
+                describe: 'Filter results by commit revision sha',
+                type: Array,
+                default: [],
+            })
+            .option('pipeline-trigger-id', {
+                describe: 'Filter results by pipeline trigger id',
+                type: Array,
+                default: [],
+            })
+            .option('from', {
+                describe: 'Date in format: YYYY-MM-DD. Show builds from the provided date',
+                type: String,
+            })
+            .option('to', {
+                describe: 'Date in format: YYYY-MM-DD. Show builds up to provided date',
+                type: String,
+            })
+            .check((argv) => {
+                const { from, to } = argv;
+
+                const dateRegex = /^\d{4}-\d{1,2}-\d{1,2}$/;
+                if (from && !dateRegex.test(from)) {
+                    throw new Error('--from option should take a date in format: YYYY-MM-DD. Example: --from 2020-12-31');
+                }
+                if (to && !dateRegex.test(to)) {
+                    throw new Error('--to option should take a date in format: YYYY-MM-DD. Example: --to 2020-12-31');
+                }
+                return true;
+            })
+            .example('codefresh get build ID', 'Get build ID')
+            .example('codefresh get builds', 'Get all builds')
+            .example('codefresh get builds --pipeline-id ID', 'Get all builds that are executions of pipeline "ID"')
+            .example('codefresh get builds --pipeline-name NAME', 'Get all builds that are executions of pipelines that are named "NAME"')
+            .example('codefresh get builds --status=error', 'Get all builds that their status is error')
+            .example('codefresh get builds --from=2020-01-01 --to=2020-02-01', 'Get all builds within given date range');
+    },
+    handler: async (argv) => {
+        const workflowIds = argv.id;
+        const {
+            limit,
+            page,
+            status,
+            trigger,
+            branch: branchName,
+            commitId: revision,
+            'pipeline-trigger-id': pipelineTriggerId,
+            from,
+            to,
+        } = argv;
+        const pipelineNames = !_.isArray(argv['pipeline-name']) ? [(argv['pipeline-name'])] : argv['pipeline-name'];
+        const pipelineIds = !_.isArray(argv['pipeline-id']) ? [(argv['pipeline-id'])] : argv['pipeline-id'];
+
+        const requestOptions = {
+            limit,
+            page,
+            status,
+            trigger,
+            branchName,
+            revision,
+            pipelineTriggerId,
+            paginationReset: page === 1,
+            startDate: from,
+            endDate: to,
+        };
+
+        let workflows = [];
+        // TODO:need to decide for one way for error handeling
+        if (!_.isEmpty(workflowIds)) {
+            workflows = await Promise.map(workflowIds, id => sdk.workflows.getBuild({ buildId: id, noAccount: false }));
+            Output.print(_.map(workflows, Workflow.fromResponse));
+        } else {
+            if (!_.isEmpty(pipelineNames)) {
+                const pipelines = await sdk.pipelines.list({
+                    id: pipelineNames,
+                });
+                if (!_.isEmpty(pipelines)) {
+                    _.forEach(pipelines.docs, (currPipeline) => {
+                        pipelineIds.push(currPipeline.metadata.id);
+                    });
+                    requestOptions.pipeline = pipelineIds;
+                } else if (_.isEmpty(pipelineIds)) {
+                    throw new CFError('Cannot find any builds with these pipelines names');
+                }
+            } else if (!_.isEmpty(pipelineIds)) {
+                requestOptions.pipeline = pipelineIds;
+            }
+
+            const result = await sdk.workflows.list(requestOptions);
+            Output.print(_.map(_.get(result, 'workflows.docs'), Workflow.fromResponse));
+        }
+    },
+});
+
+module.exports = command;