@contrail/cli 3.4.5 → 3.4.6-alpha.cffb28e

package/node_modules/@contrail/loader/lib/entities-v2/entity-processor-v2.spec.js

@@ -0,0 +1,973 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const entity_processor_v2_1 = require("./entity-processor-v2");
+const entities_helper_1 = require("../common/entities-helper");
+const entity_builder_helpers_1 = require("../common/entity-builder-helpers");
+const types_1 = require("@contrail/types");
+const entity_types_1 = require("@contrail/entity-types");
+const processor_registry_1 = require("../processor-registry");
+const lodash_1 = require("lodash");
+const util_1 = require("../common/util");
+const color_processor_v2_1 = require("./colors-v2/color-processor-v2");
+const constants_1 = require("../constants");
+jest.mock('../common/entity-builder-helpers');
+jest.mock('../processor-registry');
+jest.mock('@contrail/entity-types');
+jest.mock('../common/entities-helper');
+jest.mock('../common/type-helper');
+jest.mock('lodash', () => ({
+    chunk: jest.fn(),
+}));
+describe('EntityProcessorV2', () => {
+    const mockTypesByPath = {
+        color: {
+            type: {
+                typeProperties: [{ slug: 'federatedId' }, { slug: 'typePath' }, { slug: 'hex' }, { slug: 'name' }],
+            },
+            allPropertiesSlugs: ['federatedId', 'typePath', 'hex', 'name'],
+            typePropertyToValueType: {
+                federatedId: types_1.PropertyType.String,
+                typePath: types_1.PropertyType.String,
+                hex: types_1.PropertyType.String,
+                name: types_1.PropertyType.String,
+            },
+            objectReferenceProperties: [],
+            userListProperties: [],
+        },
+    };
+    const mockData = [
+        { federatedId: '1', typePath: 'color', hex: '#ff0000', name: 'Red' },
+        { federatedId: '2', typePath: 'color', hex: '#00ff00', name: 'Green' },
+    ];
+    const mockProcessor = {
+        processFederatedId: jest.fn().mockImplementation((entity) => entity.federatedId),
+        getTypePath: jest.fn().mockImplementation((row, entityType) => row?.typePath || entityType),
+        validateRow: jest.fn().mockImplementation((entity) => (entity.federatedId ? true : false)),
+        setExtraProperties: jest.fn(),
+        canAddProperty: jest.fn().mockReturnValue(true),
+        processEntitiesProperties: jest.fn().mockReturnValue({ projectId: null }),
+        assignExtraItems: jest.fn().mockReturnValue({
+            itemsByFamilyId: null,
+            sizeRangeWarningsAsStringList: null,
+        }),
+        getFederatedIdKeys: jest.fn().mockReturnValue(['federatedId']),
+        canExtractFederatedIds: jest.fn().mockReturnValue(true),
+        logIncommingEntities: jest.fn(),
+        getEntityTypeForFederatedId: jest.fn(),
+    };
+    let client;
+    let consoleSpy;
+    beforeEach(() => {
+        client = {
+            create: jest.fn(),
+            update: jest.fn(),
+            getAllReferences: jest.fn(),
+            get: jest.fn(),
+            delete: jest.fn(),
+            batchCreate: jest.fn(),
+            batchUpdate: jest.fn(),
+            batchDelete: jest.fn(),
+        };
+        consoleSpy = jest.spyOn(console, 'log').mockImplementation();
+        jest.spyOn(console, 'info').mockImplementation();
+        jest.spyOn(console, 'debug').mockImplementation();
+        jest.spyOn(console, 'error').mockImplementation();
+    });
+    afterEach(() => {
+        consoleSpy.mockRestore();
+        jest.clearAllMocks();
+    });
+    describe('extractFederatedIds', () => {
+        const mockProcessor = {
+            processFederatedId: jest.fn().mockImplementation((federatedId, typePath) => federatedId),
+        };
+        const mockProcessorWithTypePath = {
+            processFederatedId: jest.fn().mockImplementation((federatedId, typePath) => {
+                if (!federatedId.startsWith('custom-entity:')) {
+                    federatedId = typePath + ':' + federatedId;
+                }
+                return federatedId;
+            }),
+        };
+        const federatedIdkeys = ['federatedId'];
+        it('should extract unique and duplicate federatedIds', () => {
+            const incomingEntities = [{ federatedId: '1/abc' }, { federatedId: '2/def' }, { federatedId: '1/abc' }];
+            const result = entity_processor_v2_1.EntityProcessorV2.extractFederatedIds(incomingEntities, mockProcessor, federatedIdkeys);
+            expect(result).toEqual(['1%2Fabc', '2%2Fdef']);
+        });
+        it('should handle entities with no duplicates', () => {
+            const incomingEntities = [{ federatedId: '1/abc' }, { federatedId: '2/def' }, { federatedId: '3/ghi' }];
+            const result = entity_processor_v2_1.EntityProcessorV2.extractFederatedIds(incomingEntities, mockProcessor, federatedIdkeys);
+            expect(result).toEqual(['1%2Fabc', '2%2Fdef', '3%2Fghi']);
+        });
+        it('should handle entities with all duplicates', () => {
+            const incomingEntities = [{ federatedId: '1/abc' }, { federatedId: '1/abc' }, { federatedId: '1/abc' }];
+            const result = entity_processor_v2_1.EntityProcessorV2.extractFederatedIds(incomingEntities, mockProcessor, federatedIdkeys);
+            expect(result).toEqual(['1%2Fabc']);
+        });
+        it('should handle an empty array', () => {
+            const incomingEntities = [];
+            const result = entity_processor_v2_1.EntityProcessorV2.extractFederatedIds(incomingEntities);
+            expect(result).toEqual([]);
+        });
+        it('should handle entities with typePath', () => {
+            const incomingEntities = [{ federatedId: '1/abc', typePath: 'customEntity:material' }];
+            const result = entity_processor_v2_1.EntityProcessorV2.extractFederatedIds(incomingEntities, mockProcessorWithTypePath, federatedIdkeys);
+            expect(result).toEqual(['customEntity:material:1%2Fabc']);
+        });
+    });
+    describe('getTypePaths', () => {
+        it('should return unique type paths', () => {
+            const data = [{ typePath: 'color' }, { typePath: 'color' }, { typePath: 'shape' }];
+            const result = entity_processor_v2_1.EntityProcessorV2.getTypePaths(data, 'defaultType', mockProcessor);
+            expect(result).toEqual(['color', 'shape']);
+        });
+        it('should return default type if typePath is missing', () => {
+            const data = [{ typePath: 'color' }, { typePath: 'shape' }, { someProperty: 'value' }];
+            const result = entity_processor_v2_1.EntityProcessorV2.getTypePaths(data, 'defaultType', mockProcessor);
+            expect(result).toEqual(['color', 'shape', 'defaultType']);
+        });
+        it('should handle an empty array', () => {
+            const data = [];
+            const result = entity_processor_v2_1.EntityProcessorV2.getTypePaths(data, 'defaultType', mockProcessor);
+            expect(result).toEqual([]);
+        });
+        it('should handle an array with one element', () => {
+            const data = [{ typePath: 'color' }];
+            const result = entity_processor_v2_1.EntityProcessorV2.getTypePaths(data, 'defaultType', mockProcessor);
+            expect(result).toEqual(['color']);
+        });
+        it('should handle an array with all elements missing typePath', () => {
+            const data = [{ someProperty: 'value1' }, { someProperty: 'value2' }, { someProperty: 'value3' }];
+            const result = entity_processor_v2_1.EntityProcessorV2.getTypePaths(data, 'defaultType', mockProcessor);
+            expect(result).toEqual(['defaultType']);
+        });
+    });
+    describe('buildIncomingEntities', () => {
+        beforeEach(() => {
+            entity_builder_helpers_1.addProperty.mockImplementation((propertyName, allPropertiesSlugs, valueType, entity, value) => {
+                entity[propertyName] = value;
+            });
+        });
+        it('should build incoming entities', () => {
+            const result = entity_processor_v2_1.EntityProcessorV2.buildIncomingEntities(mockProcessor, mockData, mockTypesByPath, 'color');
+            const returnData = {
+                badEntities: [],
+                incomingEntities: [
+                    {
+                        federatedId: '1',
+                        hex: '#ff0000',
+                        name: 'Red',
+                        typePath: 'color',
+                    },
+                    {
+                        federatedId: '2',
+                        hex: '#00ff00',
+                        name: 'Green',
+                        typePath: 'color',
+                    },
+                ],
+            };
+            expect(result).toEqual(returnData);
+            expect(entity_builder_helpers_1.addProperty).toHaveBeenCalledWith('federatedId', ['federatedId', 'typePath', 'hex', 'name'], types_1.PropertyType.String, { federatedId: '1', typePath: 'color', hex: '#ff0000', name: 'Red' }, '1');
+            expect(entity_builder_helpers_1.addProperty).toHaveBeenCalledWith('typePath', ['federatedId', 'typePath', 'hex', 'name'], types_1.PropertyType.String, { federatedId: '1', typePath: 'color', hex: '#ff0000', name: 'Red' }, 'color');
+            expect(entity_builder_helpers_1.addProperty).toHaveBeenCalledWith('hex', ['federatedId', 'typePath', 'hex', 'name'], types_1.PropertyType.String, { federatedId: '1', typePath: 'color', hex: '#ff0000', name: 'Red' }, '#ff0000');
+            expect(entity_builder_helpers_1.addProperty).toHaveBeenCalledWith('name', ['federatedId', 'typePath', 'hex', 'name'], types_1.PropertyType.String, { federatedId: '1', typePath: 'color', hex: '#ff0000', name: 'Red' }, 'Red');
+        });
+        it('should skip rows without federatedId', () => {
+            const data = [
+                { typePath: 'color', hex: '#ff0000', name: 'Red' },
+                { federatedId: '2', typePath: 'color', hex: '#00ff00', name: 'Green' },
+            ];
+            const result = entity_processor_v2_1.EntityProcessorV2.buildIncomingEntities(mockProcessor, data, mockTypesByPath, 'color');
+            const returnData = {
+                badEntities: [
+                    {
+                        hex: '#ff0000',
+                        name: 'Red',
+                        typePath: 'color',
+                    },
+                ],
+                incomingEntities: [
+                    {
+                        federatedId: '2',
+                        typePath: 'color',
+                        hex: '#00ff00',
+                        name: 'Green',
+                    },
+                ],
+            };
+            expect(result).toEqual(returnData);
+            expect(console.error).toHaveBeenCalledWith('Invalid data found for this row color:', {
+                typePath: 'color',
+                hex: '#ff0000',
+                name: 'Red',
+            });
+        });
+        it('should handle an empty array', () => {
+            const data = [];
+            const result = entity_processor_v2_1.EntityProcessorV2.buildIncomingEntities(mockProcessor, data, mockTypesByPath, 'color');
+            expect(result).toEqual({ badEntities: [], incomingEntities: [] });
+        });
+    });
+    describe('fetchCurrentEntities', () => {
+        it('should fetch and process entities in chunks', async () => {
+            const federatedIds = ['1', '2', '3', '4'];
+            const chunks = [
+                ['1', '2'],
+                ['3', '4'],
+            ];
+            lodash_1.chunk.mockReturnValue(chunks);
+            const mockEntities = [
+                { federatedId: '1', name: 'Entity 1' },
+                { federatedId: '2', name: 'Entity 2' },
+            ];
+            entities_helper_1.retryOnTimeout.mockResolvedValue(mockEntities);
+            const result = await entity_processor_v2_1.EntityProcessorV2.fetchCurrentEntities(client, entity_types_1.EntityType.COLOR, federatedIds);
+            expect(result).toEqual({
+                '1': { federatedId: '1', name: 'Entity 1' },
+                '2': { federatedId: '2', name: 'Entity 2' },
+            });
+            expect(lodash_1.chunk).toHaveBeenCalledWith(federatedIds, 200);
+            expect(entities_helper_1.retryOnTimeout).toHaveBeenCalledTimes(2);
+        });
+        it('should handle empty federatedIds array', async () => {
+            const federatedIds = [];
+            lodash_1.chunk.mockReturnValue([]);
+            const result = await entity_processor_v2_1.EntityProcessorV2.fetchCurrentEntities(client, entity_types_1.EntityType.COLOR, federatedIds);
+            expect(result).toEqual({});
+            expect(entities_helper_1.retryOnTimeout).not.toHaveBeenCalled();
+        });
+        it('should handle API errors and rethrow', async () => {
+            const federatedIds = ['1'];
+            const chunks = [['1']];
+            lodash_1.chunk.mockReturnValue(chunks);
+            const error = new Error('API Error');
+            entities_helper_1.retryOnTimeout.mockRejectedValue(error);
+            await expect(entity_processor_v2_1.EntityProcessorV2.fetchCurrentEntities(client, entity_types_1.EntityType.COLOR, federatedIds)).rejects.toThrow('API Error');
+            expect(console.error).toHaveBeenCalledWith('Failed to fetch color by federatedIds:', error);
+        });
+        it('should handle empty response from API', async () => {
+            const federatedIds = ['1'];
+            const chunks = [['1']];
+            lodash_1.chunk.mockReturnValue(chunks);
+            entities_helper_1.retryOnTimeout.mockResolvedValue([]);
+            const result = await entity_processor_v2_1.EntityProcessorV2.fetchCurrentEntities(client, entity_types_1.EntityType.COLOR, federatedIds);
+            expect(result).toEqual({});
+        });
+        it('should process multiple chunks correctly', async () => {
+            const federatedIds = ['1', '2', '3', '4'];
+            const chunks = [
+                ['1', '2'],
+                ['3', '4'],
+            ];
+            lodash_1.chunk.mockReturnValue(chunks);
+            const mockEntities1 = [
+                { federatedId: '1', name: 'Entity 1' },
+                { federatedId: '2', name: 'Entity 2' },
+            ];
+            const mockEntities2 = [
+                { federatedId: '3', name: 'Entity 3' },
+                { federatedId: '4', name: 'Entity 4' },
+            ];
+            entities_helper_1.retryOnTimeout.mockResolvedValueOnce(mockEntities1).mockResolvedValueOnce(mockEntities2);
+            const result = await entity_processor_v2_1.EntityProcessorV2.fetchCurrentEntities(client, entity_types_1.EntityType.COLOR, federatedIds);
+            expect(result).toEqual({
+                '1': { federatedId: '1', name: 'Entity 1' },
+                '2': { federatedId: '2', name: 'Entity 2' },
+                '3': { federatedId: '3', name: 'Entity 3' },
+                '4': { federatedId: '4', name: 'Entity 4' },
+            });
+        });
+    });
+    describe('constructEntities', () => {
+        const loaderProcess = {
+            id: 'mock-loader-process-id',
+            loadFileId: 'mock-load-file-id',
+            loadType: [entity_types_1.LoadType.COLOR],
+            status: entity_types_1.LoadStatus.COMPLETE,
+            federatedMappings: {
+                federatedId: 'name',
+                name: 'name',
+            },
+            conditionalColumns: [
+                {
+                    toProperty: 'typePath',
+                    default: 'color',
+                },
+            ],
+        };
+        it('should handle empty data', async () => {
+            const result = await entity_processor_v2_1.EntityProcessorV2.constructEntities({
+                client,
+                processor: mockProcessor,
+                entityType: entity_types_1.EntityType.COLOR,
+                requiredProperties: [],
+                data: [],
+                entitySpecificProperties: null,
+                itemsByFederatedId: {},
+                typesByTypePath: {},
+            });
+            expect(result).toEqual({
+                incomingEntities: [],
+                badEntities: [],
+                allCurrentEntitiesByFederatedId: {},
+                projectId: null,
+                typesByPath: [],
+            });
+            expect(console.debug).toHaveBeenCalledWith('No data to upload');
+        });
+        it('should process and load objects successfully', async () => {
+            const data = [{ federatedId: '1', typePath: 'color', hex: '#ff0000' }];
+            const typesByPath = {
+                color: {
+                    type: {
+                        typeProperties: [{ slug: 'federatedId' }, { slug: 'typePath' }, { slug: 'hex' }],
+                    },
+                    allPropertiesSlugs: ['federatedId', 'typePath', 'hex'],
+                    typePropertyToValueType: { hex: types_1.PropertyType.String },
+                    objectReferenceProperties: [],
+                    userListProperties: [],
+                },
+            };
+            entity_processor_v2_1.EntityProcessorV2.getTypePaths = jest.fn().mockReturnValue(['color']);
+            entity_processor_v2_1.EntityProcessorV2.fetchTypesByPath = jest.fn().mockResolvedValue(typesByPath);
+            entity_processor_v2_1.EntityProcessorV2.buildIncomingEntities = jest
+                .fn()
+                .mockReturnValue({ incomingEntities: data, badEntities: [] });
+            entity_processor_v2_1.EntityProcessorV2.extractFederatedIds = jest.fn().mockReturnValue(['1']);
+            entity_processor_v2_1.EntityProcessorV2.fetchCurrentEntities = jest.fn().mockResolvedValue({
+                '1': { federatedId: '1', hex: '#ff0000' },
+            });
+            entity_processor_v2_1.EntityProcessorV2.getEntityTypeForFederatedId = jest.fn().mockReturnValue(entity_types_1.EntityType.COLOR);
+            entities_helper_1.assignObjectReferences.mockResolvedValue(undefined);
+            const result = await entity_processor_v2_1.EntityProcessorV2.constructEntities({
+                client,
+                processor: mockProcessor,
+                entityType: entity_types_1.EntityType.COLOR,
+                requiredProperties: ['federatedId', 'hex'],
+                data,
+                entitySpecificProperties: null,
+                itemsByFederatedId: {},
+                typesByTypePath: undefined,
+            });
+            expect(result).toEqual({
+                incomingEntities: data,
+                badEntities: [],
+                allCurrentEntitiesByFederatedId: {
+                    '1': { federatedId: '1', hex: '#ff0000' },
+                },
+                typesByPath: typesByPath,
+                projectId: null,
+                generalWarnings: undefined,
+                itemsByFamilyId: null,
+                sizeRangeWarningsAsStringList: null,
+            });
+            expect(entity_processor_v2_1.EntityProcessorV2.getTypePaths).toHaveBeenCalledWith(data, entity_types_1.EntityType.COLOR, mockProcessor);
+            expect(entity_processor_v2_1.EntityProcessorV2.fetchTypesByPath).toHaveBeenCalledWith({
+                client,
+                typePaths: ['color'],
+                requiredProperties: ['federatedId', 'hex'],
+                entityType: entity_types_1.EntityType.COLOR,
+                typesByTypePath: undefined,
+            });
+            expect(entity_processor_v2_1.EntityProcessorV2.buildIncomingEntities).toHaveBeenCalledWith(mockProcessor, data, typesByPath, entity_types_1.EntityType.COLOR);
+            expect(entities_helper_1.assignObjectReferences).toHaveBeenCalledWith(client, ['color'], typesByPath, data);
+            expect(entity_processor_v2_1.EntityProcessorV2.extractFederatedIds).toHaveBeenCalledWith(data, mockProcessor, ['federatedId']);
+            expect(entity_processor_v2_1.EntityProcessorV2.fetchCurrentEntities).toHaveBeenCalled();
+        });
+        it('should return empty result when buildIncomingEntities returns empty array', async () => {
+            const data = [{ federatedId: '1', typePath: 'color', hex: '#ff0000' }];
+            const typesByPath = {
+                color: {
+                    type: {
+                        typeProperties: [{ slug: 'federatedId' }, { slug: 'typePath' }, { slug: 'hex' }],
+                    },
+                    allPropertiesSlugs: ['federatedId', 'typePath', 'hex'],
+                    typePropertyToValueType: { hex: types_1.PropertyType.String },
+                    objectReferenceProperties: [],
+                    userListProperties: [],
+                },
+            };
+            entity_processor_v2_1.EntityProcessorV2.getTypePaths = jest.fn().mockReturnValue(['color']);
+            entity_processor_v2_1.EntityProcessorV2.fetchTypesByPath = jest.fn().mockResolvedValue(typesByPath);
+            entity_processor_v2_1.EntityProcessorV2.buildIncomingEntities = jest
+                .fn()
+                .mockReturnValue({ badEntities: [], incomingEntities: [] });
+            const result = await entity_processor_v2_1.EntityProcessorV2.constructEntities({
+                client,
+                processor: mockProcessor,
+                entityType: entity_types_1.EntityType.COLOR,
+                requiredProperties: ['federatedId', 'hex'],
+                data,
+            });
+            expect(result).toEqual({
+                incomingEntities: [],
+                badEntities: [],
+                allCurrentEntitiesByFederatedId: {},
+                projectId: null,
+                typesByPath: [],
+            });
+        });
+        it('should handle undefined data parameter', async () => {
+            const result = await entity_processor_v2_1.EntityProcessorV2.constructEntities({
+                client,
+                processor: mockProcessor,
+                entityType: entity_types_1.EntityType.COLOR,
+                requiredProperties: [],
+            });
+            expect(result).toEqual({
+                incomingEntities: [],
+                badEntities: [],
+                allCurrentEntitiesByFederatedId: {},
+                projectId: null,
+                typesByPath: [],
+            });
+        });
+    });
+    describe('setupEntities', () => {
+        it('should process and load objects successfully', async () => {
+            const rawData = [{ id: 1, name: 'test' }];
+            const mockProcessor = {
+                transformData: jest.fn().mockReturnValue(rawData),
+                requiredProperties: ['id', 'name'],
+            };
+            processor_registry_1.getProcessorForEntityType.mockReturnValue(mockProcessor);
+            entity_processor_v2_1.EntityProcessorV2.constructEntities = jest.fn().mockResolvedValue({
+                incomingEntities: rawData,
+                badEntities: [],
+                allCurrentEntitiesByFederatedId: {},
+            });
+            const result = await entity_processor_v2_1.EntityProcessorV2.setupEntities(client, entity_types_1.EntityType.COLOR, rawData);
+            expect(result).toEqual({
+                incomingEntities: rawData,
+                badEntities: [],
+                allCurrentEntitiesByFederatedId: {},
+            });
+            expect(mockProcessor.transformData).toHaveBeenCalledWith(rawData);
+            expect(entity_processor_v2_1.EntityProcessorV2.constructEntities).toHaveBeenCalledWith({
+                client,
+                processor: mockProcessor,
+                entityType: entity_types_1.EntityType.COLOR,
+                requiredProperties: ['id', 'name'],
+                data: rawData,
+                entitySpecificProperties: undefined,
+                itemsByFederatedId: {},
+                typesByTypePath: undefined,
+            });
+        });
+        it('should handle errors and return raw data', async () => {
+            const rawData = [{ id: 1, name: 'test' }];
+            const error = new Error('Test error');
+            processor_registry_1.getProcessorForEntityType.mockImplementation(() => {
+                throw error;
+            });
+            const result = await entity_processor_v2_1.EntityProcessorV2.setupEntities(client, entity_types_1.EntityType.COLOR, rawData);
+            expect(result).toEqual({
+                incomingEntities: rawData,
+                badEntities: [],
+                allCurrentEntitiesByFederatedId: {},
+                projectId: null,
+                typesByPath: [],
+            });
+            expect(console.error).toHaveBeenCalledWith('Error processing and loading objects for color:', error);
+        });
+        it('should handle undefined required properties', async () => {
+            const rawData = [{ id: 1, name: 'test' }];
+            const mockProcessor = {
+                transformData: jest.fn().mockReturnValue(rawData),
+                requiredProperties: undefined,
+            };
+            processor_registry_1.getProcessorForEntityType.mockReturnValue(mockProcessor);
+            entity_processor_v2_1.EntityProcessorV2.constructEntities = jest.fn().mockResolvedValue({
+                incomingEntities: rawData,
+                badEntities: [],
+                allCurrentEntitiesByFederatedId: {},
+            });
+            const result = await entity_processor_v2_1.EntityProcessorV2.setupEntities(client, entity_types_1.EntityType.COLOR, rawData);
+            expect(result).toEqual({
+                incomingEntities: rawData,
+                badEntities: [],
+                allCurrentEntitiesByFederatedId: {},
+            });
+            expect(entity_processor_v2_1.EntityProcessorV2.constructEntities).toHaveBeenCalledWith({
+                client,
+                processor: mockProcessor,
+                entityType: entity_types_1.EntityType.COLOR,
+                requiredProperties: [],
+                data: rawData,
+                entitySpecificProperties: undefined,
+                itemsByFederatedId: {},
+                typesByTypePath: undefined,
+            });
+        });
+        it('should handle empty raw data', async () => {
+            const rawData = [];
+            const mockProcessor = {
+                transformData: jest.fn().mockReturnValue([]),
+                requiredProperties: ['id', 'name'],
+            };
+            processor_registry_1.getProcessorForEntityType.mockReturnValue(mockProcessor);
+            entity_processor_v2_1.EntityProcessorV2.constructEntities = jest.fn().mockResolvedValue({
+                incomingEntities: [],
+                badEntities: [],
+                allCurrentEntitiesByFederatedId: {},
+            });
+            const result = await entity_processor_v2_1.EntityProcessorV2.setupEntities(client, entity_types_1.EntityType.COLOR, rawData);
+            expect(result).toEqual({
+                incomingEntities: [],
+                badEntities: [],
+                allCurrentEntitiesByFederatedId: {},
+            });
+        });
+    });
+    describe('getUniqueAndDuplicateEntries', () => {
+        it('should return unique and duplicate entries', () => {
+            const strings = ['1', '2', '1', '3', '2'];
+            const result = entity_processor_v2_1.EntityProcessorV2.getUniqueAndDuplicateEntries(strings);
+            expect(result).toEqual({
+                uniqueFedIds: ['1', '2', '3'],
+                nonUniqueFedIds: ['1', '2'],
+            });
+        });
+        it('should return all unique entries when there are no duplicates', () => {
+            const strings = ['1', '2', '3'];
+            const result = entity_processor_v2_1.EntityProcessorV2.getUniqueAndDuplicateEntries(strings);
+            expect(result).toEqual({
+                uniqueFedIds: ['1', '2', '3'],
+                nonUniqueFedIds: [],
+            });
+        });
+        it('should return all duplicate entries when all are duplicates', () => {
+            const strings = ['1', '1', '1'];
+            const result = entity_processor_v2_1.EntityProcessorV2.getUniqueAndDuplicateEntries(strings);
+            expect(result).toEqual({
+                uniqueFedIds: ['1'],
+                nonUniqueFedIds: ['1'],
+            });
+        });
+        it('should handle an empty array', () => {
+            const strings = [];
+            const result = entity_processor_v2_1.EntityProcessorV2.getUniqueAndDuplicateEntries(strings);
+            expect(result).toEqual({
+                uniqueFedIds: [],
+                nonUniqueFedIds: [],
+            });
+        });
+        it('should handle an array with one element', () => {
+            const strings = ['1'];
+            const result = entity_processor_v2_1.EntityProcessorV2.getUniqueAndDuplicateEntries(strings);
+            expect(result).toEqual({
+                uniqueFedIds: ['1'],
+                nonUniqueFedIds: [],
+            });
+        });
+    });
+    describe('validateLoadFile', () => {
+        const loaderProcess = {
+            id: 'mock-loader-process-id',
+            loadFileId: 'mock-load-file-id',
+            loadType: [entity_types_1.LoadType.COLOR],
+            status: entity_types_1.LoadStatus.COMPLETE,
+            federatedMappings: {
+                federatedId: 'name',
+                name: 'name',
+            },
+            conditionalColumns: [
+                {
+                    toProperty: 'typePath',
+                    default: 'color',
+                },
+            ],
+        };
+        it('should return error if no config file provided', () => {
+            const data = [{ name: 'color1' }];
+            const result = entity_processor_v2_1.EntityProcessorV2.validateLoadFile(data, null, entity_types_1.LoadType.COLOR);
+            expect(result.generalErrors).toEqual([
+                {
+                    message: 'Config file is empty',
+                    issueType: entity_types_1.IssueType.CONFIG,
+                },
+            ]);
+        });
+        it('should return error if loadType is missing', () => {
+            const data = [{ name: 'color1' }];
+            const config = {
+                ...loaderProcess,
+                loadType: [],
+            };
+            const result = entity_processor_v2_1.EntityProcessorV2.validateLoadFile(data, config);
+            expect(result.generalErrors).toEqual([
+                {
+                    message: '"loadType" is required in the config file',
+                    issueType: entity_types_1.IssueType.CONFIG,
+                },
+            ]);
+        });
+        it('should throw error if loadType is invalid', () => {
+            const data = [{ name: 'color1' }];
+            const config = {
+                ...loaderProcess,
+                loadType: ['COLOR1'],
+            };
+            const result = color_processor_v2_1.ColorProcessorV2.validateLoadFile(data, config);
+            expect(result.generalErrors).toEqual([
+                {
+                    message: '"loadType" must be single value "COLOR" in the config file',
+                    issueType: entity_types_1.IssueType.CONFIG,
+                },
+            ]);
+        });
+        describe('federatedId validation', () => {
+            it('should validate federatedId in conditional columns', () => {
+                const data = [{ name: 'test1' }];
+                const config = {
+                    ...loaderProcess,
+                    conditionalColumns: [
+                        {
+                            toProperty: 'federatedId',
+                            default: 'test-{name}',
+                        },
+                    ],
+                };
+                const result = entity_processor_v2_1.EntityProcessorV2.validateLoadFile(data, config);
+                expect(result.generalErrors).not.toContainEqual({
+                    message: constants_1.ENTITY_PROCESSOR_ERRORS.FEDERATED_ID_REQUIRED,
+                    issueType: entity_types_1.IssueType.CONFIG,
+                });
+            });
+            it('should validate federatedId in CSV data', () => {
+                const data = [{ federatedId: 'test1', name: 'Test 1' }];
+                const result = entity_processor_v2_1.EntityProcessorV2.validateLoadFile(data, loaderProcess);
+                expect(result.generalErrors).not.toContainEqual({
+                    message: constants_1.ENTITY_PROCESSOR_ERRORS.FEDERATED_ID_REQUIRED,
+                    issueType: entity_types_1.IssueType.CONFIG,
+                });
+            });
+            it('should validate federatedId in federatedMapping', () => {
+                const data = [{ code: 'test1', name: 'Test 1' }];
+                const config = {
+                    ...loaderProcess,
+                    federatedMappings: {
+                        federatedId: 'code',
+                    },
+                };
+                const result = entity_processor_v2_1.EntityProcessorV2.validateLoadFile(data, config);
+                expect(result.generalErrors).not.toContainEqual({
+                    message: constants_1.ENTITY_PROCESSOR_ERRORS.FEDERATED_ID_REQUIRED,
+                    issueType: entity_types_1.IssueType.CONFIG,
+                });
+            });
+            it('should return error if federated id is missing in federatedmapping config, csv header and conditional column', () => {
+                const data = [{ name: 'color1' }];
+                const config = {
+                    id: 'mock-loader-process-id',
+                    loadFileId: 'mock-load-file-id',
+                    loadType: [entity_types_1.LoadType.COLOR],
+                    status: entity_types_1.LoadStatus.COMPLETE,
+                    conditionalColumns: [
+                        {
+                            toProperty: 'typePath',
+                            default: 'color',
+                        },
+                    ],
+                    federatedMapping: {
+                        name: 'name',
+                    },
+                    ignoreParameters: { ignoreFamilyNameOnUpdate: false, ignoreOptionNameOnUpdate: false },
+                    shouldSkipAssortmentPublish: false,
+                };
+                const result = entity_processor_v2_1.EntityProcessorV2.validateLoadFile(data, config);
+                expect(result.generalErrors).toEqual([
+                    {
+                        message: constants_1.ENTITY_PROCESSOR_ERRORS.FEDERATED_ID_REQUIRED,
+                        issueType: entity_types_1.IssueType.CONFIG,
+                    },
+                ]);
+            });
+            it('should return error if federatedmapping object is missing', () => {
+                const data = [{ name: 'color1' }];
+                const config = {
+                    id: 'mock-loader-process-id',
+                    loadFileId: 'mock-load-file-id',
+                    loadType: [entity_types_1.LoadType.CUSTOM_ENTITY],
+                    status: entity_types_1.LoadStatus.COMPLETE,
+                    conditionalColumns: [
+                        {
+                            toProperty: 'typePath',
+                            default: 'color',
+                        },
+                    ],
+                    ignoreParameters: { ignoreFamilyNameOnUpdate: false, ignoreOptionNameOnUpdate: false },
+                    shouldSkipAssortmentPublish: false,
+                };
+                const result = entity_processor_v2_1.EntityProcessorV2.validateLoadFile(data, config);
+                expect(result.generalErrors).toEqual([
+                    {
+                        message: constants_1.ENTITY_PROCESSOR_ERRORS.FEDERATED_ID_REQUIRED,
+                        issueType: entity_types_1.IssueType.CONFIG,
+                    },
+                ]);
+            });
+            it('should return error if federatedId column is not found in the CSV file', () => {
+                const data = [{ name: 'custom-entity1' }];
+                const config = {
+                    ...loaderProcess,
+                    loadType: [entity_types_1.LoadType.CUSTOM_ENTITY],
+                    federatedMappings: { federatedId: 'missingId', name: 'name' },
+                };
+                const result = entity_processor_v2_1.EntityProcessorV2.validateLoadFile(data, config);
+                expect(result.generalErrors).toEqual([
+                    {
+                        message: constants_1.ENTITY_PROCESSOR_ERRORS.FEDERATED_ID_REQUIRED,
+                        issueType: entity_types_1.IssueType.CONFIG,
+                    },
+                ]);
+            });
+            it('should not return error if federatedId is present in CSV headers but missing in config and conditional column', () => {
+                const data = [{ federatedId: 'custom-entity1', name: 'custom-entity1' }];
+                const config = {
+                    ...loaderProcess,
+                    loadType: [entity_types_1.LoadType.CUSTOM_ENTITY],
+                    federatedMappings: { name: 'name' },
+                };
+                const result = entity_processor_v2_1.EntityProcessorV2.validateLoadFile(data, config);
+                expect(result.generalErrors).toEqual([]);
+            });
+        });
+        describe('name validation', () => {
+            it('should validate name in conditional columns', () => {
+                const data = [{ federatedId: 'test1' }];
+                const config = {
+                    ...loaderProcess,
+                    federatedMappings: {},
+                    conditionalColumns: [
+                        {
+                            toProperty: 'name',
+                            default: 'Test {federatedId}',
+                        },
+                    ],
+                };
+                const result = entity_processor_v2_1.EntityProcessorV2.validateLoadFile(data, config);
+                console.log(JSON.stringify(result, null, 2));
+                expect(result.generalErrors).not.toContainEqual({
+                    message: constants_1.ENTITY_PROCESSOR_ERRORS.NAME_REQUIRED,
+                    issueType: entity_types_1.IssueType.CONFIG,
+                });
+            });
+            it('should validate name in CSV data', () => {
+                const data = [{ federatedId: 'test1', name: 'Test 1' }];
+                const result = entity_processor_v2_1.EntityProcessorV2.validateLoadFile(data, loaderProcess);
+                expect(result.generalErrors).not.toContainEqual({
+                    message: constants_1.ENTITY_PROCESSOR_ERRORS.NAME_REQUIRED,
+                    issueType: entity_types_1.IssueType.CONFIG,
+                });
+            });
+            it('should validate name in federatedMapping', () => {
+                const data = [{ federatedId: 'test1', display_name: 'Test 1' }];
+                const config = {
+                    ...loaderProcess,
+                    federatedMappings: {
+                        name: 'display_name',
+                    },
+                };
+                const result = entity_processor_v2_1.EntityProcessorV2.validateLoadFile(data, config);
+                expect(result.generalErrors).not.toContainEqual({
+                    message: constants_1.ENTITY_PROCESSOR_ERRORS.NAME_REQUIRED,
+                    issueType: entity_types_1.IssueType.CONFIG,
+                });
+            });
+            it('should return error if name is missing in federatedMappings, config and conditional column', () => {
+                const data = [{ id: 'custom-entity1' }];
+                const config = {
+                    ...loaderProcess,
+                    loadType: [entity_types_1.LoadType.CUSTOM_ENTITY],
+                    federatedMappings: { federatedId: 'id' },
+                };
+                const result = entity_processor_v2_1.EntityProcessorV2.validateLoadFile(data, config);
+                expect(result.generalErrors).toEqual([
+                    {
+                        message: constants_1.ENTITY_PROCESSOR_ERRORS.NAME_REQUIRED,
+                        issueType: entity_types_1.IssueType.CONFIG,
+                    },
+                ]);
+            });
+            it('should return error if name column is not found in the CSV file', () => {
+                const data = [{ federatedId: 'color1' }];
+                const config = {
+                    ...loaderProcess,
+                    federatedMappings: {
+                        federatedId: 'federatedId',
+                        name: 'missingName',
+                    },
+                };
+                const result = entity_processor_v2_1.EntityProcessorV2.validateLoadFile(data, config);
+                expect(result.generalErrors).toEqual([
+                    {
+                        message: constants_1.ENTITY_PROCESSOR_ERRORS.NAME_REQUIRED,
+                        issueType: entity_types_1.IssueType.CONFIG,
+                    },
+                ]);
+            });
+            it('should not return error if name is present in CSV headers but missing in config and conditional column', () => {
+                const data = [{ federatedId: 'id1', name: 'color1' }];
+                const config = {
+                    ...loaderProcess,
+                    federatedMappings: { federatedId: 'federatedId' },
+                };
+                const result = entity_processor_v2_1.EntityProcessorV2.validateLoadFile(data, config);
+                expect(result.generalErrors).toEqual([]);
+            });
+            it('should handle mixed validation scenarios', () => {
+                const data = [{ code: 'test1', display_name: 'Test 1' }];
+                const config = {
+                    ...loaderProcess,
+                    federatedMappings: {
+                        federatedId: 'code',
+                    },
+                    conditionalColumns: [
+                        {
+                            toProperty: 'name',
+                            default: '{display_name}',
+                        },
+                    ],
+                };
+                const result = entity_processor_v2_1.EntityProcessorV2.validateLoadFile(data, config);
+                expect(result.generalErrors).toHaveLength(0);
+            });
+        });
+        describe('skipStaleUpdatesUsing validation', () => {
+            it('should not return error when skipStaleUpdatesUsing is not specified', () => {
+                const data = [{ federatedId: 'test1', name: 'Test 1' }];
+                const config = {
+                    ...loaderProcess,
+                };
+                const result = entity_processor_v2_1.EntityProcessorV2.validateLoadFile(data, config);
+                expect(result.generalErrors).not.toContainEqual(expect.objectContaining({
+                    message: expect.stringContaining('skipStaleUpdatesUsing'),
+                }));
+                expect(result.returnImmediately).toBe(false);
+            });
+            it('should validate skipStaleUpdatesUsing column exists in CSV', () => {
+                const data = [{ federatedId: 'test1', name: 'Test 1', lastModified: '2024-01-01' }];
+                const config = {
+                    ...loaderProcess,
+                    skipStaleUpdatesUsing: 'lastModified',
+                };
+                const result = entity_processor_v2_1.EntityProcessorV2.validateLoadFile(data, config);
+                expect(result.generalErrors).not.toContainEqual(expect.objectContaining({
+                    message: expect.stringContaining('skipStaleUpdatesUsing'),
+                }));
+                expect(result.returnImmediately).toBe(false);
+            });
+            it('should validate skipStaleUpdatesUsing column exists in federatedMappings', () => {
+                const data = [{ federatedId: 'test1', name: 'Test 1', modified_date: '2024-01-01' }];
+                const config = {
+                    ...loaderProcess,
+                    skipStaleUpdatesUsing: 'lastModified',
+                    federatedMappings: {
+                        lastModified: 'modified_date',
+                    },
+                };
+                const result = entity_processor_v2_1.EntityProcessorV2.validateLoadFile(data, config);
+                expect(result.generalErrors).not.toContainEqual(expect.objectContaining({
+                    message: expect.stringContaining('skipStaleUpdatesUsing'),
+                }));
+            });
+            it('should validate skipStaleUpdatesUsing column exists in conditionalColumns', () => {
+                const data = [{ federatedId: 'test1', name: 'Test 1' }];
+                const config = {
+                    ...loaderProcess,
+                    skipStaleUpdatesUsing: 'lastModified',
+                    conditionalColumns: [
+                        {
+                            toProperty: 'lastModified',
+                            default: '2024-01-01',
+                        },
+                    ],
+                };
+                const result = entity_processor_v2_1.EntityProcessorV2.validateLoadFile(data, config);
+                expect(result.generalErrors).not.toContainEqual(expect.objectContaining({
+                    message: expect.stringContaining('skipStaleUpdatesUsing'),
+                }));
+            });
+            it('should return error when skipStaleUpdatesUsing column not found', () => {
+                const data = [{ federatedId: 'test1', name: 'Test 1' }];
+                const config = {
+                    ...loaderProcess,
+                    skipStaleUpdatesUsing: 'lastModified',
+                };
+                const result = entity_processor_v2_1.EntityProcessorV2.validateLoadFile(data, config);
+                expect(result.generalErrors).toContainEqual({
+                    message: "skipStaleUpdatesUsing column 'lastModified' not found in CSV headers, federated mappings, or conditional columns",
+                    issueType: entity_types_1.IssueType.CONFIG,
+                });
+                expect(result.returnImmediately).toBe(true);
+            });
+            it('should return error when skipStaleUpdatesUsing is not a string', () => {
+                const data = [{ federatedId: 'test1', name: 'Test 1' }];
+                const config = {
+                    ...loaderProcess,
+                    skipStaleUpdatesUsing: ['lastModified'],
+                };
+                const result = entity_processor_v2_1.EntityProcessorV2.validateLoadFile(data, config);
+                expect(result.generalErrors).toContainEqual({
+                    message: 'skipStaleUpdatesUsing must be a string column name, received: object',
+                    issueType: entity_types_1.IssueType.CONFIG,
+                });
+                expect(result.returnImmediately).toBe(true);
+            });
+            it('should return error when skipStaleUpdatesUsing mapped column not in CSV', () => {
+                const data = [{ federatedId: 'test1', name: 'Test 1' }];
+                const config = {
+                    ...loaderProcess,
+                    skipStaleUpdatesUsing: 'lastModified',
+                    federatedMappings: {
+                        lastModified: 'missing_column',
+                    },
+                };
+                const result = entity_processor_v2_1.EntityProcessorV2.validateLoadFile(data, config);
+                expect(result.generalErrors).toContainEqual({
+                    message: "skipStaleUpdatesUsing column 'lastModified' is mapped to 'missing_column' but that column is not in the CSV",
+                    issueType: entity_types_1.IssueType.CONFIG,
+                });
+                expect(result.returnImmediately).toBe(true);
+            });
+        });
+    });
+    describe('getDuplicateFederatedIds', () => {
+        it('should return duplicate federated IDs', () => {
+            const data = [{ name: 'color1' }, { name: 'color2' }, { name: 'color1' }];
+            const result = (0, util_1.getDuplicateFederatedIds)(data, 'name');
+            expect(result).toEqual([
+                {
+                    rowNumber: 2,
+                    columnIssues: [
+                        {
+                            columnName: 'name',
+                            message: 'Duplicate federatedId found: color1',
+                            issueType: entity_types_1.IssueType.DUPLICATE_FEDERATED_ID,
+                            data: '{"name":"color1"}',
+                        },
+                    ],
+                },
+                {
+                    rowNumber: 4,
+                    columnIssues: [
+                        {
+                            columnName: 'name',
+                            message: 'Duplicate federatedId found: color1',
+                            issueType: entity_types_1.IssueType.DUPLICATE_FEDERATED_ID,
+                            data: '{"name":"color1"}',
+                        },
+                    ],
+                },
+            ]);
+        });
+        it('should handle no duplicate federated IDs', () => {
+            const data = [{ name: 'color1' }, { name: 'color2' }, { name: 'color3' }];
+            const result = (0, util_1.getDuplicateFederatedIds)(data, 'name');
+            expect(result).toEqual([]);
+        });
+    });
+});