@squiz/dxp-cli-next 5.25.3 → 5.26.0-develop.2

package/lib/migration/utils.spec.js

@@ -0,0 +1,543 @@
+"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 fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const child_process_1 = require("child_process");
+const axios_1 = __importDefault(require("axios"));
+const ApplicationConfig_1 = require("../ApplicationConfig");
+const ApplicationStore_1 = require("../ApplicationStore");
+const ApiService_1 = require("../ApiService");
+const utils_1 = require("./utils");
+// Mock all external dependencies
+jest.mock('fs');
+jest.mock('path');
+jest.mock('child_process');
+jest.mock('axios');
+jest.mock('../ApplicationConfig');
+jest.mock('../ApplicationStore');
+jest.mock('../ApiService');
+// Mock global fetch
+const mockFetch = jest.fn();
+global.fetch = mockFetch;
+const mockFs = fs_1.default;
+const mockPath = path_1.default;
+const mockSpawn = child_process_1.spawn;
+const mockAxios = axios_1.default;
+const mockFetchApplicationConfig = ApplicationConfig_1.fetchApplicationConfig;
+const mockGetApplicationFile = ApplicationStore_1.getApplicationFile;
+const mockApiService = ApiService_1.ApiService;
+describe('Migration Utils', () => {
+    beforeEach(() => {
+        jest.clearAllMocks();
+        jest.resetAllMocks();
+    });
+    describe('handleCommandError', () => {
+        let mockCommand;
+        beforeEach(() => {
+            mockCommand = {
+                error: jest.fn(),
+            };
+        });
+        it('handles axios errors with response data message', () => {
+            const axiosError = {
+                message: 'Network Error',
+                response: {
+                    data: {
+                        message: 'Server Error',
+                        details: 'Additional details',
+                    },
+                },
+            };
+            mockAxios.isAxiosError.mockReturnValue(true);
+            (0, utils_1.handleCommandError)(mockCommand, axiosError);
+            expect(mockCommand.error).toHaveBeenCalledWith(expect.stringContaining('Network Error: Server Error - Additional details'));
+        });
+        it('handles axios errors without response data', () => {
+            const axiosError = {
+                message: 'Network Error',
+            };
+            mockAxios.isAxiosError.mockReturnValue(true);
+            (0, utils_1.handleCommandError)(mockCommand, axiosError);
+            expect(mockCommand.error).toHaveBeenCalledWith(expect.stringContaining('Network Error'));
+        });
+        it('handles regular errors with message', () => {
+            const error = new Error('Regular error');
+            mockAxios.isAxiosError.mockReturnValue(false);
+            (0, utils_1.handleCommandError)(mockCommand, error);
+            expect(mockCommand.error).toHaveBeenCalledWith(expect.stringContaining('Regular error'));
+        });
+        it('handles errors without message', () => {
+            const error = new Error();
+            error.message = '';
+            mockAxios.isAxiosError.mockReturnValue(false);
+            (0, utils_1.handleCommandError)(mockCommand, error);
+            expect(mockCommand.error).toHaveBeenCalledWith(expect.stringContaining('An unknown error occurred'));
+        });
+        it('shows stack trace in debug mode', () => {
+            const originalDebug = process.env.DEBUG;
+            process.env.DEBUG = 'true';
+            const error = new Error('Test error');
+            error.stack = 'Error stack trace';
+            mockAxios.isAxiosError.mockReturnValue(false);
+            (0, utils_1.handleCommandError)(mockCommand, error);
+            expect(mockCommand.error).toHaveBeenCalledWith('Error stack trace');
+            process.env.DEBUG = originalDebug;
+        });
+    });
+    describe('throwErrorIfNotLoggedIn', () => {
+        let mockCommand;
+        beforeEach(() => {
+            mockCommand = {
+                error: jest.fn(),
+            };
+        });
+        it('throws error when not logged in', () => __awaiter(void 0, void 0, void 0, function* () {
+            mockGetApplicationFile.mockResolvedValue(undefined);
+            yield (0, utils_1.throwErrorIfNotLoggedIn)(mockCommand);
+            expect(mockCommand.error).toHaveBeenCalledWith(expect.stringContaining('You must login to interact with the migration service'));
+        }));
+        it('does not throw error when logged in', () => __awaiter(void 0, void 0, void 0, function* () {
+            mockGetApplicationFile.mockResolvedValue('session-cookie');
+            yield (0, utils_1.throwErrorIfNotLoggedIn)(mockCommand);
+            expect(mockCommand.error).not.toHaveBeenCalled();
+        }));
+    });
+    describe('buildMigrationUrl', () => {
+        it('builds url without override', () => __awaiter(void 0, void 0, void 0, function* () {
+            const mockConfig = {
+                baseUrl: 'https://example.com',
+                tenant: 'test-tenant',
+                region: 'au',
+            };
+            mockFetchApplicationConfig.mockResolvedValue(mockConfig);
+            const result = yield (0, utils_1.buildMigrationUrl)('tenant-id');
+            expect(result).toBe('https://example.com/__dxp/service/aiapps/migration');
+            expect(mockFetchApplicationConfig).toHaveBeenCalledWith('tenant-id');
+        }));
+        it('returns override url when provided', () => __awaiter(void 0, void 0, void 0, function* () {
+            const overrideUrl = 'https://override.com';
+            const result = yield (0, utils_1.buildMigrationUrl)('tenant-id', overrideUrl);
+            expect(result).toBe(overrideUrl);
+            expect(mockFetchApplicationConfig).not.toHaveBeenCalled();
+        }));
+    });
+    describe('validateAxiosStatus', () => {
+        it('returns true for successful status codes', () => {
+            expect((0, utils_1.validateAxiosStatus)(200)).toBe(true);
+            expect((0, utils_1.validateAxiosStatus)(201)).toBe(true);
+            expect((0, utils_1.validateAxiosStatus)(399)).toBe(true);
+        });
+        it('returns false for error status codes', () => {
+            expect((0, utils_1.validateAxiosStatus)(400)).toBe(false);
+            expect((0, utils_1.validateAxiosStatus)(404)).toBe(false);
+            expect((0, utils_1.validateAxiosStatus)(500)).toBe(false);
+        });
+    });
+    describe('validateExportFolder', () => {
+        beforeEach(() => {
+            mockPath.join.mockImplementation((...paths) => paths.join('/'));
+        });
+        it('validates successful export folder structure', () => {
+            mockFs.existsSync.mockImplementation(filePath => {
+                return [
+                    '/export/path',
+                    '/export/path/export',
+                    '/export/path/export/export.xml',
+                ].includes(filePath);
+            });
+            mockFs.statSync.mockImplementation(filePath => ({
+                isDirectory: () => filePath !== '/export/path/export/export.xml',
+                isFile: () => filePath === '/export/path/export/export.xml',
+            }));
+            expect(() => (0, utils_1.validateExportFolder)('/export/path')).not.toThrow();
+        });
+        it('throws error when export folder does not exist', () => {
+            mockFs.existsSync.mockReturnValue(false);
+            expect(() => (0, utils_1.validateExportFolder)('/nonexistent')).toThrow('Export folder does not exist: /nonexistent');
+        });
+        it('throws error when export path is not a directory', () => {
+            mockFs.existsSync.mockReturnValue(true);
+            mockFs.statSync.mockReturnValue({
+                isDirectory: () => false,
+                isFile: () => true,
+            });
+            expect(() => (0, utils_1.validateExportFolder)('/export/file.txt')).toThrow('Export path is not a directory: /export/file.txt');
+        });
+        it('throws error when nested export folder does not exist', () => {
+            mockFs.existsSync.mockImplementation(filePath => filePath === '/export/path');
+            mockFs.statSync.mockReturnValue({
+                isDirectory: () => true,
+            });
+            expect(() => (0, utils_1.validateExportFolder)('/export/path')).toThrow('Nested export folder does not exist: /export/path/export');
+        });
+        it('throws error when export.xml does not exist', () => {
+            mockFs.existsSync.mockImplementation(filePath => {
+                return ['/export/path', '/export/path/export'].includes(filePath);
+            });
+            mockFs.statSync.mockReturnValue({
+                isDirectory: () => true,
+            });
+            expect(() => (0, utils_1.validateExportFolder)('/export/path')).toThrow('export.xml file does not exist in: /export/path/export');
+        });
+        it('throws error when export.xml is not a file', () => {
+            mockFs.existsSync.mockReturnValue(true);
+            mockFs.statSync.mockImplementation(filePath => ({
+                isDirectory: () => filePath !== '/export/path/export/export.xml',
+                isFile: () => false,
+            }));
+            expect(() => (0, utils_1.validateExportFolder)('/export/path')).toThrow('export.xml is not a valid file: /export/path/export/export.xml');
+        });
+        it('throws error when nested export path is not a directory', () => {
+            mockFs.existsSync.mockReturnValue(true);
+            mockFs.statSync.mockImplementation(filePath => {
+                if (filePath === '/export/path') {
+                    return { isDirectory: () => true };
+                }
+                else if (filePath === '/export/path/export') {
+                    return { isDirectory: () => false, isFile: () => true };
+                }
+                return { isDirectory: () => false, isFile: () => false };
+            });
+            expect(() => (0, utils_1.validateExportFolder)('/export/path')).toThrow('Nested export path is not a directory: /export/path/export');
+        });
+    });
+    describe('createTarFile', () => {
+        let mockChildProcess;
+        beforeEach(() => {
+            mockChildProcess = {
+                on: jest.fn(),
+            };
+            mockSpawn.mockReturnValue(mockChildProcess);
+            mockPath.join.mockImplementation((...paths) => paths.join('/'));
+            mockPath.dirname.mockReturnValue('/parent');
+            mockPath.basename.mockReturnValue('export');
+            // Mock Date.now() to return consistent timestamp
+            jest.spyOn(Date, 'now').mockReturnValue(1234567890);
+        });
+        afterEach(() => {
+            jest.restoreAllMocks();
+        });
+        it('creates tar file successfully', () => __awaiter(void 0, void 0, void 0, function* () {
+            const promise = (0, utils_1.createTarFile)('/parent/export');
+            // Simulate successful tar creation
+            const closeCallback = mockChildProcess.on.mock.calls.find((call) => call[0] === 'close')[1];
+            closeCallback(0);
+            const result = yield promise;
+            expect(result).toBe(`${process.cwd()}/export_1234567890.tar.gz`);
+            expect(mockSpawn).toHaveBeenCalledWith('tar', [
+                '-czf',
+                `${process.cwd()}/export_1234567890.tar.gz`,
+                '-C',
+                '/parent',
+                'export',
+            ]);
+        }));
+        it('handles tar command failure', () => __awaiter(void 0, void 0, void 0, function* () {
+            const promise = (0, utils_1.createTarFile)('/parent/export');
+            // Simulate tar command failure
+            const closeCallback = mockChildProcess.on.mock.calls.find((call) => call[0] === 'close')[1];
+            closeCallback(1);
+            yield expect(promise).rejects.toThrow('tar command failed with exit code 1');
+        }));
+        it('handles spawn error', () => __awaiter(void 0, void 0, void 0, function* () {
+            const promise = (0, utils_1.createTarFile)('/parent/export');
+            // Simulate spawn error
+            const errorCallback = mockChildProcess.on.mock.calls.find((call) => call[0] === 'error')[1];
+            errorCallback(new Error('Spawn failed'));
+            yield expect(promise).rejects.toThrow('Failed to create tar file: Spawn failed');
+        }));
+    });
+    describe('getMigrationHeaders', () => {
+        it('returns headers with tenant from config', () => __awaiter(void 0, void 0, void 0, function* () {
+            const mockConfig = {
+                tenant: 'test-tenant',
+                baseUrl: 'https://example.com',
+                region: 'au',
+            };
+            mockFetchApplicationConfig.mockResolvedValue(mockConfig);
+            const result = yield (0, utils_1.getMigrationHeaders)('tenant-id');
+            expect(result).toEqual({
+                'x-dxp-tenant': 'test-tenant',
+            });
+            expect(mockFetchApplicationConfig).toHaveBeenCalledWith('tenant-id');
+        }));
+    });
+    describe('uploadFileToS3', () => {
+        beforeEach(() => {
+            mockFs.readFileSync.mockReturnValue(Buffer.from('file content'));
+            mockFetchApplicationConfig.mockResolvedValue({
+                tenant: 'test-tenant',
+                baseUrl: 'https://example.com',
+                region: 'au',
+            });
+        });
+        it('uploads file successfully', () => __awaiter(void 0, void 0, void 0, function* () {
+            const mockResponse = {
+                url: 'https://s3.amazonaws.com/uploaded-file',
+            };
+            mockFetch.mockResolvedValue(mockResponse);
+            const result = yield (0, utils_1.uploadFileToS3)('https://upload.url', '/path/to/file.tar.gz', 'tenant-id');
+            expect(result).toBe('https://s3.amazonaws.com/uploaded-file');
+            expect(mockFetch).toHaveBeenCalledWith('https://upload.url', {
+                method: 'PUT',
+                body: Buffer.from('file content'),
+                headers: {
+                    'x-dxp-tenant': 'test-tenant',
+                },
+            });
+        }));
+        it('handles file read error', () => __awaiter(void 0, void 0, void 0, function* () {
+            mockFs.readFileSync.mockImplementation(() => {
+                throw new Error('File not found');
+            });
+            yield expect((0, utils_1.uploadFileToS3)('https://upload.url', '/nonexistent/file.tar.gz')).rejects.toThrow('File not found');
+        }));
+    });
+    describe('createMigration', () => {
+        let mockApiServiceInstance;
+        let mockOptions;
+        beforeEach(() => {
+            mockApiServiceInstance = {
+                client: {
+                    post: jest.fn(),
+                },
+            };
+            mockApiService.mockImplementation(() => mockApiServiceInstance);
+            mockOptions = {
+                assetId: 'asset-123',
+                previewAssetId: 'preview-456',
+                matrixUrl: 'https://matrix.example.com',
+                tenant: 'test-tenant',
+            };
+            mockFetchApplicationConfig.mockResolvedValue({
+                tenant: 'test-tenant',
+                baseUrl: 'https://example.com',
+                region: 'au',
+            });
+        });
+        it('creates migration successfully', () => __awaiter(void 0, void 0, void 0, function* () {
+            const mockResponse = {
+                status: 201,
+                data: {
+                    assetMigration: {
+                        migrationId: 'migration-123',
+                        assetId: 'asset-123',
+                        stage: 'pending',
+                        status: 'created',
+                        xmlFilePath: '/path/to/xml',
+                        matrixUrl: 'https://matrix.example.com',
+                        previewAssetId: 'preview-456',
+                        created: 1234567890,
+                        updated: 1234567890,
+                        migrationIdAssetId: 'migration-123-asset-123',
+                    },
+                    uploadUrl: 'https://upload.s3.amazonaws.com',
+                },
+            };
+            mockApiServiceInstance.client.post.mockResolvedValue(mockResponse);
+            const result = yield (0, utils_1.createMigration)(mockOptions);
+            expect(result).toEqual(mockResponse.data);
+            expect(mockApiServiceInstance.client.post).toHaveBeenCalledWith('https://example.com/__dxp/service/aiapps/migration/migrations', {
+                assetId: 'asset-123',
+                previewAssetId: 'preview-456',
+                matrixUrl: 'https://matrix.example.com',
+            }, {
+                headers: {
+                    'Content-Type': 'application/json',
+                    'x-dxp-tenant': 'test-tenant',
+                },
+            });
+        }));
+        it('handles non-success status codes', () => __awaiter(void 0, void 0, void 0, function* () {
+            const mockResponse = {
+                status: 400,
+                data: {},
+            };
+            mockApiServiceInstance.client.post.mockResolvedValue(mockResponse);
+            yield expect((0, utils_1.createMigration)(mockOptions)).rejects.toThrow('Migration creation failed with status: 400');
+        }));
+        it('handles invalid response format - missing migrationId', () => __awaiter(void 0, void 0, void 0, function* () {
+            const mockResponse = {
+                status: 200,
+                data: {
+                    assetMigration: {
+                        assetId: 'asset-123',
+                        stage: 'pending',
+                        status: 'created',
+                    },
+                    uploadUrl: 'https://upload.s3.amazonaws.com',
+                },
+            };
+            mockApiServiceInstance.client.post.mockResolvedValue(mockResponse);
+            yield expect((0, utils_1.createMigration)(mockOptions)).rejects.toThrow('Invalid response format from migration service');
+        }));
+        it('handles missing upload URL', () => __awaiter(void 0, void 0, void 0, function* () {
+            const mockResponse = {
+                status: 200,
+                data: {
+                    assetMigration: {
+                        migrationId: 'migration-123',
+                        assetId: 'asset-123',
+                        stage: 'pending',
+                        status: 'created',
+                    },
+                },
+            };
+            mockApiServiceInstance.client.post.mockResolvedValue(mockResponse);
+            yield expect((0, utils_1.createMigration)(mockOptions)).rejects.toThrow('Upload URL not found in response');
+        }));
+        it('handles API service errors', () => __awaiter(void 0, void 0, void 0, function* () {
+            const error = new Error('Network error');
+            mockApiServiceInstance.client.post.mockRejectedValue(error);
+            yield expect((0, utils_1.createMigration)(mockOptions)).rejects.toThrow('Network error');
+        }));
+        it('handles unknown errors', () => __awaiter(void 0, void 0, void 0, function* () {
+            mockApiServiceInstance.client.post.mockRejectedValue('Unknown error');
+            yield expect((0, utils_1.createMigration)(mockOptions)).rejects.toThrow('Failed to create migration: Unknown error');
+        }));
+    });
+    describe('getMigration', () => {
+        let mockApiServiceInstance;
+        let mockOptions;
+        beforeEach(() => {
+            mockApiServiceInstance = {
+                client: {
+                    get: jest.fn(),
+                },
+            };
+            mockApiService.mockImplementation(() => mockApiServiceInstance);
+            mockOptions = {
+                migrationId: 'migration-123',
+                assetId: 'asset-456',
+                tenant: 'test-tenant',
+            };
+            mockFetchApplicationConfig.mockResolvedValue({
+                tenant: 'test-tenant',
+                baseUrl: 'https://example.com',
+                region: 'au',
+            });
+        });
+        it('gets migration successfully', () => __awaiter(void 0, void 0, void 0, function* () {
+            const mockResponse = {
+                status: 200,
+                data: {
+                    migrationId: 'migration-123',
+                    assetId: 'asset-456',
+                    stage: 'completed',
+                    status: 'success',
+                    stageDetails: 'Migration completed successfully',
+                    previewPageAssetId: 'preview-789',
+                    componentsTarDownloadUrl: 'https://download.example.com/components.zip',
+                },
+            };
+            mockApiServiceInstance.client.get.mockResolvedValue(mockResponse);
+            const result = yield (0, utils_1.getMigration)(mockOptions);
+            expect(result).toEqual({
+                migrationId: 'migration-123',
+                assetId: 'asset-456',
+                stage: 'completed',
+                status: 'success',
+                stageDetails: 'Migration completed successfully',
+                previewPageAssetId: 'preview-789',
+                componentsTarDownloadUrl: 'https://download.example.com/components.zip',
+            });
+            expect(mockApiServiceInstance.client.get).toHaveBeenCalledWith('https://example.com/__dxp/service/aiapps/migration/migrations/migration-123/assets/asset-456', {
+                headers: {
+                    'Content-Type': 'application/json',
+                    'x-dxp-tenant': 'test-tenant',
+                },
+            });
+        }));
+        it('gets migration with override URL', () => __awaiter(void 0, void 0, void 0, function* () {
+            const optionsWithOverride = Object.assign(Object.assign({}, mockOptions), { overrideUrl: 'https://custom.migration.url' });
+            const mockResponse = {
+                status: 200,
+                data: {
+                    migrationId: 'migration-123',
+                    assetId: 'asset-456',
+                    stage: 'pending',
+                    status: 'processing',
+                },
+            };
+            mockApiServiceInstance.client.get.mockResolvedValue(mockResponse);
+            const result = yield (0, utils_1.getMigration)(optionsWithOverride);
+            expect(result.migrationId).toBe('migration-123');
+            expect(result.assetId).toBe('asset-456');
+            expect(mockApiServiceInstance.client.get).toHaveBeenCalledWith('https://custom.migration.url/migrations/migration-123/assets/asset-456', expect.any(Object));
+        }));
+        it('handles non-success status codes', () => __awaiter(void 0, void 0, void 0, function* () {
+            const mockResponse = {
+                status: 404,
+                data: {},
+            };
+            mockApiServiceInstance.client.get.mockResolvedValue(mockResponse);
+            yield expect((0, utils_1.getMigration)(mockOptions)).rejects.toThrow('Failed to get migration: 404');
+        }));
+        it('handles missing response data', () => __awaiter(void 0, void 0, void 0, function* () {
+            const mockResponse = {
+                status: 200,
+                data: null,
+            };
+            mockApiServiceInstance.client.get.mockResolvedValue(mockResponse);
+            yield expect((0, utils_1.getMigration)(mockOptions)).rejects.toThrow('No data returned from migration service');
+        }));
+        it('handles API service errors', () => __awaiter(void 0, void 0, void 0, function* () {
+            const error = new Error('Network error');
+            mockApiServiceInstance.client.get.mockRejectedValue(error);
+            yield expect((0, utils_1.getMigration)(mockOptions)).rejects.toThrow('Network error');
+        }));
+        it('handles unknown errors', () => __awaiter(void 0, void 0, void 0, function* () {
+            mockApiServiceInstance.client.get.mockRejectedValue('Unknown error');
+            yield expect((0, utils_1.getMigration)(mockOptions)).rejects.toThrow('Failed to get migration: Unknown error');
+        }));
+        it('works without optional fields in response', () => __awaiter(void 0, void 0, void 0, function* () {
+            const mockResponse = {
+                status: 200,
+                data: {
+                    migrationId: 'migration-123',
+                    assetId: 'asset-456',
+                    stage: 'pending',
+                    status: 'processing',
+                    // No optional fields: stageDetails, previewPageAssetId, componentsTarDownloadUrl
+                },
+            };
+            mockApiServiceInstance.client.get.mockResolvedValue(mockResponse);
+            const result = yield (0, utils_1.getMigration)(mockOptions);
+            expect(result).toEqual({
+                migrationId: 'migration-123',
+                assetId: 'asset-456',
+                stage: 'pending',
+                status: 'processing',
+                stageDetails: undefined,
+                previewPageAssetId: undefined,
+                componentsTarDownloadUrl: undefined,
+            });
+        }));
+        it('constructs correct URL path', () => __awaiter(void 0, void 0, void 0, function* () {
+            const mockResponse = {
+                status: 200,
+                data: {
+                    migrationId: 'migration-123',
+                    assetId: 'asset-456',
+                    stage: 'completed',
+                    status: 'success',
+                },
+            };
+            mockApiServiceInstance.client.get.mockResolvedValue(mockResponse);
+            yield (0, utils_1.getMigration)(mockOptions);
+            expect(mockApiServiceInstance.client.get).toHaveBeenCalledWith('https://example.com/__dxp/service/aiapps/migration/migrations/migration-123/assets/asset-456', expect.any(Object));
+        }));
+    });
+});

package/package.json

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