@contrail/cli 3.4.5 → 3.4.6-alpha.cffb28e

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

@@ -0,0 +1,693 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const entity_processor_1 = require("./entity-processor");
+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 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('EntityProcessor', () => {
+    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' },
+    ];
+    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;
+            }),
+        };
+        it('should extract unique and duplicate federatedIds', () => {
+            const incomingEntities = [{ federatedId: '1/abc' }, { federatedId: '2/def' }, { federatedId: '1/abc' }];
+            const result = entity_processor_1.EntityProcessor.extractFederatedIds(incomingEntities, mockProcessor);
+            expect(result).toEqual(['1%2Fabc', '2%2Fdef', '1%2Fabc']);
+        });
+        it('should handle entities with no duplicates', () => {
+            const incomingEntities = [{ federatedId: '1/abc' }, { federatedId: '2/def' }, { federatedId: '3/ghi' }];
+            const result = entity_processor_1.EntityProcessor.extractFederatedIds(incomingEntities, mockProcessor);
+            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_1.EntityProcessor.extractFederatedIds(incomingEntities, mockProcessor);
+            expect(result).toEqual(['1%2Fabc', '1%2Fabc']);
+        });
+        it('should handle an empty array', () => {
+            const incomingEntities = [];
+            const result = entity_processor_1.EntityProcessor.extractFederatedIds(incomingEntities, mockProcessor);
+            expect(result).toEqual([]);
+        });
+        it('should handle entities with typePath', () => {
+            const incomingEntities = [{ federatedId: '1/abc', typePath: 'customEntity:material' }];
+            const result = entity_processor_1.EntityProcessor.extractFederatedIds(incomingEntities, mockProcessorWithTypePath);
+            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_1.EntityProcessor.getTypePaths(data, 'defaultType');
+            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_1.EntityProcessor.getTypePaths(data, 'defaultType');
+            expect(result).toEqual(['color', 'shape', 'defaultType']);
+        });
+        it('should handle an empty array', () => {
+            const data = [];
+            const result = entity_processor_1.EntityProcessor.getTypePaths(data, 'defaultType');
+            expect(result).toEqual([]);
+        });
+        it('should handle an array with one element', () => {
+            const data = [{ typePath: 'color' }];
+            const result = entity_processor_1.EntityProcessor.getTypePaths(data, 'defaultType');
+            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_1.EntityProcessor.getTypePaths(data, 'defaultType');
+            expect(result).toEqual(['defaultType']);
+        });
+    });
+    describe('buildIncomingEntities', () => {
+        const mockProcessor = {
+            validateRow: jest.fn().mockImplementation((entity) => (entity.federatedId ? true : false)),
+            setExtraProperties: jest.fn(),
+        };
+        beforeEach(() => {
+            entity_builder_helpers_1.addProperty.mockImplementation((propertyName, allPropertiesSlugs, valueType, entity, value) => {
+                entity[propertyName] = value;
+            });
+        });
+        it('should build incoming entities', () => {
+            const result = entity_processor_1.EntityProcessor.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_1.EntityProcessor.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_1.EntityProcessor.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_1.EntityProcessor.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_1.EntityProcessor.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_1.EntityProcessor.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_1.EntityProcessor.fetchCurrentEntities(client, entity_types_1.EntityType.COLOR, federatedIds);
+            expect(result).toEqual({});
+            expect(console.info).toHaveBeenCalledWith('color lookup complete. 0 colors retrieved');
+        });
+        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_1.EntityProcessor.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' },
+            });
+            expect(console.info).toHaveBeenCalledWith('color lookup complete. 4 colors retrieved');
+        });
+    });
+    describe('constructEntities', () => {
+        it('should handle empty data', async () => {
+            const result = await entity_processor_1.EntityProcessor.constructEntities(client, entity_types_1.EntityType.COLOR, [], []);
+            expect(result).toEqual({
+                incomingEntities: [],
+                badEntities: [],
+                allCurrentEntitiesByFederatedId: {},
+            });
+            expect(console.debug).toHaveBeenCalledWith('No data to upload');
+        });
+        it('should process and load objects successfully', async () => {
+            const mockProcessor = {
+                validateRow: jest.fn().mockImplementation((federatedId, typePath) => (federatedId ? true : false)),
+                setExtraProperties: jest.fn(),
+            };
+            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_1.EntityProcessor.getTypePaths = jest.fn().mockReturnValue(['color']);
+            entity_processor_1.EntityProcessor.fetchTypesByPath = jest.fn().mockResolvedValue(typesByPath);
+            entity_processor_1.EntityProcessor.buildIncomingEntities = jest
+                .fn()
+                .mockReturnValue({ incomingEntities: data, badEntities: [] });
+            entity_processor_1.EntityProcessor.extractFederatedIds = jest.fn().mockReturnValue(['1']);
+            entity_processor_1.EntityProcessor.fetchCurrentEntities = jest.fn().mockResolvedValue({
+                '1': { federatedId: '1', hex: '#ff0000' },
+            });
+            entities_helper_1.assignObjectReferences.mockResolvedValue(undefined);
+            const result = await entity_processor_1.EntityProcessor.constructEntities(client, mockProcessor, entity_types_1.EntityType.COLOR, ['federatedId', 'hex'], data);
+            expect(result).toEqual({
+                incomingEntities: data,
+                badEntities: [],
+                allCurrentEntitiesByFederatedId: {
+                    '1': { federatedId: '1', hex: '#ff0000' },
+                },
+            });
+            expect(entity_processor_1.EntityProcessor.getTypePaths).toHaveBeenCalledWith(data, entity_types_1.EntityType.COLOR);
+            expect(entity_processor_1.EntityProcessor.fetchTypesByPath).toHaveBeenCalledWith(client, ['color'], ['federatedId', 'hex'], entity_types_1.EntityType.COLOR);
+            expect(entity_processor_1.EntityProcessor.buildIncomingEntities).toHaveBeenCalledWith(mockProcessor, data, typesByPath, entity_types_1.EntityType.COLOR);
+            expect(entities_helper_1.assignObjectReferences).toHaveBeenCalledWith(client, ['color'], typesByPath, data);
+            expect(entity_processor_1.EntityProcessor.extractFederatedIds).toHaveBeenCalledWith(data, mockProcessor);
+            expect(entity_processor_1.EntityProcessor.fetchCurrentEntities).toHaveBeenCalledWith(client, entity_types_1.EntityType.COLOR, ['1']);
+        });
+        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_1.EntityProcessor.getTypePaths = jest.fn().mockReturnValue(['color']);
+            entity_processor_1.EntityProcessor.fetchTypesByPath = jest.fn().mockResolvedValue(typesByPath);
+            entity_processor_1.EntityProcessor.buildIncomingEntities = jest.fn().mockReturnValue([]);
+            const result = await entity_processor_1.EntityProcessor.constructEntities(client, entity_types_1.EntityType.COLOR, ['federatedId', 'hex'], data);
+            expect(result).toEqual({
+                incomingEntities: [],
+                badEntities: [],
+                allCurrentEntitiesByFederatedId: {},
+            });
+        });
+        it('should handle undefined data parameter', async () => {
+            const result = await entity_processor_1.EntityProcessor.constructEntities(client, entity_types_1.EntityType.COLOR, []);
+            expect(result).toEqual({
+                incomingEntities: [],
+                badEntities: [],
+                allCurrentEntitiesByFederatedId: {},
+            });
+        });
+    });
+    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_1.EntityProcessor.constructEntities = jest.fn().mockResolvedValue({
+                incomingEntities: rawData,
+                badEntities: [],
+                allCurrentEntitiesByFederatedId: {},
+            });
+            const result = await entity_processor_1.EntityProcessor.setupEntities(client, entity_types_1.EntityType.COLOR, rawData);
+            expect(result).toEqual({
+                incomingEntities: rawData,
+                badEntities: [],
+                allCurrentEntitiesByFederatedId: {},
+            });
+            expect(mockProcessor.transformData).toHaveBeenCalledWith(rawData);
+            expect(entity_processor_1.EntityProcessor.constructEntities).toHaveBeenCalledWith(client, mockProcessor, entity_types_1.EntityType.COLOR, ['id', 'name'], rawData);
+        });
+        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_1.EntityProcessor.setupEntities(client, entity_types_1.EntityType.COLOR, rawData);
+            expect(result).toEqual({
+                incomingEntities: rawData,
+                badEntities: [],
+                allCurrentEntitiesByFederatedId: {},
+            });
+            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_1.EntityProcessor.constructEntities = jest.fn().mockResolvedValue({
+                incomingEntities: rawData,
+                badEntities: [],
+                allCurrentEntitiesByFederatedId: {},
+            });
+            const result = await entity_processor_1.EntityProcessor.setupEntities(client, entity_types_1.EntityType.COLOR, rawData);
+            expect(result).toEqual({
+                incomingEntities: rawData,
+                badEntities: [],
+                allCurrentEntitiesByFederatedId: {},
+            });
+            expect(entity_processor_1.EntityProcessor.constructEntities).toHaveBeenCalledWith(client, mockProcessor, entity_types_1.EntityType.COLOR, [], rawData);
+        });
+        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_1.EntityProcessor.constructEntities = jest.fn().mockResolvedValue({
+                incomingEntities: [],
+                badEntities: [],
+                allCurrentEntitiesByFederatedId: {},
+            });
+            const result = await entity_processor_1.EntityProcessor.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_1.EntityProcessor.getUniqueAndDuplicateEntries(strings);
+            expect(result).toEqual({
+                uniqueStrings: ['1', '2', '3'],
+                duplicateStrings: ['1', '2'],
+            });
+        });
+        it('should return all unique entries when there are no duplicates', () => {
+            const strings = ['1', '2', '3'];
+            const result = entity_processor_1.EntityProcessor.getUniqueAndDuplicateEntries(strings);
+            expect(result).toEqual({
+                uniqueStrings: ['1', '2', '3'],
+                duplicateStrings: [],
+            });
+        });
+        it('should return all duplicate entries when all are duplicates', () => {
+            const strings = ['1', '1', '1'];
+            const result = entity_processor_1.EntityProcessor.getUniqueAndDuplicateEntries(strings);
+            expect(result).toEqual({
+                uniqueStrings: ['1'],
+                duplicateStrings: ['1'],
+            });
+        });
+        it('should handle an empty array', () => {
+            const strings = [];
+            const result = entity_processor_1.EntityProcessor.getUniqueAndDuplicateEntries(strings);
+            expect(result).toEqual({
+                uniqueStrings: [],
+                duplicateStrings: [],
+            });
+        });
+        it('should handle an array with one element', () => {
+            const strings = ['1'];
+            const result = entity_processor_1.EntityProcessor.getUniqueAndDuplicateEntries(strings);
+            expect(result).toEqual({
+                uniqueStrings: ['1'],
+                duplicateStrings: [],
+            });
+        });
+    });
+    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_1.EntityProcessor.validateLoadFile(data, null, entity_types_1.LoadType.COLOR);
+            expect(result.generalErrors).toEqual([
+                {
+                    message: constants_1.ENTITY_PROCESSOR_ERRORS.CONFIG_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_1.EntityProcessor.validateLoadFile(data, config, entity_types_1.LoadType.COLOR);
+            expect(result.generalErrors).toEqual([
+                {
+                    message: constants_1.ENTITY_PROCESSOR_ERRORS.LOAD_TYPE_REQUIRED,
+                    issueType: entity_types_1.IssueType.CONFIG,
+                },
+            ]);
+        });
+        it('should throw error if loadType is invalid', () => {
+            const data = [{ name: 'color1' }];
+            const config = {
+                ...loaderProcess,
+                loadType: [entity_types_1.LoadType.COLOR],
+            };
+            const result = entity_processor_1.EntityProcessor.validateLoadFile(data, config, entity_types_1.LoadType.CUSTOM_ENTITY);
+            expect(result.generalErrors).toEqual([
+                {
+                    message: constants_1.ENTITY_PROCESSOR_ERRORS.LOAD_TYPE_INVALID(entity_types_1.LoadType.CUSTOM_ENTITY),
+                    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_1.EntityProcessor.validateLoadFile(data, config, entity_types_1.LoadType.COLOR);
+                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_1.EntityProcessor.validateLoadFile(data, loaderProcess, entity_types_1.LoadType.COLOR);
+                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_1.EntityProcessor.validateLoadFile(data, config, entity_types_1.LoadType.COLOR);
+                expect(result.generalErrors).not.toContainEqual({
+                    message: constants_1.ENTITY_PROCESSOR_ERRORS.FEDERATED_ID_REQUIRED,
+                    issueType: entity_types_1.IssueType.CONFIG,
+                });
+            });
+            it('should error when federatedId column from mapping is not in CSV', () => {
+                const data = [{ name: 'Test 1' }];
+                const config = {
+                    ...loaderProcess,
+                    federatedMappings: {
+                        federatedId: 'code',
+                    },
+                };
+                const result = entity_processor_1.EntityProcessor.validateLoadFile(data, config, entity_types_1.LoadType.COLOR);
+                expect(result.generalErrors).toContainEqual({
+                    message: constants_1.ENTITY_PROCESSOR_ERRORS.FEDERATED_ID_REQUIRED,
+                    issueType: entity_types_1.IssueType.CONFIG,
+                });
+            });
+        });
+        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_1.EntityProcessor.validateLoadFile(data, config, entity_types_1.LoadType.COLOR);
+                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_1.EntityProcessor.validateLoadFile(data, loaderProcess, entity_types_1.LoadType.COLOR);
+                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_1.EntityProcessor.validateLoadFile(data, config, entity_types_1.LoadType.COLOR);
+                expect(result.generalErrors).not.toContainEqual({
+                    message: constants_1.ENTITY_PROCESSOR_ERRORS.NAME_REQUIRED,
+                    issueType: entity_types_1.IssueType.CONFIG,
+                });
+            });
+            it('should error when name column from mapping is not in CSV', () => {
+                const data = [{ federatedId: 'test1' }];
+                const config = {
+                    ...loaderProcess,
+                    federatedMappings: {
+                        name: 'display_name',
+                    },
+                };
+                const result = entity_processor_1.EntityProcessor.validateLoadFile(data, config, entity_types_1.LoadType.COLOR);
+                expect(result.generalErrors).toContainEqual({
+                    message: constants_1.ENTITY_PROCESSOR_ERRORS.NAME_REQUIRED,
+                    issueType: entity_types_1.IssueType.CONFIG,
+                });
+            });
+            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_1.EntityProcessor.validateLoadFile(data, config, entity_types_1.LoadType.COLOR);
+                expect(result.generalErrors).toHaveLength(0);
+            });
+        });
+    });
+    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([]);
+        });
+    });
+});