@squiz/dxp-cli-next 5.30.0-develop.3 → 5.30.0-develop.4

package/lib/cdp/instance/activate/activate.js

@@ -37,6 +37,9 @@ const createActivateCommand = () => {
             write(chalk_1.default.red(str));
         },
     })
+        .addOption(new commander_1.Option('-r, --region <string>', 'Region for your cdp instance to be activated e.g. au')
+        .choices(['au', 'us', 'uk'])
+        .default(''))
         .action((options) => __awaiter(void 0, void 0, void 0, function* () {
         yield (0, utils_1.throwErrorIfNotLoggedIn)(activateCommand);
         console.log('');
@@ -47,10 +50,22 @@ const createActivateCommand = () => {
                     return status < 400 || status === 404;
                 },
             });
-            const scvDeployBaseUrl = yield (0, utils_1.buildDXPUrl)(constants_1.SCV_DEPLOY_SERVICE_NAME);
-            const apiUrl = `${scvDeployBaseUrl.dxpUrl}/${scvDeployBaseUrl.tenant}`;
+            const scvDeployBaseUrl = yield (0, utils_1.buildDXPUrl)(constants_1.SCV_DEPLOY_SERVICE_NAME, '', '', options.region);
+            let apiUrl = '';
+            const tenant = scvDeployBaseUrl.tenant;
+            const hasRegion = options.region !== '';
+            // If the region is provided, use the region specific URL
+            // Otherwise, we utilize service to automatically retrieve the region for us
+            if (hasRegion) {
+                apiUrl = `${scvDeployBaseUrl.dxpUrl}/${tenant}`;
+            }
+            else {
+                apiUrl = `${scvDeployBaseUrl.dxpUrl}`;
+            }
             const getDeployResponse = (yield apiService.client
-                .get(apiUrl)
+                .get(apiUrl, {
+                headers: Object.assign({ 'Content-Type': 'application/json' }, (!hasRegion && { 'x-dxp-tenant': tenant })),
+            })
                 .catch((err) => {
                 (0, utils_1.logDebug)(`RAW ERROR: ${JSON.stringify(err)}`);
                 if (err.response && err.response.status != 404) {
@@ -62,7 +77,9 @@ const createActivateCommand = () => {
             }
             (0, utils_1.logDebug)(`PUT ${apiUrl}`);
             const activateInstanceAndDeploySchemaResponse = (yield apiService.client
-                .put(apiUrl)
+                .put(apiUrl, {
+                headers: Object.assign({ 'Content-Type': 'application/json' }, (!hasRegion && { 'x-dxp-tenant': tenant })),
+            })
                 .catch((err) => {
                 (0, utils_1.logDebug)(`RAW ERROR: ${JSON.stringify(err)}`);
                 if (err.response) {

package/lib/cdp/instance/activate/activate.spec.js

@@ -42,7 +42,7 @@ const activate = __importStar(require("./activate"));
 const utils = __importStar(require("../../utils"));
 const axios_1 = __importDefault(require("axios"));
 jest.mock('axios');
-const mockDomainWithPath = 'http://localhost:9999/__dxp/us/scv-deploy/myTenant';
+const mockDomainWithPath = 'http://localhost:9999/__dxp/service/scv-deploy/myTenant';
 function createMockArgs() {
     return ['node', 'dxp-cli', 'cdp', 'instance', 'activate'];
 }
@@ -65,103 +65,216 @@ describe('cdpInstanceCommand', () => {
     afterEach(() => {
         jest.clearAllMocks();
     });
-    it('should throw error when tenant exists', () => __awaiter(void 0, void 0, void 0, function* () {
-        const mockedAxiosInstance = {
-            get: jest.fn().mockResolvedValue({ status: 200 }),
-            interceptors: {
-                request: { use: jest.fn() },
-                response: { use: jest.fn() },
-            },
-        };
-        axios_1.default.create.mockReturnValue(mockedAxiosInstance);
-        jest.spyOn(utils, 'buildDXPUrl').mockResolvedValue({
-            dxpUrl: `${mockDomain}/__dxp/us/scv-deploy`,
-            tenant: mockTenant,
-        });
-        const mockPath = (0, utils_1.createMockUrl)(mockRegion, mockTenant);
-        expect(`${mockDomain}${mockPath}`).toEqual(mockDomainWithPath);
-        const program = (0, activate_1.default)();
-        yield program.parseAsync(createMockArgs());
-        expect(errorSpy).toHaveBeenCalledWith(expect.stringContaining(activate_1.errorMessage));
-    }));
-    it('deploys a default schema and activate an instance', () => __awaiter(void 0, void 0, void 0, function* () {
-        jest.spyOn(utils, 'buildDXPUrl').mockResolvedValue({
-            dxpUrl: `${mockDomain}/__dxp/us/scv-deploy`,
-            tenant: mockTenant,
-        });
-        jest.spyOn(utils, 'pollForDeployedSchema').mockResolvedValue({});
-        const mockedAxiosInstance = {
-            get: jest.fn().mockResolvedValue({ status: 404 }),
-            put: jest
-                .fn()
-                .mockResolvedValue({ status: 200, data: { message: 'Success' } }),
-            interceptors: {
-                request: { use: jest.fn() },
-                response: { use: jest.fn() },
-            },
-        };
-        axios_1.default.create.mockReturnValue(mockedAxiosInstance);
-        const mockPath = (0, utils_1.createMockUrl)(mockRegion, mockTenant);
-        expect(`${mockDomain}${mockPath}`).toEqual(mockDomainWithPath);
-        const program = (0, activate_1.default)();
-        yield program.parseAsync(createMockArgs());
-        expect(mockedAxiosInstance.put).toHaveBeenCalledWith(`${mockDomain}${mockPath}`);
-        // Note the output from the spinner doesn't seem to appear here but this still tests that it
-        // ran without displaying an error.
-        expect(logSpy).toHaveBeenNthCalledWith(1, '');
-        expect(logSpy).toHaveBeenNthCalledWith(2, '');
-        expect(logSpy).toHaveBeenNthCalledWith(3, 'Your Schema has been deployed and instance has been activated.');
-        expect(logSpy).toHaveBeenNthCalledWith(4, '');
-        expect(errorSpy).not.toHaveBeenCalled();
-    }));
-    it('should throw error when trying to activate an instance currently', () => __awaiter(void 0, void 0, void 0, function* () {
-        jest.spyOn(utils, 'buildDXPUrl').mockResolvedValue({
-            dxpUrl: `${mockDomain}/__dxp/us/scv-deploy`,
-            tenant: mockTenant,
-        });
-        jest.spyOn(utils, 'pollForDeployedSchema').mockResolvedValue({});
-        const mockedAxios = axios_1.default;
-        //GET request (404)
-        mockedAxios.get.mockResolvedValueOnce({
-            status: 404,
-            data: { status: deploy_const_1.CDP_DEPLOY_STATUS_ERROR },
-        });
-        // PUT request (409)
-        mockedAxios.put.mockResolvedValueOnce({
-            status: 409,
-            data: {
-                tenantid: 'myTenant',
-                version: 'unknown',
-                stack: 'stackName',
-                status: deploy_const_1.CDP_DEPLOY_STATUS_DEPLOYING,
-            },
-        });
-        axios_1.default.create.mockReturnValue(mockedAxios);
-        const mockPath = (0, utils_1.createMockUrl)(mockRegion, mockTenant);
-        expect(`${mockDomain}${mockPath}`).toEqual(mockDomainWithPath);
-        const program = (0, activate_1.default)();
-        yield program.parseAsync(createMockArgs());
-        expect(mockedAxios.put).toHaveBeenCalledWith(`${mockDomain}${mockPath}`);
-        expect(errorSpy).toHaveBeenCalledWith(expect.stringContaining('Currently activating instance. Please try again later.'));
-    }));
-    it('should throw error when get tenant returns 403', () => __awaiter(void 0, void 0, void 0, function* () {
-        const mockedAxiosInstance = {
-            get: jest.fn().mockRejectedValue({
-                response: { status: 403, data: {} },
-            }),
-            interceptors: {
-                request: { use: jest.fn() },
-                response: { use: jest.fn() },
-            },
-        };
-        axios_1.default.create.mockReturnValue(mockedAxiosInstance);
-        jest.spyOn(utils, 'buildDXPUrl').mockResolvedValue({
-            dxpUrl: `${mockDomain}/__dxp/us/scv-deploy`,
-            tenant: mockTenant,
-        });
-        const handleActivateErrorSpy = jest.spyOn(activate, 'handleActivateError');
-        const program = (0, activate_1.default)();
-        yield program.parseAsync(createMockArgs());
-        expect(handleActivateErrorSpy).toHaveBeenCalledWith(403, {});
-    }));
+    describe('when region is provided', () => {
+        it.each(['au', 'us', 'uk'])('should throw error when tenant exists for %s region', (region) => __awaiter(void 0, void 0, void 0, function* () {
+            const mockedAxiosInstance = {
+                get: jest.fn().mockResolvedValue({ status: 200 }),
+                interceptors: {
+                    request: { use: jest.fn() },
+                    response: { use: jest.fn() },
+                },
+            };
+            axios_1.default.create.mockReturnValue(mockedAxiosInstance);
+            jest.spyOn(utils, 'buildDXPUrl').mockResolvedValue({
+                dxpUrl: `${mockDomain}/__dxp/${region}/scv-deploy`,
+                tenant: mockTenant,
+            });
+            const program = (0, activate_1.default)();
+            yield program.parseAsync((0, utils_1.createMockActivateArgs)(region));
+            expect(errorSpy).toHaveBeenCalledWith(expect.stringContaining(activate_1.errorMessage));
+        }));
+        it.each(['au', 'us', 'uk'])('deploys a default schema and activate an instance for %s region', (region) => __awaiter(void 0, void 0, void 0, function* () {
+            jest.spyOn(utils, 'buildDXPUrl').mockResolvedValue({
+                dxpUrl: `${mockDomain}/__dxp/${region}/scv-deploy`,
+                tenant: mockTenant,
+            });
+            jest.spyOn(utils, 'pollForDeployedSchema').mockResolvedValue({});
+            const mockedAxiosInstance = {
+                get: jest.fn().mockResolvedValue({ status: 404 }),
+                put: jest
+                    .fn()
+                    .mockResolvedValue({ status: 200, data: { message: 'Success' } }),
+                interceptors: {
+                    request: { use: jest.fn() },
+                    response: { use: jest.fn() },
+                },
+            };
+            axios_1.default.create.mockReturnValue(mockedAxiosInstance);
+            const program = (0, activate_1.default)();
+            yield program.parseAsync((0, utils_1.createMockActivateArgs)(region));
+            expect(mockedAxiosInstance.put).toHaveBeenCalledWith(`http://localhost:9999/__dxp/${region}/scv-deploy/${mockTenant}`, {
+                headers: {
+                    'Content-Type': 'application/json',
+                },
+            });
+            expect(logSpy).toHaveBeenNthCalledWith(1, '');
+            expect(logSpy).toHaveBeenNthCalledWith(2, '');
+            expect(logSpy).toHaveBeenNthCalledWith(3, 'Your Schema has been deployed and instance has been activated.');
+            expect(logSpy).toHaveBeenNthCalledWith(4, '');
+            expect(errorSpy).not.toHaveBeenCalled();
+        }));
+        it.each(['au', 'us', 'uk'])('should throw error when trying to activate an instance currently for %s region', (region) => __awaiter(void 0, void 0, void 0, function* () {
+            jest.spyOn(utils, 'buildDXPUrl').mockResolvedValue({
+                dxpUrl: `${mockDomain}/__dxp/${region}/scv-deploy`,
+                tenant: mockTenant,
+            });
+            jest.spyOn(utils, 'pollForDeployedSchema').mockResolvedValue({});
+            const mockedAxios = axios_1.default;
+            //GET request (404)
+            mockedAxios.get.mockResolvedValueOnce({
+                status: 404,
+                data: { status: deploy_const_1.CDP_DEPLOY_STATUS_ERROR },
+            });
+            // PUT request (409)
+            mockedAxios.put.mockResolvedValueOnce({
+                status: 409,
+                data: {
+                    tenantid: 'myTenant',
+                    version: 'unknown',
+                    stack: 'stackName',
+                    status: deploy_const_1.CDP_DEPLOY_STATUS_DEPLOYING,
+                },
+            });
+            axios_1.default.create.mockReturnValue(mockedAxios);
+            const program = (0, activate_1.default)();
+            yield program.parseAsync((0, utils_1.createMockActivateArgs)(region));
+            expect(mockedAxios.put).toHaveBeenCalledWith(`http://localhost:9999/__dxp/${region}/scv-deploy/${mockTenant}`, {
+                headers: {
+                    'Content-Type': 'application/json',
+                },
+            });
+            expect(errorSpy).toHaveBeenCalledWith(expect.stringContaining('Currently activating instance. Please try again later.'));
+        }));
+        it.each(['au', 'us', 'uk'])('should throw error when get tenant returns 403 for %s region', (region) => __awaiter(void 0, void 0, void 0, function* () {
+            const mockedAxiosInstance = {
+                get: jest.fn().mockRejectedValue({
+                    response: { status: 403, data: {} },
+                }),
+                interceptors: {
+                    request: { use: jest.fn() },
+                    response: { use: jest.fn() },
+                },
+            };
+            axios_1.default.create.mockReturnValue(mockedAxiosInstance);
+            jest.spyOn(utils, 'buildDXPUrl').mockResolvedValue({
+                dxpUrl: `${mockDomain}/__dxp/${region}/scv-deploy`,
+                tenant: mockTenant,
+            });
+            const handleActivateErrorSpy = jest.spyOn(activate, 'handleActivateError');
+            const program = (0, activate_1.default)();
+            yield program.parseAsync((0, utils_1.createMockActivateArgs)(region));
+            expect(handleActivateErrorSpy).toHaveBeenCalledWith(403, {});
+        }));
+    });
+    describe('when region is not provided', () => {
+        it('should throw error when tenant exists', () => __awaiter(void 0, void 0, void 0, function* () {
+            const mockedAxiosInstance = {
+                get: jest.fn().mockResolvedValue({ status: 200 }),
+                interceptors: {
+                    request: { use: jest.fn() },
+                    response: { use: jest.fn() },
+                },
+            };
+            axios_1.default.create.mockReturnValue(mockedAxiosInstance);
+            jest.spyOn(utils, 'buildDXPUrl').mockResolvedValue({
+                dxpUrl: `${mockDomain}/__dxp/service/scv-deploy`,
+                tenant: mockTenant,
+            });
+            const mockPath = (0, utils_1.createMockUrl)(mockTenant);
+            expect(`${mockDomain}${mockPath}`).toEqual(mockDomainWithPath);
+            const program = (0, activate_1.default)();
+            yield program.parseAsync(createMockArgs());
+            expect(errorSpy).toHaveBeenCalledWith(expect.stringContaining(activate_1.errorMessage));
+        }));
+        it('deploys a default schema and activate an instance', () => __awaiter(void 0, void 0, void 0, function* () {
+            jest.spyOn(utils, 'buildDXPUrl').mockResolvedValue({
+                dxpUrl: `${mockDomain}/__dxp/service/scv-deploy`,
+                tenant: mockTenant,
+            });
+            jest.spyOn(utils, 'pollForDeployedSchema').mockResolvedValue({});
+            const mockedAxiosInstance = {
+                get: jest.fn().mockResolvedValue({ status: 404 }),
+                put: jest
+                    .fn()
+                    .mockResolvedValue({ status: 200, data: { message: 'Success' } }),
+                interceptors: {
+                    request: { use: jest.fn() },
+                    response: { use: jest.fn() },
+                },
+            };
+            axios_1.default.create.mockReturnValue(mockedAxiosInstance);
+            const mockPath = (0, utils_1.createMockUrl)(mockTenant);
+            expect(`${mockDomain}${mockPath}`).toEqual(mockDomainWithPath);
+            const program = (0, activate_1.default)();
+            yield program.parseAsync(createMockArgs());
+            expect(mockedAxiosInstance.put).toHaveBeenCalledWith('http://localhost:9999/__dxp/service/scv-deploy', {
+                headers: {
+                    'Content-Type': 'application/json',
+                    'x-dxp-tenant': 'myTenant',
+                },
+            });
+            // Note the output from the spinner doesn't seem to appear here but this still tests that it
+            // ran without displaying an error.
+            expect(logSpy).toHaveBeenNthCalledWith(1, '');
+            expect(logSpy).toHaveBeenNthCalledWith(2, '');
+            expect(logSpy).toHaveBeenNthCalledWith(3, 'Your Schema has been deployed and instance has been activated.');
+            expect(logSpy).toHaveBeenNthCalledWith(4, '');
+            expect(errorSpy).not.toHaveBeenCalled();
+        }));
+        it('should throw error when trying to activate an instance currently', () => __awaiter(void 0, void 0, void 0, function* () {
+            jest.spyOn(utils, 'buildDXPUrl').mockResolvedValue({
+                dxpUrl: `${mockDomain}/__dxp/service/scv-deploy`,
+                tenant: mockTenant,
+            });
+            jest.spyOn(utils, 'pollForDeployedSchema').mockResolvedValue({});
+            const mockedAxios = axios_1.default;
+            //GET request (404)
+            mockedAxios.get.mockResolvedValueOnce({
+                status: 404,
+                data: { status: deploy_const_1.CDP_DEPLOY_STATUS_ERROR },
+            });
+            // PUT request (409)
+            mockedAxios.put.mockResolvedValueOnce({
+                status: 409,
+                data: {
+                    tenantid: 'myTenant',
+                    version: 'unknown',
+                    stack: 'stackName',
+                    status: deploy_const_1.CDP_DEPLOY_STATUS_DEPLOYING,
+                },
+            });
+            axios_1.default.create.mockReturnValue(mockedAxios);
+            const mockPath = (0, utils_1.createMockUrl)(mockTenant);
+            expect(`${mockDomain}${mockPath}`).toEqual(mockDomainWithPath);
+            const program = (0, activate_1.default)();
+            yield program.parseAsync(createMockArgs());
+            expect(mockedAxios.put).toHaveBeenCalledWith('http://localhost:9999/__dxp/service/scv-deploy', {
+                headers: {
+                    'Content-Type': 'application/json',
+                    'x-dxp-tenant': 'myTenant',
+                },
+            });
+            expect(errorSpy).toHaveBeenCalledWith(expect.stringContaining('Currently activating instance. Please try again later.'));
+        }));
+        it('should throw error when get tenant returns 403', () => __awaiter(void 0, void 0, void 0, function* () {
+            const mockedAxiosInstance = {
+                get: jest.fn().mockRejectedValue({
+                    response: { status: 403, data: {} },
+                }),
+                interceptors: {
+                    request: { use: jest.fn() },
+                    response: { use: jest.fn() },
+                },
+            };
+            axios_1.default.create.mockReturnValue(mockedAxiosInstance);
+            jest.spyOn(utils, 'buildDXPUrl').mockResolvedValue({
+                dxpUrl: `${mockDomain}/__dxp/service/scv-deploy`,
+                tenant: mockTenant,
+            });
+            const handleActivateErrorSpy = jest.spyOn(activate, 'handleActivateError');
+            const program = (0, activate_1.default)();
+            yield program.parseAsync(createMockArgs());
+            expect(handleActivateErrorSpy).toHaveBeenCalledWith(403, {});
+        }));
+    });
 });

package/lib/cdp/schema/deploy/deploy.spec.js

@@ -60,7 +60,7 @@ describe('cdpSchemaCommand', () => {
         jest.clearAllMocks(); // Clear all spies
     });
     it('correctly handles command arguments', () => __awaiter(void 0, void 0, void 0, function* () {
-        const mockPath = (0, utils_1.createMockUrl)(mockRegion, mockTenant);
+        const mockPath = (0, utils_1.createMockUrl)(mockTenant, mockRegion);
         (0, nock_1.default)(mockDomain)
             .put(mockPath, require(path_1.default.resolve(process.cwd(), './src/__tests__/cdp/scv/schema.json')))
             .reply(200, {
@@ -81,7 +81,7 @@ describe('cdpSchemaCommand', () => {
     }));
     it('presents a formatted invalid schema message', () => __awaiter(void 0, void 0, void 0, function* () {
         const schemaFileContent = require(path_1.default.resolve(process.cwd(), mockFilePath));
-        const mockPath = (0, utils_1.createMockUrl)(mockRegion, mockTenant);
+        const mockPath = (0, utils_1.createMockUrl)(mockTenant, mockRegion);
         expect(`${mockDomain}${mockPath}`).toEqual('http://localhost:9999/__dxp/us/scv-deploy/myTenant');
         (0, nock_1.default)(mockDomain)
             .get(mockPath)
@@ -110,7 +110,7 @@ describe('cdpSchemaCommand', () => {
     }));
     it('deploys a schema', () => __awaiter(void 0, void 0, void 0, function* () {
         const schemaFileContent = require(path_1.default.resolve(process.cwd(), mockFilePath));
-        const mockPath = (0, utils_1.createMockUrl)(mockRegion, mockTenant);
+        const mockPath = (0, utils_1.createMockUrl)(mockTenant, mockRegion);
         expect(`${mockDomain}${mockPath}`).toEqual('http://localhost:9999/__dxp/us/scv-deploy/myTenant');
         (0, nock_1.default)(mockDomain)
             .get(mockPath)

package/lib/cdp/utils.d.ts

@@ -14,7 +14,8 @@ export declare function buildDXPUrl(serviceName: string, tenantID?: string, over
     tenant: string | undefined;
 }>;
 export declare function handleCommandError(error: Error): void;
-export declare function createMockUrl(region: string, path: string): string;
+export declare function createMockUrl(path: string, region?: string): string;
+export declare function createMockActivateArgs(region: string): Array<string>;
 /**
  * Poll the schema to be deployed.
  */

package/lib/cdp/utils.js

@@ -12,7 +12,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.pollForDeployedSchema = exports.createMockUrl = exports.handleCommandError = exports.buildDXPUrl = exports.throwErrorIfNotLoggedIn = exports.logDebug = void 0;
+exports.pollForDeployedSchema = exports.createMockActivateArgs = exports.createMockUrl = exports.handleCommandError = exports.buildDXPUrl = exports.throwErrorIfNotLoggedIn = exports.logDebug = void 0;
 const ApplicationStore_1 = require("../ApplicationStore");
 const chalk_1 = __importDefault(require("chalk"));
 const ApplicationConfig_1 = require("../ApplicationConfig");
@@ -43,14 +43,14 @@ function buildDXPUrl(serviceName, tenantID, override, region) {
             const existingConfig = yield (0, ApplicationConfig_1.fetchApplicationConfig)(tenantID);
             logDebug(`existingConfig: ${JSON.stringify(existingConfig)}`);
             return {
-                dxpUrl: `${existingConfig.baseUrl}/__dxp/${region || existingConfig.region}/${serviceName}`,
+                dxpUrl: `${existingConfig.baseUrl}/__dxp/${region || 'service'}/${serviceName}`,
                 tenant: existingConfig.tenant,
             };
         }
         else {
             logDebug(`Using override URL: ${override}`);
             return {
-                dxpUrl: `${override}/__dxp/${region || 'au'}/${serviceName}`,
+                dxpUrl: `${override}/__dxp/${region || 'service'}/${serviceName}`,
                 tenant: tenantID,
             };
         }
@@ -82,10 +82,14 @@ function handleCommandError(error) {
     }
 }
 exports.handleCommandError = handleCommandError;
-function createMockUrl(region, path) {
-    return `/__dxp/${region}/scv-deploy/${path}`;
+function createMockUrl(path, region) {
+    return `/__dxp/${region || 'service'}/scv-deploy/${path}`;
 }
 exports.createMockUrl = createMockUrl;
+function createMockActivateArgs(region) {
+    return ['node', 'dxp-cli', 'cdp', 'instance', 'activate', '--region', region];
+}
+exports.createMockActivateArgs = createMockActivateArgs;
 /**
  * Poll the schema to be deployed.
  */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@squiz/dxp-cli-next",
-  "version": "5.30.0-develop.3",
+  "version": "5.30.0-develop.4",
   "repository": {
     "url": "https://gitlab.squiz.net/dxp/dxp-cli-next"
   },