@squiz/dxp-cli-next 5.14.0 → 5.15.0-develop.2

package/lib/porter/project/add/add.js

@@ -0,0 +1,125 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const commander_1 = require("commander");
+const chalk_1 = __importDefault(require("chalk"));
+const promises_1 = __importDefault(require("fs/promises"));
+const path_1 = __importDefault(require("path"));
+const ora_1 = __importDefault(require("ora"));
+const ApiService_1 = require("../../../ApiService");
+const utils_1 = require("../../utils");
+const dxp_porter_shared_1 = require("@squiz/dxp-porter-shared");
+const constants_1 = require("../../constants");
+const { version: cliVersion } = require('../../../../package.json');
+const allPortStages = Object.values(dxp_porter_shared_1.Stage);
+const stageDirsToCreate = allPortStages.filter(stage => stage !== dxp_porter_shared_1.Stage['component-transform'] && stage !== dxp_porter_shared_1.Stage['design-dedupe']);
+const createAddProjectCommand = () => {
+    const addCommand = new commander_1.Command('addProject')
+        .description('Adds a new project')
+        .addOption(new commander_1.Option('--project-name <string>', 'project name')
+        .makeOptionMandatory()
+        .argParser(name => {
+        // Project name validation
+        const regex = /^[a-zA-Z0-9\-_]+$/;
+        if (!regex.test(name)) {
+            throw new commander_1.InvalidArgumentError('Project name can only contain letters, numbers, hyphen and underscore');
+        }
+        return name;
+    }))
+        .addOption(new commander_1.Option('--path <string>', 'path to store the project').makeOptionMandatory())
+        .configureOutput({
+        outputError(str, write) {
+            write(chalk_1.default.red(str));
+        },
+    })
+        .action((options) => __awaiter(void 0, void 0, void 0, function* () {
+        var _a, _b;
+        yield (0, utils_1.throwErrorIfNotLoggedIn)(addCommand);
+        const baseUrl = yield (0, utils_1.buildPorterUrl)();
+        const projectName = options.projectName;
+        const projectPath = options.path;
+        const spinner = (0, ora_1.default)();
+        const projectDir = path_1.default.resolve(projectPath);
+        try {
+            const pathExists = yield (0, utils_1.doesPathExist)(projectPath);
+            if (pathExists) {
+                throw new Error(constants_1.PORTER_ERRORS.projectAlreadyExists);
+            }
+            const parentDir = path_1.default.dirname(projectDir);
+            try {
+                yield promises_1.default.access(parentDir);
+            }
+            catch (_c) {
+                throw new Error(`Project parent directory "${parentDir}" does not exist`);
+            }
+            spinner.start('Creating a new project..');
+            yield promises_1.default.mkdir(projectDir);
+            (0, utils_1.logDebug)(`Directory created successfully at ${projectDir}`);
+            const configJsonFile = path_1.default.join(projectDir, 'config.json');
+            yield promises_1.default.writeFile(configJsonFile, JSON.stringify({
+                service: 'dxp-porter',
+                projectName,
+                version: cliVersion,
+            }, null, 2));
+            (0, utils_1.logDebug)(`File created successfully at ${configJsonFile}`);
+            const stageConfigDir = path_1.default.join(projectDir, 'stage-configs');
+            yield promises_1.default.mkdir(stageConfigDir);
+            (0, utils_1.logDebug)(`Directory created successfully at ${stageConfigDir}`);
+            yield Promise.all(stageDirsToCreate.map((stage) => __awaiter(void 0, void 0, void 0, function* () {
+                const stageDir = path_1.default.join(stageConfigDir, stage);
+                yield promises_1.default.mkdir(stageDir);
+                (0, utils_1.logDebug)(`Directory created successfully at ${stageDir}`);
+            })));
+            const crawlConfigExample = path_1.default.join(stageConfigDir, 'crawl', 'config.json.example');
+            yield promises_1.default.writeFile(crawlConfigExample, JSON.stringify({
+                start_urls: ['https://...', 'https://...'],
+                exclude_patterns: ['https://...', 'https://...'],
+                max_download_size: 'MB',
+                request_delay: 'INT',
+                max_dir_depth: 'INT',
+                max_files_stored: 'INT',
+                run: true,
+            }, null, 2));
+            (0, utils_1.logDebug)(`File created successfully at ${crawlConfigExample}`);
+            // Default example configs for other stages
+            stageDirsToCreate
+                .filter(dir => dir !== dxp_porter_shared_1.Stage.crawl)
+                .map((dir) => __awaiter(void 0, void 0, void 0, function* () {
+                const configExample = path_1.default.join(stageConfigDir, dir, 'config.json.example');
+                yield promises_1.default.writeFile(configExample, JSON.stringify({ run: true }, null, 2));
+                (0, utils_1.logDebug)(`File created successfully at ${configExample}`);
+            }));
+            const apiService = new ApiService_1.ApiService(utils_1.validateAxiosStatus, baseUrl);
+            const requestBody = { 'new-project': true };
+            const response = yield apiService.client.put(`/projects/${projectName}`, requestBody);
+            (0, utils_1.logDebug)(response.data);
+            spinner.succeed(`Project "${projectName}" created. Project directory initialized`);
+        }
+        catch (error) {
+            (0, utils_1.logDebug)(`ERROR: ${error instanceof Error ? `${error.message}` : JSON.stringify(error)}`);
+            if (spinner.isSpinning) {
+                spinner.fail();
+            }
+            if (((_b = (_a = error.response) === null || _a === void 0 ? void 0 : _a.data) === null || _b === void 0 ? void 0 : _b.status) === 409) {
+                (0, utils_1.logDebug)(`Failed to create new project, removing project directory: "${projectDir}"`);
+                yield promises_1.default.rm(projectDir, { recursive: true });
+                const errorMessage = `Project "${projectName}" already exists. Try a different project name`;
+                return (0, utils_1.handleError)(addCommand, errorMessage);
+            }
+            (0, utils_1.handleCommandError)(addCommand, error);
+        }
+    }));
+    return addCommand;
+};
+exports.default = createAddProjectCommand;

package/lib/porter/project/add/add.spec.d.ts

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

package/lib/porter/project/add/add.spec.js

@@ -0,0 +1,270 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const commander_1 = require("commander");
+const promises_1 = __importDefault(require("fs/promises"));
+const axios_1 = require("axios");
+const ApiService = __importStar(require("../../../ApiService"));
+const PorterUtils = __importStar(require("../../utils"));
+const mockCliVersion = '1.2.3';
+jest.mock('../../../../package.json', () => {
+    return {
+        version: mockCliVersion,
+    };
+});
+jest.mock('fs/promises', () => {
+    return {
+        access: jest.fn(),
+        mkdir: jest.fn(),
+        rm: jest.fn(),
+        writeFile: jest.fn(),
+    };
+});
+jest.mock('../../utils');
+describe('addProject', () => {
+    let projectName;
+    let projectPath;
+    let baseUrl;
+    let mockHandleCommandError;
+    let mockHandleError;
+    let mockBuildPorterUrl;
+    let mockResponse;
+    let mockClient;
+    beforeEach(() => {
+        jest.resetAllMocks();
+        jest.clearAllMocks();
+        projectName = 'porter-project';
+        projectPath = 'tmp/project-dir';
+        baseUrl = 'mock-url';
+        mockHandleCommandError = jest.fn(() => Promise.resolve());
+        mockHandleError = jest.fn();
+        mockBuildPorterUrl = jest.fn(() => Promise.resolve(baseUrl));
+        mockResponse = {
+            data: {},
+            status: 200,
+        };
+        mockClient = {
+            put: jest.fn().mockImplementationOnce(() => mockResponse),
+        };
+        jest.spyOn(PorterUtils, 'throwErrorIfNotLoggedIn').mockImplementation();
+        jest
+            .spyOn(PorterUtils, 'doesPathExist')
+            .mockImplementationOnce(() => Promise.resolve(false));
+        jest
+            .spyOn(PorterUtils, 'buildPorterUrl')
+            .mockImplementationOnce(mockBuildPorterUrl);
+        jest
+            .spyOn(PorterUtils, 'handleCommandError')
+            .mockImplementationOnce(mockHandleCommandError);
+        jest
+            .spyOn(PorterUtils, 'handleError')
+            .mockImplementationOnce(mockHandleError);
+        jest.spyOn(process, 'exit').mockImplementation();
+        jest.spyOn(ApiService, 'ApiService').mockImplementationOnce(() => {
+            return {
+                client: mockClient,
+            };
+        });
+    });
+    it('should throw an error if project name is invalid', () => __awaiter(void 0, void 0, void 0, function* () {
+        // Project name can only contain letters, numbers, hyphens and underscores'
+        const projectNameInvalid = '!@#$';
+        const { default: createAddCommand } = require('./add');
+        const program = createAddCommand();
+        yield expect(() => program.parseAsync([
+            'project',
+            'addProject',
+            '--project-name',
+            projectNameInvalid,
+            '--path',
+            projectPath,
+        ])).rejects.toThrow(commander_1.InvalidArgumentError);
+        expect(process.exit).toHaveBeenCalled();
+    }));
+    it('should throw an error if not logged in', () => __awaiter(void 0, void 0, void 0, function* () {
+        const mockError = new Error('Error not logged in');
+        jest
+            .spyOn(PorterUtils, 'throwErrorIfNotLoggedIn')
+            .mockImplementationOnce(() => {
+            throw mockError;
+        });
+        const { default: createAddCommand } = require('./add');
+        const program = createAddCommand();
+        yield expect(() => program.parseAsync([
+            'project',
+            'addProject',
+            '--project-name',
+            projectName,
+            '--path',
+            projectPath,
+        ])).rejects.toThrow(mockError);
+        const opts = program.opts();
+        expect(opts.projectName).toEqual(projectName);
+        expect(opts.path).toEqual(projectPath);
+        expect(PorterUtils.buildPorterUrl).not.toHaveBeenCalled();
+    }));
+    it('should throw an error if project directory already exists', () => __awaiter(void 0, void 0, void 0, function* () {
+        jest
+            .spyOn(PorterUtils, 'doesPathExist')
+            .mockReset()
+            .mockImplementationOnce(() => Promise.resolve(true));
+        const { default: createAddCommand } = require('./add');
+        const program = createAddCommand();
+        yield program.parseAsync([
+            'project',
+            'addProject',
+            '--project-name',
+            projectName,
+            '--path',
+            projectPath,
+        ]);
+        const opts = program.opts();
+        expect(opts.projectName).toEqual(projectName);
+        expect(opts.path).toEqual(projectPath);
+        expect(PorterUtils.buildPorterUrl).toHaveBeenCalled();
+        expect(PorterUtils.doesPathExist).toHaveBeenCalled();
+        expect(mockClient.put).not.toHaveBeenCalled();
+        expect(PorterUtils.handleCommandError).toHaveBeenCalled();
+    }));
+    it('should throw an error if parent directory does not exist', () => __awaiter(void 0, void 0, void 0, function* () {
+        jest.spyOn(promises_1.default, 'access').mockImplementationOnce(() => {
+            throw new Error();
+        });
+        const { default: createAddCommand } = require('./add');
+        const program = createAddCommand();
+        yield program.parseAsync([
+            'project',
+            'addProject',
+            '--project-name',
+            projectName,
+            '--path',
+            projectPath,
+        ]);
+        const opts = program.opts();
+        expect(opts.projectName).toEqual(projectName);
+        expect(opts.path).toEqual(projectPath);
+        expect(PorterUtils.buildPorterUrl).toHaveBeenCalled();
+        expect(PorterUtils.doesPathExist).toHaveBeenCalled();
+        expect(promises_1.default.access).toHaveBeenCalled();
+        expect(mockClient.put).not.toHaveBeenCalled();
+        expect(PorterUtils.handleCommandError).toHaveBeenCalled();
+    }));
+    it('should clean up the directory if project already exists', () => __awaiter(void 0, void 0, void 0, function* () {
+        mockClient.put = jest.fn(() => {
+            throw new axios_1.AxiosError('Project already exists', '409', undefined, undefined, {
+                data: { status: 409 },
+            });
+        });
+        const { default: createAddCommand } = require('./add');
+        const program = createAddCommand();
+        yield program.parseAsync([
+            'project',
+            'addProject',
+            '--project-name',
+            projectName,
+            '--path',
+            projectPath,
+        ]);
+        const opts = program.opts();
+        expect(opts.projectName).toEqual(projectName);
+        expect(opts.path).toEqual(projectPath);
+        expect(PorterUtils.buildPorterUrl).toHaveBeenCalled();
+        expect(PorterUtils.doesPathExist).toHaveBeenCalled();
+        expect(promises_1.default.access).toHaveBeenCalled();
+        // Create project dir, create "stage-configs" directory, create directories for (crawl, index, template-dedupe, validation, report)
+        expect(promises_1.default.mkdir).toHaveBeenCalledTimes(7);
+        // Create project config.json as well as 5 example config.json (for each stage)
+        expect(promises_1.default.writeFile).toHaveBeenCalledTimes(6);
+        expect(promises_1.default.writeFile).toHaveBeenNthCalledWith(1, expect.any(String), expect.stringContaining(mockCliVersion));
+        expect(mockClient.put).toHaveBeenCalled();
+        expect(promises_1.default.rm).toHaveBeenCalled();
+        expect(PorterUtils.handleError).toHaveBeenCalled();
+        expect(PorterUtils.handleCommandError).not.toHaveBeenCalled();
+    }));
+    it('should handle unexpected errors', () => __awaiter(void 0, void 0, void 0, function* () {
+        const { default: createAddCommand } = require('./add');
+        const program = createAddCommand();
+        yield program.parseAsync([
+            'project',
+            'addProject',
+            '--project-name',
+            projectName,
+            '--path',
+            projectPath,
+        ]);
+        const opts = program.opts();
+        expect(opts.projectName).toEqual(projectName);
+        expect(opts.path).toEqual(projectPath);
+        expect(PorterUtils.buildPorterUrl).toHaveBeenCalled();
+        expect(PorterUtils.doesPathExist).toHaveBeenCalled();
+        expect(promises_1.default.access).toHaveBeenCalled();
+        // Create project dir, create "stage-configs" directory, create directories for (crawl, index, template-dedupe, validation, report)
+        expect(promises_1.default.mkdir).toHaveBeenCalledTimes(7);
+        // Create project config.json as well as 5 example config.json (for each stage)
+        expect(promises_1.default.writeFile).toHaveBeenCalledTimes(6);
+        expect(promises_1.default.writeFile).toHaveBeenNthCalledWith(1, expect.any(String), expect.stringContaining(mockCliVersion));
+        expect(mockClient.put).toHaveBeenCalled();
+        expect(PorterUtils.handleCommandError).not.toHaveBeenCalled();
+    }));
+    it('should successfully initialise the project directory and the porter project', () => __awaiter(void 0, void 0, void 0, function* () {
+        const { default: createAddCommand } = require('./add');
+        const program = createAddCommand();
+        yield program.parseAsync([
+            'project',
+            'addProject',
+            '--project-name',
+            projectName,
+            '--path',
+            projectPath,
+        ]);
+        const opts = program.opts();
+        expect(opts.projectName).toEqual(projectName);
+        expect(opts.path).toEqual(projectPath);
+        expect(PorterUtils.buildPorterUrl).toHaveBeenCalled();
+        expect(PorterUtils.doesPathExist).toHaveBeenCalled();
+        expect(promises_1.default.access).toHaveBeenCalled();
+        // Create project dir, create "stage-configs" directory, create directories for (crawl, index, template-dedupe, validation, report)
+        expect(promises_1.default.mkdir).toHaveBeenCalledTimes(7);
+        // Create project config.json as well as 5 example config.json (for each stage)
+        expect(promises_1.default.writeFile).toHaveBeenCalledTimes(6);
+        expect(promises_1.default.writeFile).toHaveBeenNthCalledWith(1, expect.any(String), expect.stringContaining(mockCliVersion));
+        expect(mockClient.put).toHaveBeenCalled();
+        expect(promises_1.default.rm).not.toHaveBeenCalled();
+        expect(PorterUtils.handleError).not.toHaveBeenCalled();
+        expect(PorterUtils.handleCommandError).not.toHaveBeenCalled();
+    }));
+});

package/lib/porter/project/get/get.d.ts

@@ -0,0 +1,3 @@
+import { Command } from 'commander';
+declare const createGetProjectCommand: () => Command;
+export default createGetProjectCommand;

package/lib/porter/project/get/get.js

@@ -0,0 +1,62 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const commander_1 = require("commander");
+const chalk_1 = __importDefault(require("chalk"));
+const ora_1 = __importDefault(require("ora"));
+const ApiService_1 = require("../../../ApiService");
+const utils_1 = require("../../utils");
+const createGetProjectCommand = () => {
+    const getCommand = new commander_1.Command('getProject')
+        .description('Retrieves the project')
+        .configureOutput({
+        outputError(str, write) {
+            write(chalk_1.default.red(str));
+        },
+    })
+        .action((options) => __awaiter(void 0, void 0, void 0, function* () {
+        var _a, _b;
+        yield (0, utils_1.throwErrorIfNotLoggedIn)(getCommand);
+        const baseUrl = yield (0, utils_1.buildPorterUrl)();
+        let projectName = '';
+        const spinner = (0, ora_1.default)();
+        try {
+            projectName = yield (0, utils_1.getProjectName)();
+            spinner.start('Retrieving project..');
+            const apiService = new ApiService_1.ApiService(utils_1.validateAxiosStatus, baseUrl);
+            const response = yield apiService.client.get(`/projects/${projectName}`);
+            const jsonResponse = response.data;
+            (0, utils_1.logDebug)(JSON.stringify(jsonResponse));
+            spinner.succeed();
+            console.log('');
+            console.log(`Project name: ${projectName}`);
+            console.log(`Download last port report: ${jsonResponse['last-report-link'] || 'Not generated'}`);
+            console.log(`Download last port artifacts: ${jsonResponse['last-artifacts-link'] || 'Not generated'}`);
+        }
+        catch (error) {
+            (0, utils_1.logDebug)(`ERROR: ${error instanceof Error ? `${error.message}` : JSON.stringify(error)}`);
+            if (spinner.isSpinning) {
+                spinner.fail();
+            }
+            if (((_b = (_a = error.response) === null || _a === void 0 ? void 0 : _a.data) === null || _b === void 0 ? void 0 : _b.status) === 404) {
+                (0, utils_1.logDebug)(error.response.data);
+                const errorMessage = `Project "${projectName}" not found in DXP porter service`;
+                return (0, utils_1.handleError)(getCommand, errorMessage);
+            }
+            (0, utils_1.handleCommandError)(getCommand, error);
+        }
+    }));
+    return getCommand;
+};
+exports.default = createGetProjectCommand;

package/lib/porter/project/get/get.spec.d.ts

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

package/lib/porter/project/get/get.spec.js

@@ -0,0 +1,185 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const axios_1 = require("axios");
+const ApiService = __importStar(require("../../../ApiService"));
+const PorterUtils = __importStar(require("../../utils"));
+const logSpy = jest.spyOn(global.console, 'log');
+jest.mock('../../utils');
+describe('getProject', () => {
+    let baseUrl;
+    let projectName;
+    let mockHandleCommandError;
+    let mockHandleError;
+    let mockBuildPorterUrl;
+    let mockResponse;
+    let mockClient;
+    beforeEach(() => {
+        jest.resetAllMocks();
+        jest.clearAllMocks();
+        projectName = 'porter-project';
+        baseUrl = 'mock-url';
+        mockHandleCommandError = jest.fn(() => Promise.resolve());
+        mockHandleError = jest.fn();
+        mockBuildPorterUrl = jest.fn(() => Promise.resolve(baseUrl));
+        mockResponse = {
+            data: {},
+            status: 200,
+        };
+        mockClient = {
+            get: jest.fn().mockImplementationOnce(() => mockResponse),
+        };
+        jest.spyOn(PorterUtils, 'throwErrorIfNotLoggedIn').mockImplementation();
+        jest
+            .spyOn(PorterUtils, 'getProjectName')
+            .mockImplementationOnce(() => Promise.resolve(projectName));
+        jest
+            .spyOn(PorterUtils, 'buildPorterUrl')
+            .mockImplementationOnce(mockBuildPorterUrl);
+        jest
+            .spyOn(PorterUtils, 'handleCommandError')
+            .mockImplementationOnce(mockHandleCommandError);
+        jest
+            .spyOn(PorterUtils, 'handleError')
+            .mockImplementationOnce(mockHandleError);
+        jest.spyOn(process, 'exit').mockImplementation();
+        jest.spyOn(ApiService, 'ApiService').mockImplementationOnce(() => {
+            return {
+                client: mockClient,
+            };
+        });
+    });
+    it('should throw an error if not logged in', () => __awaiter(void 0, void 0, void 0, function* () {
+        const mockError = new Error('Error not logged in');
+        jest
+            .spyOn(PorterUtils, 'throwErrorIfNotLoggedIn')
+            .mockImplementation(() => {
+            throw mockError;
+        });
+        const { default: createGetCommand } = require('./get');
+        const program = createGetCommand();
+        yield expect(() => program.parseAsync(['project', 'getProject'])).rejects.toThrow(mockError);
+        const opts = program.opts();
+        expect(opts).toStrictEqual({});
+        expect(PorterUtils.throwErrorIfNotLoggedIn).toHaveBeenCalled();
+        expect(PorterUtils.buildPorterUrl).not.toHaveBeenCalled();
+    }));
+    it('should throw an error if project name could not be found', () => __awaiter(void 0, void 0, void 0, function* () {
+        jest
+            .spyOn(PorterUtils, 'getProjectName')
+            .mockReset()
+            .mockImplementation(() => {
+            throw new Error();
+        });
+        const { default: createGetCommand } = require('./get');
+        const program = createGetCommand();
+        yield program.parseAsync(['dxp-next', 'porter', 'project', 'getProject']);
+        expect(PorterUtils.throwErrorIfNotLoggedIn).toHaveBeenCalled();
+        expect(PorterUtils.buildPorterUrl).toHaveBeenCalled();
+        expect(mockClient.get).not.toHaveBeenCalled();
+        expect(PorterUtils.handleCommandError).toHaveBeenCalled();
+    }));
+    it('should throw an error if the project does not exist in the cloud', () => __awaiter(void 0, void 0, void 0, function* () {
+        mockClient.get = jest.fn(() => {
+            throw new axios_1.AxiosError('Project does not exist', '404', undefined, undefined, {
+                data: { status: 404 },
+            });
+        });
+        const { default: createGetCommand } = require('./get');
+        const program = createGetCommand();
+        yield program.parseAsync(['project', 'getProject']);
+        expect(PorterUtils.throwErrorIfNotLoggedIn).toHaveBeenCalled();
+        expect(PorterUtils.buildPorterUrl).toHaveBeenCalled();
+        expect(mockClient.get).toHaveBeenCalled();
+        expect(PorterUtils.handleError).toHaveBeenCalled();
+    }));
+    it('should handle unexpected errors', () => __awaiter(void 0, void 0, void 0, function* () {
+        mockClient.get = jest.fn(() => {
+            throw new axios_1.AxiosError('Internal server error', '500', undefined, undefined, {
+                data: { status: 500 },
+            });
+        });
+        const { default: createGetCommand } = require('./get');
+        const program = createGetCommand();
+        yield program.parseAsync(['project', 'getProject']);
+        expect(PorterUtils.throwErrorIfNotLoggedIn).toHaveBeenCalled();
+        expect(PorterUtils.buildPorterUrl).toHaveBeenCalled();
+        expect(mockClient.get).toHaveBeenCalled();
+        expect(PorterUtils.handleCommandError).toHaveBeenCalled();
+    }));
+    it('should successfully retrieve the project details (without generated links) and log this to the console', () => __awaiter(void 0, void 0, void 0, function* () {
+        const mockGetResponse = {
+            projectid: projectName,
+            'last-artifacts-link': null,
+            'last-report-link': null,
+        };
+        mockResponse = {
+            data: mockGetResponse,
+            status: 200,
+        };
+        const { default: createGetCommand } = require('./get');
+        const program = createGetCommand();
+        yield program.parseAsync(['project', 'getProject']);
+        expect(PorterUtils.throwErrorIfNotLoggedIn).toHaveBeenCalled();
+        expect(PorterUtils.buildPorterUrl).toHaveBeenCalled();
+        expect(mockClient.get).toHaveBeenCalled();
+        expect(PorterUtils.handleCommandError).not.toHaveBeenCalled();
+        expect(logSpy).toHaveBeenNthCalledWith(2, `Project name: ${projectName}`);
+        expect(logSpy).toHaveBeenNthCalledWith(3, 'Download last port report: Not generated');
+        expect(logSpy).toHaveBeenNthCalledWith(4, 'Download last port artifacts: Not generated');
+    }));
+    it('should successfully retrieve the project details and log this to the console', () => __awaiter(void 0, void 0, void 0, function* () {
+        const mockReportLink = 'mock-report-link';
+        const mockArtifactsLink = 'mock-artifacts-link';
+        const mockGetResponse = {
+            projectid: '1234-5678-abcd-efgh',
+            'last-artifacts-link': mockArtifactsLink,
+            'last-report-link': mockReportLink,
+        };
+        mockResponse = {
+            data: mockGetResponse,
+            status: 200,
+        };
+        const { default: createGetCommand } = require('./get');
+        const program = createGetCommand();
+        yield program.parseAsync(['project', 'getProject']);
+        expect(PorterUtils.throwErrorIfNotLoggedIn).toHaveBeenCalled();
+        expect(PorterUtils.buildPorterUrl).toHaveBeenCalled();
+        expect(mockClient.get).toHaveBeenCalled();
+        expect(PorterUtils.handleCommandError).not.toHaveBeenCalled();
+        expect(logSpy).toHaveBeenNthCalledWith(2, `Project name: ${projectName}`);
+        expect(logSpy).toHaveBeenNthCalledWith(3, `Download last port report: ${mockReportLink}`);
+        expect(logSpy).toHaveBeenNthCalledWith(4, `Download last port artifacts: ${mockArtifactsLink}`);
+    }));
+});

package/lib/porter/project/projectCommand.d.ts

@@ -0,0 +1,3 @@
+import { Command } from 'commander';
+declare const createProjectCommand: () => Command;
+export default createProjectCommand;