codefresh 0.78.2

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

@@ -0,0 +1,51 @@
+const Command = require('../../Command');
+const CFError = require('cf-errors');
+const _ = require('lodash');
+const applyRoot = require('../root/apply.cmd');
+const { crudFilenameOption } = require('../../helpers/general');
+const { sdk } = require('../../../../logic');
+
+
+const command = new Command({
+    command: 'context',
+    aliases: ['ctx'],
+    parent: applyRoot,
+    description: 'Apply changes to a context',
+    usage: 'Use apply to patch an existing context',
+    webDocs: {
+        category: 'Contexts',
+        title: 'Update Context',
+        weight: 90,
+    },
+    builder: (yargs) => {
+        crudFilenameOption(yargs);
+        return yargs
+            .example('codefresh patch context -f ./context.yml', 'Apply changes to a context');
+    },
+    handler: async (argv) => {
+        const data = argv.filename;
+        const name = _.get(data, 'metadata.name');
+
+        if (!name) {
+            throw new CFError('Missing name in metadata');
+        }
+
+        try {
+            await sdk.contexts.get({ name });
+
+            await sdk.contexts.patch({ name }, data);
+            console.log(`Context: ${name} patched`);
+        } catch (err) {
+            if (err) {
+                await sdk.contexts.create(data);
+                console.log(`Context: ${name} created`);
+            } else {
+                throw err;
+            }
+        }
+    },
+});
+
+
+module.exports = command;
+

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

@@ -0,0 +1,158 @@
+const getCmd = require('./get.cmd').toCommand();
+const deleteCmd = require('./delete.cmd').toCommand();
+const applyCmd = require('./apply.cmd').toCommand();
+
+const request = require('requestretry');
+
+jest.mock('../../../../logic/entities/Context');
+
+
+const DEFAULT_RESPONSE = request.__defaultResponse();
+
+describe('context commands', () => {
+    beforeEach(async () => {
+        request.__reset();
+        request.mockClear();
+        await configureSdk(); // eslint-disable-line
+    });
+
+    describe('get', () => {
+        it('should handle getting given id', async () => {
+            const argv = { name: ['some name'] };
+            await getCmd.handler(argv);
+            await verifyResponsesReturned([DEFAULT_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', () => {
+        describe('git', () => {
+            describe('bitbucket', () => {
+                it('should handle creation', async () => {
+                    const cmd = require('./create/git/types/bitbucket.cmd');
+                    const argv = { name: 'some name' };
+                    await cmd.handler(argv);
+                    await verifyResponsesReturned([DEFAULT_RESPONSE]); // eslint-disable-line
+                });
+            });
+            describe('github', () => {
+                it('should handle creation', async () => {
+                    const cmd = require('./create/git/types/github.cmd');
+                    const argv = { name: 'some name' };
+                    await cmd.handler(argv);
+                    await verifyResponsesReturned([DEFAULT_RESPONSE]); // eslint-disable-line
+                });
+            });
+            describe('gitlab', () => {
+                it('should handle creation', async () => {
+                    const cmd = require('./create/git/types/gitlab.cmd');
+                    const argv = { name: 'some name' };
+                    await cmd.handler(argv);
+                    await verifyResponsesReturned([DEFAULT_RESPONSE]); // eslint-disable-line
+                });
+            });
+            describe('stash', () => {
+                it('should handle creation', async () => {
+                    const cmd = require('./create/git/types/stash.cmd');
+                    const argv = { name: 'some name' };
+                    await cmd.handler(argv);
+                    await verifyResponsesReturned([DEFAULT_RESPONSE]); // eslint-disable-line
+                });
+            });
+        });
+
+        describe('helm-repo', () => {
+            describe('http', () => {
+                it('should handle creation', async () => {
+                    const cmd = require('./create/helm-repo/types/http.cmd');
+                    const argv = { name: 'some name', url: 'some url' };
+                    await cmd.handler(argv);
+                    await verifyResponsesReturned([DEFAULT_RESPONSE]); // eslint-disable-line
+                });
+            });
+            describe('s3', () => {
+                it('should handle creation', async () => {
+                    const cmd = require('./create/helm-repo/types/s3.cmd');
+                    const argv = { name: 'some name', bucket: 'some bucket' };
+                    await cmd.handler(argv);
+                    await verifyResponsesReturned([DEFAULT_RESPONSE]); // eslint-disable-line
+                });
+            });
+        });
+
+        describe('config', () => {
+            it('should handle creation', async () => {
+                const cmd = require('./create/createConfig.cmd');
+                const argv = { name: 'some name', variable: [] };
+                await cmd.handler(argv);
+                await verifyResponsesReturned([DEFAULT_RESPONSE]); // eslint-disable-line
+            });
+        });
+
+        describe('secret', () => {
+            it('should handle creation', async () => {
+                const cmd = require('./create/createSecret.cmd');
+                const argv = { name: 'some name', variable: [] };
+                await cmd.handler(argv);
+                await verifyResponsesReturned([DEFAULT_RESPONSE]); // eslint-disable-line
+            });
+        });
+
+        describe('secret yaml', () => {
+            it('should handle creation', async () => {
+                const cmd = require('./create/createSecretYaml.cmd');
+                const argv = { name: 'some name', variable: [] };
+                await cmd.handler(argv);
+                await verifyResponsesReturned([DEFAULT_RESPONSE]); // eslint-disable-line
+            });
+        });
+
+        describe('yaml', () => {
+            it('should handle creation', async () => {
+                const cmd = require('./create/createYaml.cmd');
+                const argv = { name: 'some name', variable: [] };
+                await cmd.handler(argv);
+                await verifyResponsesReturned([DEFAULT_RESPONSE]); // eslint-disable-line
+            });
+        });
+    });
+
+    describe('apply', () => {
+        it('should handle patching when context is found', async () => {
+            const argv = { filename: { metadata: { name: 'some name' } } };
+            const responses = [
+                DEFAULT_RESPONSE,
+                DEFAULT_RESPONSE,
+            ];
+            request.__queueResponses(responses);
+            await applyCmd.handler(argv);
+            await verifyResponsesReturned(responses); // eslint-disable-line
+        });
+
+        it('should handle creation when context not found', async () => {
+            const argv = { filename: { metadata: { name: 'some name' } } };
+            const responses = [
+                { statusCode: 404 },
+                DEFAULT_RESPONSE,
+            ];
+            request.__queueResponses(responses);
+            await applyCmd.handler(argv);
+            await verifyResponsesReturned(responses); // eslint-disable-line
+        });
+    });
+
+    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
+        });
+    });
+});

package/lib/interface/cli/commands/context/create/createConfig.cmd.js

@@ -0,0 +1,54 @@
+const Command = require('../../../Command');
+const CFError = require('cf-errors');
+const { prepareKeyValueFromCLIEnvOption } = require('../../../helpers/general');
+const createContext = require('../create.cmd');
+const { sdk } = require('../../../../../logic');
+
+const command = new Command({
+    command: 'config <name>',
+    parent: createContext,
+    description: 'Create a config context',
+    webDocs: {
+        category: 'Create Context',
+        subCategory: 'Config',
+        title: 'Create Config Context',
+        weight: 10,
+    },
+    builder: (yargs) => {
+        yargs
+            .positional('name', {
+                describe: 'Name of context',
+            })
+            .option('variable', {
+                describe: 'Variables list',
+                default: [],
+                alias: 'v',
+            })
+            .example('codefresh create context config my-config -v key1=valu1 -v key2=value2', 'Create a config.');
+
+        return yargs;
+    },
+    handler: async (argv) => {
+        const data = {
+            apiVersion: 'v1',
+            kind: 'context',
+            metadata: {
+                name: argv.name,
+            },
+            spec: {
+                type: 'config',
+                data: prepareKeyValueFromCLIEnvOption(argv.variable),
+            },
+        };
+
+        if (!data.metadata.name || !data.spec.type) {
+            throw new CFError('Name and type must be provided');
+        }
+
+        await sdk.contexts.create(data);
+        console.log(`Context: ${data.metadata.name} created`);
+    },
+});
+
+module.exports = command;
+

package/lib/interface/cli/commands/context/create/createSecret.cmd.js

@@ -0,0 +1,54 @@
+const Command = require('../../../Command');
+const CFError = require('cf-errors');
+const { prepareKeyValueFromCLIEnvOption } = require('../../../helpers/general');
+const createContext = require('../create.cmd');
+const { sdk } = require('../../../../../logic');
+
+const command = new Command({
+    command: 'secret <name>',
+    parent: createContext,
+    description: 'Create a secret context',
+    webDocs: {
+        category: 'Create Context',
+        subCategory: 'Secret',
+        title: 'Create Secret Context',
+        weight: 20,
+    },
+    builder: (yargs) => {
+        yargs
+            .positional('name', {
+                describe: 'Name of context',
+            })
+            .option('variable', {
+                describe: 'Variables list',
+                default: [],
+                alias: 'v',
+            })
+            .example('codefresh create context secret my-secret -v key1=valu1 -v key2=value2', 'Create a secret.');
+
+        return yargs;
+    },
+    handler: async (argv) => {
+        const data = {
+            apiVersion: 'v1',
+            kind: 'context',
+            metadata: {
+                name: argv.name,
+            },
+            spec: {
+                type: 'secret',
+                data: prepareKeyValueFromCLIEnvOption(argv.variable),
+            },
+        };
+
+        if (!data.metadata.name || !data.spec.type) {
+            throw new CFError('Name and type must be provided');
+        }
+
+        await sdk.contexts.create(data);
+        console.log(`Context: ${data.metadata.name} created`);
+    },
+});
+
+module.exports = command;
+

package/lib/interface/cli/commands/context/create/createSecretYaml.cmd.js

@@ -0,0 +1,53 @@
+const Command = require('../../../Command');
+const CFError = require('cf-errors');
+const { prepareKeyValueFromCLIEnvOption } = require('../../../helpers/general');
+const createContext = require('../create.cmd');
+const { sdk } = require('../../../../../logic');
+
+const command = new Command({
+    command: 'secret-yaml <name>',
+    parent: createContext,
+    description: 'Create a secret-yaml context',
+    webDocs: {
+        category: 'Create Context',
+        subCategory: 'Secret Yaml',
+        title: 'Create Secret-Yaml Context',
+        weight: 30,
+    },
+    builder: (yargs) => {
+        yargs
+            .positional('name', {
+                describe: 'Name of context',
+            })
+            .option('variable', {
+                describe: 'Variables list',
+                default: [],
+                alias: 'v',
+            });
+
+        return yargs;
+    },
+    handler: async (argv) => {
+        const data = {
+            apiVersion: 'v1',
+            kind: 'context',
+            metadata: {
+                name: argv.name,
+            },
+            spec: {
+                type: 'secret-yaml',
+                data: prepareKeyValueFromCLIEnvOption(argv.variable),
+            },
+        };
+
+        if (!data.metadata.name || !data.spec.type) {
+            throw new CFError('Name and type must be provided');
+        }
+
+        await sdk.contexts.create(data);
+        console.log(`Context: ${data.metadata.name} created`);
+    },
+});
+
+module.exports = command;
+

package/lib/interface/cli/commands/context/create/createYaml.cmd.js

@@ -0,0 +1,53 @@
+const Command = require('../../../Command');
+const CFError = require('cf-errors');
+const { prepareKeyValueFromCLIEnvOption } = require('../../../helpers/general');
+const createContext = require('../create.cmd');
+const { sdk } = require('../../../../../logic');
+
+const command = new Command({
+    command: 'yaml <name>',
+    parent: createContext,
+    description: 'Create a yaml context',
+    webDocs: {
+        category: 'Create Context',
+        subCategory: 'Yaml',
+        title: 'Create Yaml Context',
+        weight: 40,
+    },
+    builder: (yargs) => {
+        yargs
+            .positional('name', {
+                describe: 'Name of context',
+            })
+            .option('variable', {
+                describe: 'Variables list',
+                default: [],
+                alias: 'v',
+            });
+
+        return yargs;
+    },
+    handler: async (argv) => {
+        const data = {
+            apiVersion: 'v1',
+            kind: 'context',
+            metadata: {
+                name: argv.name,
+            },
+            spec: {
+                type: 'yaml',
+                data: prepareKeyValueFromCLIEnvOption(argv.variable),
+            },
+        };
+
+        if (!data.metadata.name || !data.spec.type) {
+            throw new CFError('Name and type must be provided');
+        }
+
+        await sdk.contexts.create(data);
+        console.log(`Context: ${data.metadata.name} created`);
+    },
+});
+
+module.exports = command;
+

package/lib/interface/cli/commands/context/create/git/base.cmd.js

@@ -0,0 +1,38 @@
+const Command = require('../../../../Command');
+const createContext = require('../../create.cmd');
+
+const CODEFRESH_GIT_CLONE_REFERENCE = 'https://codefresh.io/docs/docs/codefresh-yaml/steps/git-clone/';
+
+const usage = `Git context are used to clone repositories during pipeline execution.\nLearn more about git context here: ${CODEFRESH_GIT_CLONE_REFERENCE}`;
+
+const command = new Command({
+    command: 'git',
+    parent: createContext,
+    description: 'Create a git context [type]',
+    usage,
+    webDocs: {
+        category: 'Create Context',
+        subCategory: 'Git',
+        title: 'Create Git Context',
+    },
+    builder: (yargs) => {
+        yargs
+            .option('sharing-policy', {
+                describe: 'Set the sharing policy for git contexts',
+                choices: ['AccountAdmins', 'AllUsersInAccount'],
+                default: 'AccountAdmins',
+            })
+            .option('behind-firewall', {
+                describe: 'Set to true to mark this context with behind firewall flag',
+                type: 'boolean',
+                default: false,
+            });
+        return yargs;
+    },
+    handler: async (argv) => {
+        yargs.showHelp();
+    },
+});
+
+module.exports = command;
+

package/lib/interface/cli/commands/context/create/git/types/bitbucket.cmd.js

@@ -0,0 +1,64 @@
+const Command = require('../../../../../Command');
+const CFError = require('cf-errors');
+const createGitCmd = require('./../base.cmd');
+const { sdk } = require('../../../../../../../logic');
+
+const LINK = 'https://bitbucket.org/account/user/{YOUR-USERNAME}/app-passwords';
+
+
+const command = new Command({
+    command: 'bitbucket <name>',
+    parent: createGitCmd,
+    description: 'Create a bitbucket context',
+    usage: `${createGitCmd.usage}\nTo create bitbucket context you need to generate application password from here: ${LINK}`,
+    webDocs: {
+        category: 'Create Git Context',
+        subCategory: 'bitbucket',
+        title: 'bitbucket',
+        weight: 10,
+    },
+    builder: (yargs) => {
+        yargs
+            .option('app-password', {
+                describe: 'Application password generated in bitbucket',
+                alias: 'a',
+                required: true,
+            })
+            .option('username', {
+                describe: 'username that has permissions to use application password',
+                alias: 'u',
+                required: true,
+            });
+        return yargs;
+    },
+    handler: async (argv) => {
+        const data = {
+            apiVersion: 'v1',
+            kind: 'context',
+            metadata: {
+                name: argv.name,
+            },
+            spec: {
+                type: 'git.bitbucket',
+                data: {
+                    behindFirewall: argv.behindFirewall,
+                    sharingPolicy: argv.sharingPolicy,
+                    auth: {
+                        type: 'basic',
+                        username: argv.username,
+                        password: argv.appPassword,
+                    },
+                },
+            },
+        };
+
+
+        if (!data.metadata.name || !data.spec.type) {
+            throw new CFError('Name and type must be provided');
+        }
+        await sdk.contexts.create(data);
+        console.log(`Context: ${data.metadata.name} created`);
+    },
+});
+
+module.exports = command;

package/lib/interface/cli/commands/context/create/git/types/github.cmd.js

@@ -0,0 +1,79 @@
+const debug = require('debug')('codefresh:cli:create:context:git:github');
+const Command = require('../../../../../Command');
+const CFError = require('cf-errors');
+const createGitCmd = require('./../base.cmd');
+const { sdk } = require('../../../../../../../logic');
+
+const LINK = 'https://github.com/settings/tokens';
+const DEFAULT_API_HOST = 'api.github.com';
+const DEFAULT_API_PREFIX = '/';
+
+const command = new Command({
+    command: 'github <name>',
+    parent: createGitCmd,
+    description: 'Create a github context',
+    usage: `${createGitCmd.usage}\nTo create Github context you need to generate the token here: ${LINK}`,
+    webDocs: {
+        category: 'Create Git Context',
+        subCategory: 'github',
+        title: 'github',
+        weight: 10,
+    },
+    builder: (yargs) => {
+        yargs
+            .option('access-token', {
+                describe: 'Access token from to be used to clone repositories',
+                alias: 't',
+                required: true,
+            })
+            .option('host', {
+                describe: 'Host name of your github (without protocol)',
+                alias: 'h',
+                default: DEFAULT_API_HOST,
+                required: true,
+            })
+            .option('api-path-prefix', {
+                describe: 'Prefix of the api on the given host',
+                alias: 'a',
+                default: DEFAULT_API_PREFIX,
+                required: true,
+            });
+        return yargs;
+    },
+    handler: async (argv) => {
+        const data = {
+            apiVersion: 'v1',
+            kind: 'context',
+            metadata: {
+                name: argv.name,
+            },
+            spec: {
+                type: 'git.github',
+                data: {
+                    behindFirewall: argv.behindFirewall,
+                    sharingPolicy: argv.sharingPolicy,
+                    auth: {
+                        type: 'basic',
+                        password: argv.accessToken,
+                    },
+                },
+            },
+        };
+
+        if (argv.apiPathPrefix !== DEFAULT_API_PREFIX) {
+            data.spec.data.auth.apiPathPrefix = argv.apiPathPrefix;
+        }
+
+        if (argv.host !== DEFAULT_API_HOST) {
+            data.spec.data.auth.apiHost = argv.host;
+        }
+
+        if (!data.metadata.name || !data.spec.type) {
+            throw new CFError('Name and type must be provided');
+        }
+        await sdk.contexts.create(data);
+        console.log(`Context: ${data.metadata.name} created`);
+    },
+});
+
+module.exports = command;

package/lib/interface/cli/commands/context/create/git/types/gitlab.cmd.js

@@ -0,0 +1,71 @@
+const debug = require('debug')('codefresh:cli:create:context:git:gitlab');
+const Command = require('../../../../../Command');
+const CFError = require('cf-errors');
+const createGitCmd = require('./../base.cmd');
+const { sdk } = require('../../../../../../../logic');
+
+
+const LINK = 'https://gitlab.com/profile/personal_access_tokens';
+const DEFAULT_API_URL = 'https://gitlab.com/api/v4/';
+
+
+const command = new Command({
+    command: 'gitlab <name>',
+    parent: createGitCmd,
+    description: 'Create a gitlab context',
+    usage: `${createGitCmd.usage}\nTo create gitlab context you need to generate the token here: ${LINK}`,
+    webDocs: {
+        category: 'Create Git Context',
+        subCategory: 'gitlab',
+        title: 'gitlab',
+        weight: 10,
+    },
+    builder: (yargs) => {
+        yargs
+            .option('access-token', {
+                describe: 'Access token from to be used to clone repositories',
+                alias: 't',
+                required: true,
+            })
+            .option('api-url', {
+                describe: 'URL of the api',
+                alias: 'a',
+                default: 'https://gitlab.com/api/v4/',
+                required: true,
+            });
+        return yargs;
+    },
+    handler: async (argv) => {
+        const data = {
+            apiVersion: 'v1',
+            kind: 'context',
+            metadata: {
+                name: argv.name,
+            },
+            spec: {
+                type: 'git.gitlab',
+                data: {
+                    behindFirewall: argv.behindFirewall,
+                    sharingPolicy: argv.sharingPolicy,
+                    auth: {
+                        type: 'basic',
+                        password: argv.accessToken,
+                    },
+                },
+            },
+        };
+
+        if (argv.apiUrl !== DEFAULT_API_URL) {
+            data.spec.data.auth.apiURL = argv.apiUrl;
+        }
+
+
+        if (!data.metadata.name || !data.spec.type) {
+            throw new CFError('Name and type must be provided');
+        }
+        await sdk.contexts.create(data);
+        console.log(`Context: ${data.metadata.name} created`);
+    },
+});
+
+module.exports = command;