@squiz/dxp-cli-next 5.33.0-develop.2 → 5.33.0-develop.4

package/lib/migration/utils/getMigration.spec.js

@@ -91,13 +91,16 @@ describe('getMigration', () => {
         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 = {
+    it('handles API errors (4xx/5xx status codes)', () => __awaiter(void 0, void 0, void 0, function* () {
+        // In production, Axios throws AxiosError for 4xx/5xx status codes
+        const axiosError = new Error('Request failed with status code 404');
+        axiosError.isAxiosError = true;
+        axiosError.response = {
             status: 404,
-            data: {},
+            data: { message: 'Not Found' },
         };
-        mockApiServiceInstance.client.get.mockResolvedValue(mockResponse);
-        yield expect((0, getMigration_1.getMigration)(mockOptions)).rejects.toThrow('Failed to get migration: 404');
+        mockApiServiceInstance.client.get.mockRejectedValue(axiosError);
+        yield expect((0, getMigration_1.getMigration)(mockOptions)).rejects.toThrow('Request failed with status code 404');
     }));
     it('handles missing response data', () => __awaiter(void 0, void 0, void 0, function* () {
         const mockResponse = {
@@ -112,9 +115,10 @@ describe('getMigration', () => {
         mockApiServiceInstance.client.get.mockRejectedValue(error);
         yield expect((0, getMigration_1.getMigration)(mockOptions)).rejects.toThrow('Network error');
     }));
-    it('handles unknown errors', () => __awaiter(void 0, void 0, void 0, function* () {
+    it('propagates rejected values as-is', () => __awaiter(void 0, void 0, void 0, function* () {
+        // Non-Error values are propagated without wrapping
         mockApiServiceInstance.client.get.mockRejectedValue('Unknown error');
-        yield expect((0, getMigration_1.getMigration)(mockOptions)).rejects.toThrow('Failed to get migration: Unknown error');
+        yield expect((0, getMigration_1.getMigration)(mockOptions)).rejects.toBe('Unknown error');
     }));
     it('works without optional fields in response', () => __awaiter(void 0, void 0, void 0, function* () {
         const mockResponse = {
@@ -154,3 +158,138 @@ describe('getMigration', () => {
         expect(mockApiServiceInstance.client.get).toHaveBeenCalledWith('https://example.com/__dxp/service/aiapps/migration/migrations/migration-123/assets/asset-456', expect.any(Object));
     }));
 });
+describe('batchGetMigration', () => {
+    let mockApiServiceInstance;
+    let mockOptions;
+    const mockApiService = ApiService_1.ApiService;
+    const mockFetchApplicationConfig = ApplicationConfig_1.fetchApplicationConfig;
+    beforeEach(() => {
+        mockApiServiceInstance = {
+            client: {
+                get: jest.fn(),
+            },
+        };
+        mockApiService.mockImplementation(() => mockApiServiceInstance);
+        mockOptions = {
+            migrationId: 'migration-123',
+            tenant: 'test-tenant',
+        };
+        mockFetchApplicationConfig.mockResolvedValue({
+            tenant: 'test-tenant',
+            baseUrl: 'https://example.com',
+            region: 'au',
+        });
+    });
+    afterEach(() => {
+        jest.clearAllMocks();
+    });
+    it('gets batch migration summary successfully', () => __awaiter(void 0, void 0, void 0, function* () {
+        const mockResponse = {
+            status: 200,
+            data: {
+                migrationId: 'migration-123',
+                created: 1704067200000,
+                expiry: 1704153600000,
+                preview: {
+                    complete: { assetIds: ['asset-1', 'asset-2'] },
+                    running: { assetIds: ['asset-3'] },
+                },
+            },
+        };
+        mockApiServiceInstance.client.get.mockResolvedValue(mockResponse);
+        const result = yield (0, getMigration_1.batchGetMigration)(mockOptions);
+        expect(result).toEqual({
+            migrationId: 'migration-123',
+            created: 1704067200000,
+            expiry: 1704153600000,
+            preview: {
+                complete: { assetIds: ['asset-1', 'asset-2'] },
+                running: { assetIds: ['asset-3'] },
+            },
+        });
+        expect(mockApiServiceInstance.client.get).toHaveBeenCalledWith('https://example.com/__dxp/service/aiapps/migration/migrations/migration-123', {
+            headers: {
+                'Content-Type': 'application/json',
+                'x-dxp-tenant': 'test-tenant',
+            },
+        });
+    }));
+    it('gets batch 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',
+                created: 1704067200000,
+                expiry: 1704153600000,
+            },
+        };
+        mockApiServiceInstance.client.get.mockResolvedValue(mockResponse);
+        const result = yield (0, getMigration_1.batchGetMigration)(optionsWithOverride);
+        expect(result.migrationId).toBe('migration-123');
+        expect(mockApiServiceInstance.client.get).toHaveBeenCalledWith('https://custom.migration.url/migrations/migration-123', expect.any(Object));
+    }));
+    it('handles API errors (4xx/5xx status codes)', () => __awaiter(void 0, void 0, void 0, function* () {
+        const axiosError = new Error('Request failed with status code 404');
+        axiosError.isAxiosError = true;
+        axiosError.response = {
+            status: 404,
+            data: { message: 'Not Found' },
+        };
+        mockApiServiceInstance.client.get.mockRejectedValue(axiosError);
+        yield expect((0, getMigration_1.batchGetMigration)(mockOptions)).rejects.toThrow('Request failed with status code 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, getMigration_1.batchGetMigration)(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, getMigration_1.batchGetMigration)(mockOptions)).rejects.toThrow('Network error');
+    }));
+    it('propagates rejected values as-is', () => __awaiter(void 0, void 0, void 0, function* () {
+        mockApiServiceInstance.client.get.mockRejectedValue('Unknown error');
+        yield expect((0, getMigration_1.batchGetMigration)(mockOptions)).rejects.toBe('Unknown error');
+    }));
+    it('constructs correct URL path without assetId', () => __awaiter(void 0, void 0, void 0, function* () {
+        const mockResponse = {
+            status: 200,
+            data: {
+                migrationId: 'migration-123',
+                created: 1704067200000,
+                expiry: 1704153600000,
+            },
+        };
+        mockApiServiceInstance.client.get.mockResolvedValue(mockResponse);
+        yield (0, getMigration_1.batchGetMigration)(mockOptions);
+        expect(mockApiServiceInstance.client.get).toHaveBeenCalledWith('https://example.com/__dxp/service/aiapps/migration/migrations/migration-123', expect.any(Object));
+    }));
+    it('handles response with multiple stages', () => __awaiter(void 0, void 0, void 0, function* () {
+        const mockResponse = {
+            status: 200,
+            data: {
+                migrationId: 'migration-123',
+                created: 1704067200000,
+                expiry: 1704153600000,
+                'export-to-json': {
+                    complete: { assetIds: ['asset-1'] },
+                },
+                preview: {
+                    running: { assetIds: ['asset-2'] },
+                    failed: { assetIds: ['asset-3'] },
+                },
+                morph: {
+                    'awaiting-confirmation': { assetIds: ['asset-4'] },
+                },
+            },
+        };
+        mockApiServiceInstance.client.get.mockResolvedValue(mockResponse);
+        const result = yield (0, getMigration_1.batchGetMigration)(mockOptions);
+        expect(result).toEqual(mockResponse.data);
+    }));
+});

package/lib/migration/utils/index.d.ts

@@ -7,3 +7,4 @@ export * from './setMigrationSettings';
 export * from './revertMigration';
 export * from './loadStageOptionsFromFile';
 export * from './promptForMorphConfirmation';
+export * from './markComponentsDeployed';

package/lib/migration/utils/index.js

@@ -23,3 +23,4 @@ __exportStar(require("./setMigrationSettings"), exports);
 __exportStar(require("./revertMigration"), exports);
 __exportStar(require("./loadStageOptionsFromFile"), exports);
 __exportStar(require("./promptForMorphConfirmation"), exports);
+__exportStar(require("./markComponentsDeployed"), exports);

package/lib/migration/utils/listMigrations.spec.js

@@ -11,6 +11,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 Object.defineProperty(exports, "__esModule", { value: true });
 const mockClient = { get: jest.fn() };
 const ApplicationConfig_1 = require("../../ApplicationConfig");
+const types_1 = require("../types");
 const listMigrations_1 = require("./listMigrations");
 jest.mock('path');
 jest.mock('child_process');
@@ -31,24 +32,24 @@ describe('listMigration', () => {
         {
             migrationId: 'migration-1',
             assetId: 'asset-1',
-            stage: 'completed',
-            status: 'success',
+            stage: types_1.MigrationStage.morph,
+            status: types_1.MigrationStatus.complete,
             created: 100,
             updated: 200,
         },
         {
             migrationId: 'migration-2',
             assetId: 'asset-2',
-            stage: 'completed',
-            status: 'success',
+            stage: types_1.MigrationStage.morph,
+            status: types_1.MigrationStatus.complete,
             created: 100,
             updated: 200,
         },
         {
             migrationId: 'migration-3',
             assetId: 'asset-3',
-            stage: 'completed',
-            status: 'success',
+            stage: types_1.MigrationStage.morph,
+            status: types_1.MigrationStatus.complete,
             created: 100,
             updated: 200,
         },

package/lib/migration/utils/loadAssetIdsFromFile.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Loads the asset/cct IDs from a file.
+ * Asset Ids can be used for bulk migrations.
+ * CCT Ids can be used for pre-migrations or to skip CCTs in migrations.
+ * @param filePath - The path to the file containing the asset IDs.
+ * @param assetType - The type of asset to load the IDs for - assets or ccts. Defaults to ccts.
+ * @returns The asset/cct IDs.
+ */
+export declare const loadAssetIdsFromFile: (filePath?: string, assetType?: 'asset' | 'cct') => string[] | undefined;

package/lib/migration/utils/loadAssetIdsFromFile.js

@@ -0,0 +1,40 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadAssetIdsFromFile = void 0;
+const fs_1 = __importDefault(require("fs"));
+/**
+ * Loads the asset/cct IDs from a file.
+ * Asset Ids can be used for bulk migrations.
+ * CCT Ids can be used for pre-migrations or to skip CCTs in migrations.
+ * @param filePath - The path to the file containing the asset IDs.
+ * @param assetType - The type of asset to load the IDs for - assets or ccts. Defaults to ccts.
+ * @returns The asset/cct IDs.
+ */
+const loadAssetIdsFromFile = (filePath, assetType = 'cct') => {
+    if (!filePath) {
+        return undefined;
+    }
+    try {
+        if (!fs_1.default.existsSync(filePath)) {
+            throw new Error(`${assetType.toUpperCase()} IDs file not found: ${filePath}`);
+        }
+        const fileContent = fs_1.default.readFileSync(filePath, 'utf8');
+        const assetIds = JSON.parse(fileContent);
+        if (!Array.isArray(assetIds) ||
+            assetIds.some(id => typeof id !== 'string' || !id.trim()) ||
+            assetIds.length === 0) {
+            throw new Error(`${assetType.toUpperCase()} IDs file must contain a valid array of strings representing ${assetType.toUpperCase()} IDs with at least one ${assetType.toUpperCase()} ID`);
+        }
+        return assetIds;
+    }
+    catch (error) {
+        if (error instanceof Error) {
+            throw new Error(`Failed to load ${assetType.toUpperCase()} IDs from file: ${error.message}`);
+        }
+        throw new Error(`Failed to load ${assetType.toUpperCase()} IDs from file: ${error}`);
+    }
+};
+exports.loadAssetIdsFromFile = loadAssetIdsFromFile;

package/lib/migration/utils/loadAssetIdsFromFile.spec.d.ts

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

package/lib/migration/utils/{loadCctIdsFromFile.spec.js → loadAssetIdsFromFile.spec.js}

@@ -4,15 +4,15 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 const fs_1 = __importDefault(require("fs"));
-const loadCctIdsFromFile_1 = require("./loadCctIdsFromFile");
+const loadAssetIdsFromFile_1 = require("./loadAssetIdsFromFile");
 jest.mock('fs');
 const mockFs = fs_1.default;
-describe('loadCctIdsFromFile', () => {
+describe('loadAssetIdsFromFile', () => {
     beforeEach(() => {
         jest.clearAllMocks();
     });
     it('should return undefined when no file path is provided', () => {
-        const result = (0, loadCctIdsFromFile_1.loadCctIdsFromFile)();
+        const result = (0, loadAssetIdsFromFile_1.loadAssetIdsFromFile)();
         expect(result).toBeUndefined();
     });
     it('should load and parse valid JSON file with CCT IDs', () => {
@@ -21,7 +21,7 @@ describe('loadCctIdsFromFile', () => {
         const expectedResult = ['cct-id-1', 'cct-id-2', 'cct-id-3'];
         mockFs.existsSync.mockReturnValue(true);
         mockFs.readFileSync.mockReturnValue(mockJsonContent);
-        const result = (0, loadCctIdsFromFile_1.loadCctIdsFromFile)(mockFilePath);
+        const result = (0, loadAssetIdsFromFile_1.loadAssetIdsFromFile)(mockFilePath);
         expect(mockFs.existsSync).toHaveBeenCalledWith(mockFilePath);
         expect(mockFs.readFileSync).toHaveBeenCalledWith(mockFilePath, 'utf8');
         expect(result).toEqual(expectedResult);
@@ -29,63 +29,63 @@ describe('loadCctIdsFromFile', () => {
     it('should throw error when file does not exist', () => {
         const mockFilePath = '/test/path/nonexistent.json';
         mockFs.existsSync.mockReturnValue(false);
-        expect(() => (0, loadCctIdsFromFile_1.loadCctIdsFromFile)(mockFilePath)).toThrow(`Failed to load CCT IDs from file: CCT IDs file not found: ${mockFilePath}`);
+        expect(() => (0, loadAssetIdsFromFile_1.loadAssetIdsFromFile)(mockFilePath)).toThrow(`Failed to load CCT IDs from file: CCT IDs file not found: ${mockFilePath}`);
     });
     it('should throw error when JSON is invalid', () => {
         const mockFilePath = '/test/path/invalid.json';
         const invalidJson = '["invalid": json}';
         mockFs.existsSync.mockReturnValue(true);
         mockFs.readFileSync.mockReturnValue(invalidJson);
-        expect(() => (0, loadCctIdsFromFile_1.loadCctIdsFromFile)(mockFilePath)).toThrow('Failed to load CCT IDs from file:');
+        expect(() => (0, loadAssetIdsFromFile_1.loadAssetIdsFromFile)(mockFilePath)).toThrow('Failed to load CCT IDs from file:');
     });
     it('should throw error when JSON is not an array', () => {
         const mockFilePath = '/test/path/object.json';
         const objectJson = '{"id": "cct-id-1"}';
         mockFs.existsSync.mockReturnValue(true);
         mockFs.readFileSync.mockReturnValue(objectJson);
-        expect(() => (0, loadCctIdsFromFile_1.loadCctIdsFromFile)(mockFilePath)).toThrow('CCT IDs file must contain a valid array of strings representing CCT IDs with at least one CCT ID');
+        expect(() => (0, loadAssetIdsFromFile_1.loadAssetIdsFromFile)(mockFilePath)).toThrow('CCT IDs file must contain a valid array of strings representing CCT IDs with at least one CCT ID');
     });
     it('should throw error when array is empty', () => {
         const mockFilePath = '/test/path/empty.json';
         const emptyArrayJson = '[]';
         mockFs.existsSync.mockReturnValue(true);
         mockFs.readFileSync.mockReturnValue(emptyArrayJson);
-        expect(() => (0, loadCctIdsFromFile_1.loadCctIdsFromFile)(mockFilePath)).toThrow('CCT IDs file must contain a valid array of strings representing CCT IDs with at least one CCT ID');
+        expect(() => (0, loadAssetIdsFromFile_1.loadAssetIdsFromFile)(mockFilePath)).toThrow('CCT IDs file must contain a valid array of strings representing CCT IDs with at least one CCT ID');
     });
     it('should throw error when array contains non-string values', () => {
         const mockFilePath = '/test/path/mixed.json';
         const mixedArrayJson = '["cct-id-1", 123, "cct-id-3"]';
         mockFs.existsSync.mockReturnValue(true);
         mockFs.readFileSync.mockReturnValue(mixedArrayJson);
-        expect(() => (0, loadCctIdsFromFile_1.loadCctIdsFromFile)(mockFilePath)).toThrow('CCT IDs file must contain a valid array of strings representing CCT IDs with at least one CCT ID');
+        expect(() => (0, loadAssetIdsFromFile_1.loadAssetIdsFromFile)(mockFilePath)).toThrow('CCT IDs file must contain a valid array of strings representing CCT IDs with at least one CCT ID');
     });
     it('should throw error when array contains empty strings', () => {
         const mockFilePath = '/test/path/empty-strings.json';
         const emptyStringsJson = '["cct-id-1", "", "cct-id-3"]';
         mockFs.existsSync.mockReturnValue(true);
         mockFs.readFileSync.mockReturnValue(emptyStringsJson);
-        expect(() => (0, loadCctIdsFromFile_1.loadCctIdsFromFile)(mockFilePath)).toThrow('CCT IDs file must contain a valid array of strings representing CCT IDs with at least one CCT ID');
+        expect(() => (0, loadAssetIdsFromFile_1.loadAssetIdsFromFile)(mockFilePath)).toThrow('CCT IDs file must contain a valid array of strings representing CCT IDs with at least one CCT ID');
     });
     it('should throw error when array contains whitespace-only strings', () => {
         const mockFilePath = '/test/path/whitespace.json';
         const whitespaceJson = '["cct-id-1", "   ", "cct-id-3"]';
         mockFs.existsSync.mockReturnValue(true);
         mockFs.readFileSync.mockReturnValue(whitespaceJson);
-        expect(() => (0, loadCctIdsFromFile_1.loadCctIdsFromFile)(mockFilePath)).toThrow('CCT IDs file must contain a valid array of strings representing CCT IDs with at least one CCT ID');
+        expect(() => (0, loadAssetIdsFromFile_1.loadAssetIdsFromFile)(mockFilePath)).toThrow('CCT IDs file must contain a valid array of strings representing CCT IDs with at least one CCT ID');
     });
     it('should throw error when JSON is null', () => {
         const mockFilePath = '/test/path/null.json';
         const nullJson = 'null';
         mockFs.existsSync.mockReturnValue(true);
         mockFs.readFileSync.mockReturnValue(nullJson);
-        expect(() => (0, loadCctIdsFromFile_1.loadCctIdsFromFile)(mockFilePath)).toThrow('CCT IDs file must contain a valid array of strings representing CCT IDs with at least one CCT ID');
+        expect(() => (0, loadAssetIdsFromFile_1.loadAssetIdsFromFile)(mockFilePath)).toThrow('CCT IDs file must contain a valid array of strings representing CCT IDs with at least one CCT ID');
     });
     it('should handle single CCT ID in array', () => {
         const mockFilePath = '/test/path/single.json';
         const singleIdJson = '["cct-id-only"]';
         mockFs.existsSync.mockReturnValue(true);
         mockFs.readFileSync.mockReturnValue(singleIdJson);
-        const result = (0, loadCctIdsFromFile_1.loadCctIdsFromFile)(mockFilePath);
+        const result = (0, loadAssetIdsFromFile_1.loadAssetIdsFromFile)(mockFilePath);
         expect(result).toEqual(['cct-id-only']);
     });
 });

package/lib/migration/utils/loadStageOptionsFromFile.d.ts

@@ -1 +1,2 @@
-export declare const loadStageOptionsFromFile: (filePath?: string) => any;
+import { StageOptions } from '../types';
+export declare const loadStageOptionsFromFile: (filePath?: string) => StageOptions | undefined;

package/lib/migration/utils/markComponentsDeployed.d.ts

@@ -0,0 +1,2 @@
+import { MarkDeployedInput, MarkDeployedApiResponse } from '../types';
+export declare function markComponentsDeployed(options: MarkDeployedInput): Promise<MarkDeployedApiResponse>;

package/lib/migration/utils/markComponentsDeployed.js

@@ -0,0 +1,37 @@
+"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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.markComponentsDeployed = void 0;
+const ApiService_1 = require("../../ApiService");
+const _1 = require(".");
+function markComponentsDeployed(options) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const apiService = new ApiService_1.ApiService({
+            validateStatus: _1.validateAxiosStatus,
+        });
+        const migrationUrl = yield (0, _1.buildMigrationUrl)(options.tenant, options.overrideUrl);
+        const payload = {
+            cctIds: options.cctIds,
+        };
+        const response = yield apiService.client.post(`${migrationUrl}/components/deployments`, payload, {
+            headers: yield (0, _1.getMigrationHeaders)(options.tenant),
+        });
+        const { success, failed } = response.data || {};
+        if (!success && !failed) {
+            throw new Error('Invalid response format from mark deployed');
+        }
+        return {
+            success: success || [],
+            failed: failed || [],
+        };
+    });
+}
+exports.markComponentsDeployed = markComponentsDeployed;

package/lib/migration/utils/markComponentsDeployed.spec.d.ts

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

package/lib/migration/utils/markComponentsDeployed.spec.js

@@ -0,0 +1,222 @@
+"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 ApiService_1 = require("../../ApiService");
+const markComponentsDeployed_1 = require("./markComponentsDeployed");
+const utils = __importStar(require("."));
+jest.mock('../../ApiService');
+jest.mock('.');
+const mockApiService = ApiService_1.ApiService;
+const mockUtils = utils;
+describe('markComponentsDeployed', () => {
+    let mockApiServiceInstance;
+    let mockOptions;
+    beforeEach(() => {
+        mockApiServiceInstance = {
+            client: {
+                post: jest.fn(),
+            },
+        };
+        mockApiService.mockImplementation(() => mockApiServiceInstance);
+        mockOptions = {
+            cctIds: ['component-1', 'component-2', 'component-3'],
+            tenant: 'test-tenant',
+        };
+        mockUtils.buildMigrationUrl.mockResolvedValue('https://example.com/__dxp/service/aiapps/migration/migrations');
+        mockUtils.getMigrationHeaders.mockResolvedValue({
+            'Content-Type': 'application/json',
+            'x-dxp-tenant': 'test-tenant',
+        });
+        mockUtils.validateAxiosStatus.mockImplementation(status => status >= 200 && status < 300);
+    });
+    afterEach(() => {
+        jest.clearAllMocks();
+    });
+    it('marks components as deployed successfully', () => __awaiter(void 0, void 0, void 0, function* () {
+        const mockResponse = {
+            status: 200,
+            data: {
+                success: ['component-1', 'component-2', 'component-3'],
+                failed: [],
+            },
+        };
+        mockApiServiceInstance.client.post.mockResolvedValue(mockResponse);
+        const result = yield (0, markComponentsDeployed_1.markComponentsDeployed)(mockOptions);
+        expect(result).toEqual({
+            success: ['component-1', 'component-2', 'component-3'],
+            failed: [],
+        });
+        expect(mockApiServiceInstance.client.post).toHaveBeenCalledWith('https://example.com/__dxp/service/aiapps/migration/migrations/components/deployments', { cctIds: ['component-1', 'component-2', 'component-3'] }, {
+            headers: {
+                'Content-Type': 'application/json',
+                'x-dxp-tenant': 'test-tenant',
+            },
+        });
+    }));
+    it('handles mixed success and failure response', () => __awaiter(void 0, void 0, void 0, function* () {
+        const mockResponse = {
+            status: 200,
+            data: {
+                success: ['component-1'],
+                failed: [
+                    { cctId: 'component-2', error: 'Component not found' },
+                    { cctId: 'component-3', error: 'Already deployed' },
+                ],
+            },
+        };
+        mockApiServiceInstance.client.post.mockResolvedValue(mockResponse);
+        const result = yield (0, markComponentsDeployed_1.markComponentsDeployed)(mockOptions);
+        expect(result).toEqual({
+            success: ['component-1'],
+            failed: [
+                { cctId: 'component-2', error: 'Component not found' },
+                { cctId: 'component-3', error: 'Already deployed' },
+            ],
+        });
+    }));
+    it('handles API errors (4xx/5xx status codes)', () => __awaiter(void 0, void 0, void 0, function* () {
+        const axiosError = new Error('Request failed with status code 400');
+        axiosError.isAxiosError = true;
+        axiosError.response = {
+            status: 400,
+            data: { message: 'Bad Request' },
+        };
+        mockApiServiceInstance.client.post.mockRejectedValue(axiosError);
+        yield expect((0, markComponentsDeployed_1.markComponentsDeployed)(mockOptions)).rejects.toThrow('Request failed with status code 400');
+    }));
+    it('handles missing success and failed in response', () => __awaiter(void 0, void 0, void 0, function* () {
+        const mockResponse = {
+            status: 200,
+            data: {},
+        };
+        mockApiServiceInstance.client.post.mockResolvedValue(mockResponse);
+        yield expect((0, markComponentsDeployed_1.markComponentsDeployed)(mockOptions)).rejects.toThrow('Invalid response format from mark deployed');
+    }));
+    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, markComponentsDeployed_1.markComponentsDeployed)(mockOptions)).rejects.toThrow('Network error');
+    }));
+    it('propagates rejected values as-is', () => __awaiter(void 0, void 0, void 0, function* () {
+        mockApiServiceInstance.client.post.mockRejectedValue('Unknown error');
+        yield expect((0, markComponentsDeployed_1.markComponentsDeployed)(mockOptions)).rejects.toBe('Unknown error');
+    }));
+    it('uses override URL when provided', () => __awaiter(void 0, void 0, void 0, function* () {
+        const optionsWithOverride = Object.assign(Object.assign({}, mockOptions), { overrideUrl: 'https://custom.migration.url' });
+        mockUtils.buildMigrationUrl.mockResolvedValue('https://custom.migration.url/migrations');
+        const mockResponse = {
+            status: 200,
+            data: {
+                success: ['component-1'],
+                failed: [],
+            },
+        };
+        mockApiServiceInstance.client.post.mockResolvedValue(mockResponse);
+        yield (0, markComponentsDeployed_1.markComponentsDeployed)(optionsWithOverride);
+        expect(mockApiServiceInstance.client.post).toHaveBeenCalledWith('https://custom.migration.url/migrations/components/deployments', expect.any(Object), expect.any(Object));
+    }));
+    it('constructs correct URL path', () => __awaiter(void 0, void 0, void 0, function* () {
+        const mockResponse = {
+            status: 200,
+            data: {
+                success: [],
+                failed: [],
+            },
+        };
+        mockApiServiceInstance.client.post.mockResolvedValue(mockResponse);
+        yield (0, markComponentsDeployed_1.markComponentsDeployed)(mockOptions);
+        expect(mockApiServiceInstance.client.post).toHaveBeenCalledWith('https://example.com/__dxp/service/aiapps/migration/migrations/components/deployments', expect.any(Object), expect.any(Object));
+    }));
+    it('uses correct headers', () => __awaiter(void 0, void 0, void 0, function* () {
+        const mockResponse = {
+            status: 200,
+            data: {
+                success: [],
+                failed: [],
+            },
+        };
+        mockApiServiceInstance.client.post.mockResolvedValue(mockResponse);
+        yield (0, markComponentsDeployed_1.markComponentsDeployed)(mockOptions);
+        expect(mockApiServiceInstance.client.post).toHaveBeenCalledWith(expect.any(String), expect.any(Object), {
+            headers: {
+                'Content-Type': 'application/json',
+                'x-dxp-tenant': 'test-tenant',
+            },
+        });
+    }));
+    it('sends cctIds in payload', () => __awaiter(void 0, void 0, void 0, function* () {
+        const mockResponse = {
+            status: 200,
+            data: {
+                success: [],
+                failed: [],
+            },
+        };
+        mockApiServiceInstance.client.post.mockResolvedValue(mockResponse);
+        yield (0, markComponentsDeployed_1.markComponentsDeployed)(mockOptions);
+        expect(mockApiServiceInstance.client.post).toHaveBeenCalledWith(expect.any(String), { cctIds: ['component-1', 'component-2', 'component-3'] }, expect.any(Object));
+    }));
+    it('works with a single cctId', () => __awaiter(void 0, void 0, void 0, function* () {
+        const singleComponentOptions = Object.assign(Object.assign({}, mockOptions), { cctIds: ['single-component'] });
+        const mockResponse = {
+            status: 200,
+            data: {
+                success: ['single-component'],
+                failed: [],
+            },
+        };
+        mockApiServiceInstance.client.post.mockResolvedValue(mockResponse);
+        const result = yield (0, markComponentsDeployed_1.markComponentsDeployed)(singleComponentOptions);
+        expect(result).toEqual({
+            success: ['single-component'],
+            failed: [],
+        });
+        expect(mockApiServiceInstance.client.post).toHaveBeenCalledWith(expect.any(String), { cctIds: ['single-component'] }, expect.any(Object));
+    }));
+    it('returns empty arrays when response has empty success and failed', () => __awaiter(void 0, void 0, void 0, function* () {
+        const mockResponse = {
+            status: 200,
+            data: {
+                success: [],
+                failed: [],
+            },
+        };
+        mockApiServiceInstance.client.post.mockResolvedValue(mockResponse);
+        const result = yield (0, markComponentsDeployed_1.markComponentsDeployed)(mockOptions);
+        expect(result).toEqual({
+            success: [],
+            failed: [],
+        });
+    }));
+});