@contrail/cli 3.4.3 → 3.4.4-alpha.1

package/dist/helpers/load/validators.spec.js

@@ -1,450 +1,450 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const validators_1 = require("./validators");
-describe('LoadValidators', () => {
-    describe('ValidateColorsLoadFile', () => {
-        it('should return errors if Federated ID is missing in the config file', () => {
-            const colorsData = [{ id: 1, name: 'Red', hex: '#FF0000' }];
-            const config = {
-                federatedMappings: { name: 'Colors' },
-                loadType: ['COLOR'],
-                conditionalColumns: [{ toProperty: 'typePath', default: 'color' }],
-            };
-            const result = validators_1.LoadValidators.ValidateColorsLoadFile(colorsData, config);
-            expect(result.errors).toContain('"federatedId" is required in the config file');
-        });
-        it('should return errors if Name is missing in the config file', () => {
-            const colorsData = [{ id: 1, name: 'Red', hex: '#FF0000' }];
-            const config = {
-                federatedMappings: { federatedId: 'id' },
-                loadType: ['COLOR'],
-                conditionalColumns: [{ toProperty: 'typePath', default: 'color' }],
-            };
-            const result = validators_1.LoadValidators.ValidateColorsLoadFile(colorsData, config);
-            expect(result.errors).toContain('"name" is required in the config file');
-        });
-        it('should return errors if Name column is not found in the CSV file', () => {
-            const colorsData = [{ id: 1, name: 'Red', hex: '#FF0000' }];
-            const config = {
-                federatedMappings: { federatedId: 'id', name: 'Colors' },
-                loadType: ['COLOR'],
-                conditionalColumns: [{ toProperty: 'typePath', default: 'color' }],
-            };
-            const result = validators_1.LoadValidators.ValidateColorsLoadFile(colorsData, config);
-            expect(result.errors).toContain('Name column (Colors) not found in the CSV file');
-        });
-        it('should return errors if Federated ID is not found in the CSV file', () => {
-            const colorsData = [{ Colors: 'Red', hex: '#FF0000' }];
-            const config = {
-                federatedMappings: { name: 'Colors', federatedId: 'id' },
-                loadType: ['COLOR'],
-                conditionalColumns: [{ toProperty: 'typePath', default: 'color' }],
-            };
-            const result = validators_1.LoadValidators.ValidateColorsLoadFile(colorsData, config);
-            expect(result.errors).toContain('Federated ID column (id) not found in the CSV file');
-        });
-        it('should return multiple errors', () => {
-            const colorsData = [{ hex: '#FF0000' }];
-            const config = {
-                federatedMappings: { name: 'Colors', federatedId: 'id' },
-                loadType: ['COLOR'],
-                conditionalColumns: [{ toProperty: 'typePath', default: 'color' }],
-            };
-            const result = validators_1.LoadValidators.ValidateColorsLoadFile(colorsData, config);
-            expect(result.errors).toContain('Name column (Colors) not found in the CSV file');
-            expect(result.errors).toContain('Federated ID column (id) not found in the CSV file');
-        });
-        it('should return warnings if Hex is ignored when red, green, and blue columns are present', () => {
-            const colorsData = [{ id: 1, name: 'Red', red: 255, green: 0, blue: 0, hex: '#FF0000' }];
-            const config = {
-                loadType: ['COLOR'],
-                conditionalColumns: [{ toProperty: 'typePath', default: 'color' }],
-                federatedMappings: {
-                    red: 'red',
-                    green: 'green',
-                    blue: 'blue',
-                    hex: 'hex',
-                    name: 'Colors',
-                    federatedId: 'id',
-                },
-            };
-            const result = validators_1.LoadValidators.ValidateColorsLoadFile(colorsData, config);
-            expect(result.warnings).toContain('"Hex" is ignored when red, green, and blue columns are present');
-        });
-        it('should return empty errors and warnings if all validations pass', () => {
-            const colorsData = [{ id: 1, Colors: 'Red', red: 255, green: 0, blue: 0 }];
-            const config = {
-                loadType: ['COLOR'],
-                conditionalColumns: [{ toProperty: 'typePath', default: 'color' }],
-                federatedMappings: {
-                    red: 'red',
-                    green: 'green',
-                    blue: 'blue',
-                    name: 'Colors',
-                    federatedId: 'id',
-                },
-            };
-            const result = validators_1.LoadValidators.ValidateColorsLoadFile(colorsData, config);
-            expect(result.errors).toEqual([]);
-            expect(result.warnings).toEqual([]);
-        });
-        it('should return error if duplicate federatedId is found', () => {
-            const colorsData = [
-                { id: 1, Colors: 'Red', red: 255, green: 0, blue: 0 },
-                { id: 1, Colors: 'Green', red: 0, green: 255, blue: 0 },
-                { id: 2, Colors: 'Blue', red: 0, green: 0, blue: 255 },
-            ];
-            const config = {
-                loadType: ['COLOR'],
-                conditionalColumns: [{ toProperty: 'typePath', default: 'color' }],
-                federatedMappings: {
-                    red: 'red',
-                    green: 'green',
-                    blue: 'blue',
-                    name: 'Colors',
-                    federatedId: 'id',
-                },
-            };
-            const result = validators_1.LoadValidators.ValidateColorsLoadFile(colorsData, config);
-            expect(result.errors).toContain('Duplicate FederatedIds found: 1');
-        });
-        it('should throw error if typePath is present in the csv header but have incorrect typePath', () => {
-            const colorsData = [{ name: 'color1', typePath: 'color1' }];
-            const config = {
-                loadType: ['COLOR'],
-                conditionalColumns: [],
-                federatedMappings: {
-                    red: 'red',
-                    green: 'green',
-                    blue: 'blue',
-                    name: 'Colors',
-                    federatedId: 'id',
-                },
-            };
-            const result = validators_1.LoadValidators.ValidateColorsLoadFile(colorsData, config);
-            expect(result.errors).toContain('"typePath" must be "color" in each row in the csv file');
-        });
-        it('should not throw error if typepath is present in the csv header and have correct typePath', () => {
-            const colorsData = [{ name: 'color1', typePath: 'color' }];
-            const config = {
-                loadType: ['COLOR'],
-                conditionalColumns: [],
-                federatedMappings: {
-                    red: 'red',
-                    green: 'green',
-                    blue: 'blue',
-                    name: 'name',
-                    federatedId: 'name',
-                },
-            };
-            const result = validators_1.LoadValidators.ValidateColorsLoadFile(colorsData, config);
-            expect(result.errors).toHaveLength(0);
-        });
-    });
-    describe('ValidateCustomEntityLoadFile', () => {
-        it('should return error if config is null', () => {
-            const customEntityData = [{ id: 1, name: 'Test' }];
-            const result = validators_1.LoadValidators.ValidateCustomEntityLoadFile(customEntityData, null);
-            expect(result.errors).toContain('Config file is empty');
-        });
-        it('should return error if loadType is missing in config', () => {
-            const customEntityData = [{ id: 1, name: 'Test' }];
-            const config = {};
-            const result = validators_1.LoadValidators.ValidateCustomEntityLoadFile(customEntityData, config);
-            expect(result.errors).toContain('"loadType" is required in the config file');
-        });
-        it('should return error if loadType is not CUSTOM_ENTITY', () => {
-            const customEntityData = [{ id: 1, name: 'Test' }];
-            const config = { loadType: ['OTHER_TYPE'] };
-            const result = validators_1.LoadValidators.ValidateCustomEntityLoadFile(customEntityData, config);
-            expect(result.errors).toContain('"loadType" must be must be single value "CUSTOM_ENTITY" in the config file');
-        });
-        it('should return error if federatedMappings.federatedId is missing in config', () => {
-            const customEntityData = [{ id: 1, name: 'Test' }];
-            const config = { loadType: ['CUSTOM_ENTITY'] };
-            const result = validators_1.LoadValidators.ValidateCustomEntityLoadFile(customEntityData, config);
-            expect(result.errors).toContain('"federatedId" is required in the config file');
-        });
-        it('should return error if federatedMappings.name is missing in config', () => {
-            const customEntityData = [{ id: 1, name: 'Test' }];
-            const config = {
-                loadType: ['CUSTOM_ENTITY'],
-                federatedMappings: { federatedId: 'id' },
-            };
-            const result = validators_1.LoadValidators.ValidateCustomEntityLoadFile(customEntityData, config);
-            expect(result.errors).toContain('"name" is required in the config file');
-        });
-        it('should return error if federatedId column is missing in CSV', () => {
-            const customEntityData = [{ name: 'Test' }];
-            const config = {
-                loadType: ['CUSTOM_ENTITY'],
-                federatedMappings: { federatedId: 'id', name: 'name' },
-                conditionalColumns: ['typePath'],
-            };
-            const result = validators_1.LoadValidators.ValidateCustomEntityLoadFile(customEntityData, config);
-            expect(result.errors).toContain('Federated ID column (id) not found in the CSV file');
-        });
-        it('should return error if conditionalColumns is missing in config', () => {
-            const customEntityData = [{ id: 1, name: 'Test' }];
-            const config = {
-                loadType: ['CUSTOM_ENTITY'],
-                federatedMappings: { federatedId: 'id', name: 'name' },
-            };
-            const result = validators_1.LoadValidators.ValidateCustomEntityLoadFile(customEntityData, config);
-            expect(result.errors).toContain('Missing "typePath" column in the csv file or config file');
-        });
-        it('should return error if name column is missing in CSV', () => {
-            const customEntityData = [{ id: 1 }];
-            const config = {
-                loadType: ['CUSTOM_ENTITY'],
-                federatedMappings: { federatedId: 'id', name: 'name' },
-                conditionalColumns: ['typePath'],
-            };
-            const result = validators_1.LoadValidators.ValidateCustomEntityLoadFile(customEntityData, config);
-            expect(result.errors).toContain('Name column not found in the CSV file');
-        });
-        it('should not return errors if all conditions are met', () => {
-            const customEntityData = [{ id: 1, name: 'Test' }];
-            const config = {
-                loadType: ['CUSTOM_ENTITY'],
-                federatedMappings: { federatedId: 'id', name: 'name' },
-                conditionalColumns: [{ toProperty: 'typePath', default: 'custom-entity:material' }],
-            };
-            const result = validators_1.LoadValidators.ValidateCustomEntityLoadFile(customEntityData, config);
-            expect(result.errors).toHaveLength(0);
-        });
-        it('should return error if duplicate federatedId is found', () => {
-            const customEntityData = [
-                { id: 1, name: 'Test' },
-                { id: 2, name: 'Test2' },
-                { id: 1, name: 'Test3' },
-            ];
-            const config = {
-                loadType: ['CUSTOM_ENTITY'],
-                federatedMappings: { federatedId: 'id', name: 'name' },
-                conditionalColumns: [{ toProperty: 'typePath', default: 'custom-entity' }],
-            };
-            const result = validators_1.LoadValidators.ValidateCustomEntityLoadFile(customEntityData, config);
-            expect(result.errors).toContain('Duplicate FederatedIds found: 1');
-        });
-        it('should throw error if typepath is present in the csv header but have incorrect typePath', () => {
-            const customEntityData = [{ name: 'custom-entity1', typePath: 'custom-entity1' }];
-            const config = {
-                loadType: ['CUSTOM_ENTITY'],
-                federatedMappings: { federatedId: 'name', name: 'name' },
-                conditionalColumns: [],
-            };
-            const result = validators_1.LoadValidators.ValidateCustomEntityLoadFile(customEntityData, config);
-            expect(result.errors).toContain('"typePath" must be "custom-entity:<subtypepath>" in each row in the csv file');
-        });
-        it('should not throw error if typepath is present in the csv header but have correct typePath', () => {
-            const customEntityData = [{ name: 'custom-entity1', typePath: 'custom-entity:material' }];
-            const config = {
-                loadType: ['CUSTOM_ENTITY'],
-                federatedMappings: { federatedId: 'name', name: 'name' },
-                conditionalColumns: [],
-            };
-            const result = validators_1.LoadValidators.ValidateCustomEntityLoadFile(customEntityData, config);
-            expect(result.errors).toHaveLength(0);
-        });
-    });
-    describe('ValidateLineSheetLoadFile', () => {
-        it('should return an error if config is empty', () => {
-            const lineSheetData = [{ header1: 'value1' }];
-            const config = null;
-            const result = validators_1.LoadValidators.ValidateLineSheetLoadFile(lineSheetData, config);
-            expect(result.errors).toContain('Config file is empty');
-            expect(result.warnings).toHaveLength(0);
-        });
-        it('should return an error if load type is missing', () => {
-            const lineSheetData = [{ header1: 'value1' }];
-            const config = { loadType: '', federatedMappings: {} };
-            const result = validators_1.LoadValidators.ValidateLineSheetLoadFile(lineSheetData, config);
-            expect(result.errors).toContain('"loadType" is required in the config file');
-        });
-        it('should return an error if load type is invalid', () => {
-            const lineSheetData = [{ header1: 'value1' }];
-            const config = { loadType: ['INVALID'], federatedMappings: {} };
-            const result = validators_1.LoadValidators.ValidateLineSheetLoadFile(lineSheetData, config);
-            expect(result.errors).toContain('"loadType" must be either of values ["ITEM", "PROJECT_ITEM", "ASSORTMENT"] in the config file');
-        });
-        it('should return an error if name is not mapped in federatedMappings', () => {
-            const lineSheetData = [{ header1: 'value1' }];
-            const config = { loadType: ['ITEM'], federatedMappings: {} };
-            const result = validators_1.LoadValidators.ValidateLineSheetLoadFile(lineSheetData, config);
-            expect(result.errors).toContain('"name" is required in the config file and must be mapped to Item Family Name');
-        });
-        it('should return a warning if optionName is not mapped in federatedMappings', () => {
-            const lineSheetData = [{ header1: 'value1' }];
-            const config = {
-                loadType: ['ITEM'],
-                federatedMappings: {
-                    name: 'header1',
-                    itemFamilyFederatedId: 'someId',
-                },
-            };
-            const result = validators_1.LoadValidators.ValidateLineSheetLoadFile(lineSheetData, config);
-            expect(result.warnings).toContain('"optionName" is not mapped in the config file');
-        });
-        it('should return an error if itemFamilyFederatedId is not mapped in federatedMappings', () => {
-            const lineSheetData = [{ header1: 'value1' }];
-            const config = {
-                loadType: ['ITEM'],
-                federatedMappings: {
-                    name: 'header1',
-                },
-            };
-            const result = validators_1.LoadValidators.ValidateLineSheetLoadFile(lineSheetData, config);
-            expect(result.errors).toContain('"itemFamilyFederatedId" is required in the config file');
-        });
-        it('should return a warning if itemOptionFederatedId is not mapped in federatedMappings', () => {
-            const lineSheetData = [{ header1: 'value1' }];
-            const config = {
-                loadType: ['ITEM'],
-                federatedMappings: {
-                    name: 'header1',
-                    itemFamilyFederatedId: 'someId',
-                },
-            };
-            const result = validators_1.LoadValidators.ValidateLineSheetLoadFile(lineSheetData, config);
-            expect(result.warnings).toContain('"itemOptionFederatedId" is not mapped in the config file');
-        });
-        it('should return an error if itemFamilyFederatedId is missing in the CSV file', () => {
-            const lineSheetData = [{ header1: 'value1', itemFamilyFederatedId: 'someId' }];
-            const config = {
-                loadType: ['ITEM'],
-                federatedMappings: {
-                    name: 'header1',
-                    itemFamilyFederatedId: null,
-                },
-            };
-            const result = validators_1.LoadValidators.ValidateLineSheetLoadFile(lineSheetData, config);
-            expect(result.errors).toContain(`itemFamilyFederatedId column (${config?.federatedMappings?.itemFamilyFederatedId}) not found in the CSV file`);
-        });
-        it('should return an error if itemFamilyFederatedId is null or undefined or empty in lineSheetData', () => {
-            const lineSheetData = [
-                { header1: 'value1', itemFamilyFederatedId: null },
-                { header1: 'value2', itemFamilyFederatedId: undefined },
-                { header1: 'value3', itemFamilyFederatedId: 'valid' },
-                { header1: 'value4', itemFamilyFederatedId: '' },
-            ];
-            const config = {
-                loadType: ['ITEM'],
-                federatedMappings: {
-                    name: 'header1',
-                    itemFamilyFederatedId: 'itemFamilyFederatedId',
-                },
-            };
-            const result = validators_1.LoadValidators.ValidateLineSheetLoadFile(lineSheetData, config);
-            expect(result.errors).toContain('some rows contain itemFamilyFederatedId is null or undefined or empty in the CSV file (rows 0,1,3)');
-        });
-        it('should return errors if duplicate itemFamilyFederatedId is found in lineSheetData', () => {
-            const lineSheetData = [
-                {
-                    header1: 'value1',
-                    itemFamilyFederatedId: '1',
-                },
-                {
-                    header1: 'value2',
-                    itemFamilyFederatedId: '1',
-                },
-                {
-                    header1: 'value3',
-                    itemFamilyFederatedId: '2',
-                },
-            ];
-            const config = {
-                loadType: ['ITEM'],
-                federatedMappings: {
-                    name: 'header1',
-                    itemFamilyFederatedId: 'itemFamilyFederatedId',
-                },
-            };
-            const result = validators_1.LoadValidators.ValidateLineSheetLoadFile(lineSheetData, config);
-            expect(result.errors).toContain('Found conflicting fields for family federated Ids: (1: (value1, value2))');
-        });
-        it('should allow for the same itemFamilyFederatedId if the names are the same', () => {
-            const lineSheetData = [
-                {
-                    itemName: 'foo',
-                    itemFamilyFederatedId: '1',
-                },
-                {
-                    itemName: 'foo',
-                    itemFamilyFederatedId: '1',
-                },
-                {
-                    itemName: 'bar',
-                    itemFamilyFederatedId: '2',
-                },
-            ];
-            const config = {
-                loadType: ['ITEM'],
-                federatedMappings: {
-                    name: 'itemName',
-                    itemFamilyFederatedId: 'itemFamilyFederatedId',
-                },
-            };
-            const result = validators_1.LoadValidators.ValidateLineSheetLoadFile(lineSheetData, config);
-            expect(result.errors.length).toBe(0);
-        });
-        it('should find error if itemFamilyFederatedId is duplicated across different names', () => {
-            const lineSheetData = [
-                {
-                    itemName: 'foo',
-                    itemFamilyFederatedId: '1',
-                },
-                {
-                    itemName: 'bar',
-                    itemFamilyFederatedId: '1',
-                },
-                {
-                    itemName: 'baz',
-                    itemFamilyFederatedId: '2',
-                },
-            ];
-            const config = {
-                loadType: ['ITEM'],
-                federatedMappings: {
-                    name: 'itemName',
-                    itemFamilyFederatedId: 'itemFamilyFederatedId',
-                },
-            };
-            const result = validators_1.LoadValidators.ValidateLineSheetLoadFile(lineSheetData, config);
-            expect(result.errors).toContain('Found conflicting fields for family federated Ids: (1: (foo, bar))');
-        });
-        it('should return warnings if duplicate itemOptionFederatedId is found in lineSheetData', () => {
-            const lineSheetData = [
-                {
-                    header1: 'value1',
-                    itemFamilyFederatedId: '1',
-                    itemOptionFederatedId: '1',
-                    optionName: 'option1',
-                },
-                {
-                    header1: 'value2',
-                    itemFamilyFederatedId: '2',
-                    itemOptionFederatedId: '1',
-                    optionName: 'option2',
-                },
-                {
-                    header1: 'value3',
-                    itemFamilyFederatedId: '3',
-                    itemOptionFederatedId: '2',
-                    optionName: 'option3',
-                },
-            ];
-            const config = {
-                loadType: ['ITEM'],
-                federatedMappings: {
-                    name: 'header1',
-                    itemFamilyFederatedId: 'itemFamilyFederatedId',
-                    itemOptionFederatedId: 'itemOptionFederatedId',
-                    optionName: 'optionName',
-                },
-            };
-            const result = validators_1.LoadValidators.ValidateLineSheetLoadFile(lineSheetData, config);
-            expect(result.errors).toContain('Duplicate itemOptionFederatedId found: 1');
-        });
-    });
-});
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const validators_1 = require("./validators");
+describe('LoadValidators', () => {
+    describe('ValidateColorsLoadFile', () => {
+        it('should return errors if Federated ID is missing in the config file', () => {
+            const colorsData = [{ id: 1, name: 'Red', hex: '#FF0000' }];
+            const config = {
+                federatedMappings: { name: 'Colors' },
+                loadType: ['COLOR'],
+                conditionalColumns: [{ toProperty: 'typePath', default: 'color' }],
+            };
+            const result = validators_1.LoadValidators.ValidateColorsLoadFile(colorsData, config);
+            expect(result.errors).toContain('"federatedId" is required in the config file');
+        });
+        it('should return errors if Name is missing in the config file', () => {
+            const colorsData = [{ id: 1, name: 'Red', hex: '#FF0000' }];
+            const config = {
+                federatedMappings: { federatedId: 'id' },
+                loadType: ['COLOR'],
+                conditionalColumns: [{ toProperty: 'typePath', default: 'color' }],
+            };
+            const result = validators_1.LoadValidators.ValidateColorsLoadFile(colorsData, config);
+            expect(result.errors).toContain('"name" is required in the config file');
+        });
+        it('should return errors if Name column is not found in the CSV file', () => {
+            const colorsData = [{ id: 1, name: 'Red', hex: '#FF0000' }];
+            const config = {
+                federatedMappings: { federatedId: 'id', name: 'Colors' },
+                loadType: ['COLOR'],
+                conditionalColumns: [{ toProperty: 'typePath', default: 'color' }],
+            };
+            const result = validators_1.LoadValidators.ValidateColorsLoadFile(colorsData, config);
+            expect(result.errors).toContain('Name column (Colors) not found in the CSV file');
+        });
+        it('should return errors if Federated ID is not found in the CSV file', () => {
+            const colorsData = [{ Colors: 'Red', hex: '#FF0000' }];
+            const config = {
+                federatedMappings: { name: 'Colors', federatedId: 'id' },
+                loadType: ['COLOR'],
+                conditionalColumns: [{ toProperty: 'typePath', default: 'color' }],
+            };
+            const result = validators_1.LoadValidators.ValidateColorsLoadFile(colorsData, config);
+            expect(result.errors).toContain('Federated ID column (id) not found in the CSV file');
+        });
+        it('should return multiple errors', () => {
+            const colorsData = [{ hex: '#FF0000' }];
+            const config = {
+                federatedMappings: { name: 'Colors', federatedId: 'id' },
+                loadType: ['COLOR'],
+                conditionalColumns: [{ toProperty: 'typePath', default: 'color' }],
+            };
+            const result = validators_1.LoadValidators.ValidateColorsLoadFile(colorsData, config);
+            expect(result.errors).toContain('Name column (Colors) not found in the CSV file');
+            expect(result.errors).toContain('Federated ID column (id) not found in the CSV file');
+        });
+        it('should return warnings if Hex is ignored when red, green, and blue columns are present', () => {
+            const colorsData = [{ id: 1, name: 'Red', red: 255, green: 0, blue: 0, hex: '#FF0000' }];
+            const config = {
+                loadType: ['COLOR'],
+                conditionalColumns: [{ toProperty: 'typePath', default: 'color' }],
+                federatedMappings: {
+                    red: 'red',
+                    green: 'green',
+                    blue: 'blue',
+                    hex: 'hex',
+                    name: 'Colors',
+                    federatedId: 'id',
+                },
+            };
+            const result = validators_1.LoadValidators.ValidateColorsLoadFile(colorsData, config);
+            expect(result.warnings).toContain('"Hex" is ignored when red, green, and blue columns are present');
+        });
+        it('should return empty errors and warnings if all validations pass', () => {
+            const colorsData = [{ id: 1, Colors: 'Red', red: 255, green: 0, blue: 0 }];
+            const config = {
+                loadType: ['COLOR'],
+                conditionalColumns: [{ toProperty: 'typePath', default: 'color' }],
+                federatedMappings: {
+                    red: 'red',
+                    green: 'green',
+                    blue: 'blue',
+                    name: 'Colors',
+                    federatedId: 'id',
+                },
+            };
+            const result = validators_1.LoadValidators.ValidateColorsLoadFile(colorsData, config);
+            expect(result.errors).toEqual([]);
+            expect(result.warnings).toEqual([]);
+        });
+        it('should return error if duplicate federatedId is found', () => {
+            const colorsData = [
+                { id: 1, Colors: 'Red', red: 255, green: 0, blue: 0 },
+                { id: 1, Colors: 'Green', red: 0, green: 255, blue: 0 },
+                { id: 2, Colors: 'Blue', red: 0, green: 0, blue: 255 },
+            ];
+            const config = {
+                loadType: ['COLOR'],
+                conditionalColumns: [{ toProperty: 'typePath', default: 'color' }],
+                federatedMappings: {
+                    red: 'red',
+                    green: 'green',
+                    blue: 'blue',
+                    name: 'Colors',
+                    federatedId: 'id',
+                },
+            };
+            const result = validators_1.LoadValidators.ValidateColorsLoadFile(colorsData, config);
+            expect(result.errors).toContain('Duplicate FederatedIds found: 1');
+        });
+        it('should throw error if typePath is present in the csv header but have incorrect typePath', () => {
+            const colorsData = [{ name: 'color1', typePath: 'color1' }];
+            const config = {
+                loadType: ['COLOR'],
+                conditionalColumns: [],
+                federatedMappings: {
+                    red: 'red',
+                    green: 'green',
+                    blue: 'blue',
+                    name: 'Colors',
+                    federatedId: 'id',
+                },
+            };
+            const result = validators_1.LoadValidators.ValidateColorsLoadFile(colorsData, config);
+            expect(result.errors).toContain('"typePath" must be "color" in each row in the csv file');
+        });
+        it('should not throw error if typepath is present in the csv header and have correct typePath', () => {
+            const colorsData = [{ name: 'color1', typePath: 'color' }];
+            const config = {
+                loadType: ['COLOR'],
+                conditionalColumns: [],
+                federatedMappings: {
+                    red: 'red',
+                    green: 'green',
+                    blue: 'blue',
+                    name: 'name',
+                    federatedId: 'name',
+                },
+            };
+            const result = validators_1.LoadValidators.ValidateColorsLoadFile(colorsData, config);
+            expect(result.errors).toHaveLength(0);
+        });
+    });
+    describe('ValidateCustomEntityLoadFile', () => {
+        it('should return error if config is null', () => {
+            const customEntityData = [{ id: 1, name: 'Test' }];
+            const result = validators_1.LoadValidators.ValidateCustomEntityLoadFile(customEntityData, null);
+            expect(result.errors).toContain('Config file is empty');
+        });
+        it('should return error if loadType is missing in config', () => {
+            const customEntityData = [{ id: 1, name: 'Test' }];
+            const config = {};
+            const result = validators_1.LoadValidators.ValidateCustomEntityLoadFile(customEntityData, config);
+            expect(result.errors).toContain('"loadType" is required in the config file');
+        });
+        it('should return error if loadType is not CUSTOM_ENTITY', () => {
+            const customEntityData = [{ id: 1, name: 'Test' }];
+            const config = { loadType: ['OTHER_TYPE'] };
+            const result = validators_1.LoadValidators.ValidateCustomEntityLoadFile(customEntityData, config);
+            expect(result.errors).toContain('"loadType" must be must be single value "CUSTOM_ENTITY" in the config file');
+        });
+        it('should return error if federatedMappings.federatedId is missing in config', () => {
+            const customEntityData = [{ id: 1, name: 'Test' }];
+            const config = { loadType: ['CUSTOM_ENTITY'] };
+            const result = validators_1.LoadValidators.ValidateCustomEntityLoadFile(customEntityData, config);
+            expect(result.errors).toContain('"federatedId" is required in the config file');
+        });
+        it('should return error if federatedMappings.name is missing in config', () => {
+            const customEntityData = [{ id: 1, name: 'Test' }];
+            const config = {
+                loadType: ['CUSTOM_ENTITY'],
+                federatedMappings: { federatedId: 'id' },
+            };
+            const result = validators_1.LoadValidators.ValidateCustomEntityLoadFile(customEntityData, config);
+            expect(result.errors).toContain('"name" is required in the config file');
+        });
+        it('should return error if federatedId column is missing in CSV', () => {
+            const customEntityData = [{ name: 'Test' }];
+            const config = {
+                loadType: ['CUSTOM_ENTITY'],
+                federatedMappings: { federatedId: 'id', name: 'name' },
+                conditionalColumns: ['typePath'],
+            };
+            const result = validators_1.LoadValidators.ValidateCustomEntityLoadFile(customEntityData, config);
+            expect(result.errors).toContain('Federated ID column (id) not found in the CSV file');
+        });
+        it('should return error if conditionalColumns is missing in config', () => {
+            const customEntityData = [{ id: 1, name: 'Test' }];
+            const config = {
+                loadType: ['CUSTOM_ENTITY'],
+                federatedMappings: { federatedId: 'id', name: 'name' },
+            };
+            const result = validators_1.LoadValidators.ValidateCustomEntityLoadFile(customEntityData, config);
+            expect(result.errors).toContain('Missing "typePath" column in the csv file or config file');
+        });
+        it('should return error if name column is missing in CSV', () => {
+            const customEntityData = [{ id: 1 }];
+            const config = {
+                loadType: ['CUSTOM_ENTITY'],
+                federatedMappings: { federatedId: 'id', name: 'name' },
+                conditionalColumns: ['typePath'],
+            };
+            const result = validators_1.LoadValidators.ValidateCustomEntityLoadFile(customEntityData, config);
+            expect(result.errors).toContain('Name column not found in the CSV file');
+        });
+        it('should not return errors if all conditions are met', () => {
+            const customEntityData = [{ id: 1, name: 'Test' }];
+            const config = {
+                loadType: ['CUSTOM_ENTITY'],
+                federatedMappings: { federatedId: 'id', name: 'name' },
+                conditionalColumns: [{ toProperty: 'typePath', default: 'custom-entity:material' }],
+            };
+            const result = validators_1.LoadValidators.ValidateCustomEntityLoadFile(customEntityData, config);
+            expect(result.errors).toHaveLength(0);
+        });
+        it('should return error if duplicate federatedId is found', () => {
+            const customEntityData = [
+                { id: 1, name: 'Test' },
+                { id: 2, name: 'Test2' },
+                { id: 1, name: 'Test3' },
+            ];
+            const config = {
+                loadType: ['CUSTOM_ENTITY'],
+                federatedMappings: { federatedId: 'id', name: 'name' },
+                conditionalColumns: [{ toProperty: 'typePath', default: 'custom-entity' }],
+            };
+            const result = validators_1.LoadValidators.ValidateCustomEntityLoadFile(customEntityData, config);
+            expect(result.errors).toContain('Duplicate FederatedIds found: 1');
+        });
+        it('should throw error if typepath is present in the csv header but have incorrect typePath', () => {
+            const customEntityData = [{ name: 'custom-entity1', typePath: 'custom-entity1' }];
+            const config = {
+                loadType: ['CUSTOM_ENTITY'],
+                federatedMappings: { federatedId: 'name', name: 'name' },
+                conditionalColumns: [],
+            };
+            const result = validators_1.LoadValidators.ValidateCustomEntityLoadFile(customEntityData, config);
+            expect(result.errors).toContain('"typePath" must be "custom-entity:<subtypepath>" in each row in the csv file');
+        });
+        it('should not throw error if typepath is present in the csv header but have correct typePath', () => {
+            const customEntityData = [{ name: 'custom-entity1', typePath: 'custom-entity:material' }];
+            const config = {
+                loadType: ['CUSTOM_ENTITY'],
+                federatedMappings: { federatedId: 'name', name: 'name' },
+                conditionalColumns: [],
+            };
+            const result = validators_1.LoadValidators.ValidateCustomEntityLoadFile(customEntityData, config);
+            expect(result.errors).toHaveLength(0);
+        });
+    });
+    describe('ValidateLineSheetLoadFile', () => {
+        it('should return an error if config is empty', () => {
+            const lineSheetData = [{ header1: 'value1' }];
+            const config = null;
+            const result = validators_1.LoadValidators.ValidateLineSheetLoadFile(lineSheetData, config);
+            expect(result.errors).toContain('Config file is empty');
+            expect(result.warnings).toHaveLength(0);
+        });
+        it('should return an error if load type is missing', () => {
+            const lineSheetData = [{ header1: 'value1' }];
+            const config = { loadType: '', federatedMappings: {} };
+            const result = validators_1.LoadValidators.ValidateLineSheetLoadFile(lineSheetData, config);
+            expect(result.errors).toContain('"loadType" is required in the config file');
+        });
+        it('should return an error if load type is invalid', () => {
+            const lineSheetData = [{ header1: 'value1' }];
+            const config = { loadType: ['INVALID'], federatedMappings: {} };
+            const result = validators_1.LoadValidators.ValidateLineSheetLoadFile(lineSheetData, config);
+            expect(result.errors).toContain('"loadType" must be either of values ["ITEM", "PROJECT_ITEM", "ASSORTMENT"] in the config file');
+        });
+        it('should return an error if name is not mapped in federatedMappings', () => {
+            const lineSheetData = [{ header1: 'value1' }];
+            const config = { loadType: ['ITEM'], federatedMappings: {} };
+            const result = validators_1.LoadValidators.ValidateLineSheetLoadFile(lineSheetData, config);
+            expect(result.errors).toContain('"name" is required in the config file and must be mapped to Item Family Name');
+        });
+        it('should return a warning if optionName is not mapped in federatedMappings', () => {
+            const lineSheetData = [{ header1: 'value1' }];
+            const config = {
+                loadType: ['ITEM'],
+                federatedMappings: {
+                    name: 'header1',
+                    itemFamilyFederatedId: 'someId',
+                },
+            };
+            const result = validators_1.LoadValidators.ValidateLineSheetLoadFile(lineSheetData, config);
+            expect(result.warnings).toContain('"optionName" is not mapped in the config file');
+        });
+        it('should return an error if itemFamilyFederatedId is not mapped in federatedMappings', () => {
+            const lineSheetData = [{ header1: 'value1' }];
+            const config = {
+                loadType: ['ITEM'],
+                federatedMappings: {
+                    name: 'header1',
+                },
+            };
+            const result = validators_1.LoadValidators.ValidateLineSheetLoadFile(lineSheetData, config);
+            expect(result.errors).toContain('"itemFamilyFederatedId" is required in the config file');
+        });
+        it('should return a warning if itemOptionFederatedId is not mapped in federatedMappings', () => {
+            const lineSheetData = [{ header1: 'value1' }];
+            const config = {
+                loadType: ['ITEM'],
+                federatedMappings: {
+                    name: 'header1',
+                    itemFamilyFederatedId: 'someId',
+                },
+            };
+            const result = validators_1.LoadValidators.ValidateLineSheetLoadFile(lineSheetData, config);
+            expect(result.warnings).toContain('"itemOptionFederatedId" is not mapped in the config file');
+        });
+        it('should return an error if itemFamilyFederatedId is missing in the CSV file', () => {
+            const lineSheetData = [{ header1: 'value1', itemFamilyFederatedId: 'someId' }];
+            const config = {
+                loadType: ['ITEM'],
+                federatedMappings: {
+                    name: 'header1',
+                    itemFamilyFederatedId: null,
+                },
+            };
+            const result = validators_1.LoadValidators.ValidateLineSheetLoadFile(lineSheetData, config);
+            expect(result.errors).toContain(`itemFamilyFederatedId column (${config?.federatedMappings?.itemFamilyFederatedId}) not found in the CSV file`);
+        });
+        it('should return an error if itemFamilyFederatedId is null or undefined or empty in lineSheetData', () => {
+            const lineSheetData = [
+                { header1: 'value1', itemFamilyFederatedId: null },
+                { header1: 'value2', itemFamilyFederatedId: undefined },
+                { header1: 'value3', itemFamilyFederatedId: 'valid' },
+                { header1: 'value4', itemFamilyFederatedId: '' },
+            ];
+            const config = {
+                loadType: ['ITEM'],
+                federatedMappings: {
+                    name: 'header1',
+                    itemFamilyFederatedId: 'itemFamilyFederatedId',
+                },
+            };
+            const result = validators_1.LoadValidators.ValidateLineSheetLoadFile(lineSheetData, config);
+            expect(result.errors).toContain('some rows contain itemFamilyFederatedId is null or undefined or empty in the CSV file (rows 0,1,3)');
+        });
+        it('should return errors if duplicate itemFamilyFederatedId is found in lineSheetData', () => {
+            const lineSheetData = [
+                {
+                    header1: 'value1',
+                    itemFamilyFederatedId: '1',
+                },
+                {
+                    header1: 'value2',
+                    itemFamilyFederatedId: '1',
+                },
+                {
+                    header1: 'value3',
+                    itemFamilyFederatedId: '2',
+                },
+            ];
+            const config = {
+                loadType: ['ITEM'],
+                federatedMappings: {
+                    name: 'header1',
+                    itemFamilyFederatedId: 'itemFamilyFederatedId',
+                },
+            };
+            const result = validators_1.LoadValidators.ValidateLineSheetLoadFile(lineSheetData, config);
+            expect(result.errors).toContain('Found conflicting fields for family federated Ids: (1: (value1, value2))');
+        });
+        it('should allow for the same itemFamilyFederatedId if the names are the same', () => {
+            const lineSheetData = [
+                {
+                    itemName: 'foo',
+                    itemFamilyFederatedId: '1',
+                },
+                {
+                    itemName: 'foo',
+                    itemFamilyFederatedId: '1',
+                },
+                {
+                    itemName: 'bar',
+                    itemFamilyFederatedId: '2',
+                },
+            ];
+            const config = {
+                loadType: ['ITEM'],
+                federatedMappings: {
+                    name: 'itemName',
+                    itemFamilyFederatedId: 'itemFamilyFederatedId',
+                },
+            };
+            const result = validators_1.LoadValidators.ValidateLineSheetLoadFile(lineSheetData, config);
+            expect(result.errors.length).toBe(0);
+        });
+        it('should find error if itemFamilyFederatedId is duplicated across different names', () => {
+            const lineSheetData = [
+                {
+                    itemName: 'foo',
+                    itemFamilyFederatedId: '1',
+                },
+                {
+                    itemName: 'bar',
+                    itemFamilyFederatedId: '1',
+                },
+                {
+                    itemName: 'baz',
+                    itemFamilyFederatedId: '2',
+                },
+            ];
+            const config = {
+                loadType: ['ITEM'],
+                federatedMappings: {
+                    name: 'itemName',
+                    itemFamilyFederatedId: 'itemFamilyFederatedId',
+                },
+            };
+            const result = validators_1.LoadValidators.ValidateLineSheetLoadFile(lineSheetData, config);
+            expect(result.errors).toContain('Found conflicting fields for family federated Ids: (1: (foo, bar))');
+        });
+        it('should return warnings if duplicate itemOptionFederatedId is found in lineSheetData', () => {
+            const lineSheetData = [
+                {
+                    header1: 'value1',
+                    itemFamilyFederatedId: '1',
+                    itemOptionFederatedId: '1',
+                    optionName: 'option1',
+                },
+                {
+                    header1: 'value2',
+                    itemFamilyFederatedId: '2',
+                    itemOptionFederatedId: '1',
+                    optionName: 'option2',
+                },
+                {
+                    header1: 'value3',
+                    itemFamilyFederatedId: '3',
+                    itemOptionFederatedId: '2',
+                    optionName: 'option3',
+                },
+            ];
+            const config = {
+                loadType: ['ITEM'],
+                federatedMappings: {
+                    name: 'header1',
+                    itemFamilyFederatedId: 'itemFamilyFederatedId',
+                    itemOptionFederatedId: 'itemOptionFederatedId',
+                    optionName: 'optionName',
+                },
+            };
+            const result = validators_1.LoadValidators.ValidateLineSheetLoadFile(lineSheetData, config);
+            expect(result.errors).toContain('Duplicate itemOptionFederatedId found: 1');
+        });
+    });
+});