@contrail/cli 3.4.5 → 3.4.6-alpha.cffb28e

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

@@ -0,0 +1,654 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const entity_types_1 = require("@contrail/entity-types");
+const item_processor_1 = require("./item-processor");
+const constants_1 = require("../../constants");
+describe('Item Processor', () => {
+    const loaderProcess = {
+        id: 'mock-loader-process-id',
+        loadFileId: 'mock-load-file-id',
+        loadType: [entity_types_1.LoadType.ITEM],
+        status: entity_types_1.LoadStatus.COMPLETE,
+        federatedMappings: {
+            itemFamilyFederatedId: 'family_federated_id',
+            name: 'name',
+        },
+        conditionalColumns: [
+            {
+                toProperty: 'typePath',
+                default: 'item',
+            },
+        ],
+    };
+    describe('validateLoadFile', () => {
+        it('should return general error if loadType is not correct', () => {
+            const data = [
+                {
+                    name: 'item1',
+                    family_federated_id: 'family_1',
+                    input_col_1: 'value_1',
+                    input_col_2: 'value_2',
+                },
+                {
+                    name: 'item2',
+                    family_federated_id: 'family_2',
+                    input_col_1: 'value_3',
+                    input_col_2: 'value_4',
+                },
+                {
+                    name: 'item3',
+                    family_federated_id: 'family_3',
+                    input_col_1: 'value_5',
+                    input_col_2: 'value_6',
+                },
+            ];
+            const config = {
+                ...loaderProcess,
+                loadType: ['INVALID'],
+            };
+            const result = item_processor_1.ItemProcessor.validateLoadFile(data, config);
+            expect(result.generalErrors).toEqual([
+                {
+                    message: constants_1.ITEM_PROCESSOR_ERRORS.LOAD_TYPE_INVALID,
+                    issueType: entity_types_1.IssueType.CONFIG,
+                },
+            ]);
+        });
+        describe('validate typepath', () => {
+            it('should throw general error if typePath is incorrect', () => {
+                const data = [
+                    {
+                        name: 'item1',
+                        family_federated_id: 'family_1',
+                        input_col_1: 'value_1',
+                        input_col_2: 'value_2',
+                    },
+                    {
+                        name: 'item2',
+                        family_federated_id: 'family_2',
+                        input_col_1: 'value_3',
+                        input_col_2: 'value_4',
+                    },
+                    {
+                        name: 'item3',
+                        family_federated_id: 'family_3',
+                        input_col_1: 'value_5',
+                        input_col_2: 'value_6',
+                    },
+                ];
+                const config = {
+                    ...loaderProcess,
+                    conditionalColumns: [
+                        {
+                            toProperty: 'typePath',
+                            default: 'custom-entity:',
+                        },
+                    ],
+                };
+                const result = item_processor_1.ItemProcessor.validateLoadFile(data, config);
+                expect(result.generalErrors).toEqual([
+                    {
+                        message: constants_1.ITEM_PROCESSOR_ERRORS.TYPEPATH_INVALID,
+                        issueType: entity_types_1.IssueType.CONFIG,
+                    },
+                ]);
+            });
+            it('should throw error if typepath is present in the config file but have incorrect typePath', () => {
+                const data = [
+                    {
+                        name: 'item1',
+                        family_federated_id: 'family_1',
+                        input_col_1: 'value_1',
+                        input_col_2: 'value_2',
+                    },
+                    {
+                        name: 'item2',
+                        family_federated_id: 'family_2',
+                        input_col_1: 'value_3',
+                        input_col_2: 'value_4',
+                    },
+                    {
+                        name: 'item3',
+                        family_federated_id: 'family_3',
+                        input_col_1: 'value_5',
+                        input_col_2: 'value_6',
+                    },
+                ];
+                const config = {
+                    ...loaderProcess,
+                    conditionalColumns: [
+                        {
+                            toProperty: 'typePath',
+                            default: 'custom-entity1',
+                        },
+                    ],
+                };
+                const result = item_processor_1.ItemProcessor.validateLoadFile(data, config);
+                expect(result.generalErrors).toEqual([
+                    {
+                        message: constants_1.ITEM_PROCESSOR_ERRORS.TYPEPATH_INVALID,
+                        issueType: entity_types_1.IssueType.CONFIG,
+                    },
+                ]);
+            });
+            it('should throw error if typepath is present in the csv header but have incorrect typePath', () => {
+                const data = [
+                    {
+                        name: 'item1',
+                        family_federated_id: 'family_1',
+                        input_col_1: 'value_1',
+                        input_col_2: 'value_2',
+                        typePath: 'custom-entity1',
+                    },
+                    {
+                        name: 'item2',
+                        family_federated_id: 'family_2',
+                        input_col_1: 'value_3',
+                        input_col_2: 'value_4',
+                        typePath: 'custom-entity1',
+                    },
+                    {
+                        name: 'item3',
+                        family_federated_id: 'family_3',
+                        input_col_1: 'value_5',
+                        input_col_2: 'value_6',
+                        typePath: 'custom-entity1',
+                    },
+                ];
+                const config = {
+                    ...loaderProcess,
+                    conditionalColumns: [],
+                };
+                const result = item_processor_1.ItemProcessor.validateLoadFile(data, config);
+                expect(result.generalErrors).toEqual([
+                    {
+                        message: constants_1.ITEM_PROCESSOR_ERRORS.TYPEPATH_INVALID,
+                        issueType: entity_types_1.IssueType.CONFIG,
+                    },
+                ]);
+            });
+            it('should not throw error if typepath is not present in csv header and config file', () => {
+                const data = [
+                    {
+                        name: 'item1',
+                        family_federated_id: 'family_1',
+                        input_col_1: 'value_1',
+                        input_col_2: 'value_2',
+                    },
+                    {
+                        name: 'item2',
+                        family_federated_id: 'family_2',
+                        input_col_1: 'value_3',
+                        input_col_2: 'value_4',
+                    },
+                    {
+                        name: 'item3',
+                        family_federated_id: 'family_3',
+                        input_col_1: 'value_5',
+                        input_col_2: 'value_6',
+                    },
+                ];
+                const config = {
+                    ...loaderProcess,
+                    conditionalColumns: [],
+                };
+                const result = item_processor_1.ItemProcessor.validateLoadFile(data, config);
+                expect(result.generalErrors).toEqual([]);
+            });
+        });
+        describe('validate itemOptionFederatedId', () => {
+            it('should validate optionFederatedId in conditional columns', () => {
+                const data = [{ name: 'test1', optionName: 'Test Option 1' }];
+                const config = {
+                    ...loaderProcess,
+                    conditionalColumns: [
+                        {
+                            toProperty: 'itemFamilyFederatedId',
+                            default: 'test-{name}',
+                        },
+                        {
+                            toProperty: 'itemOptionFederatedId',
+                            default: 'test-{optionName}',
+                        },
+                    ],
+                };
+                const result = item_processor_1.ItemProcessor.validateLoadFile(data, config);
+                expect(result.generalWarnings).not.toContainEqual({
+                    message: constants_1.ITEM_PROCESSOR_WARNINGS.OPTION_FEDERATED_ID_UNMAPPED,
+                    issueType: entity_types_1.IssueType.CONFIG,
+                });
+            });
+            it('should validate federatedId in CSV data', () => {
+                const data = [
+                    {
+                        itemFamilyFederatedId: 'test1',
+                        itemOptionFederatedId: 'option1',
+                        name: 'Test 1',
+                    },
+                ];
+                const result = item_processor_1.ItemProcessor.validateLoadFile(data, loaderProcess);
+                expect(result.generalErrors).not.toContainEqual({
+                    message: constants_1.ITEM_PROCESSOR_WARNINGS.OPTION_FEDERATED_ID_UNMAPPED,
+                    issueType: entity_types_1.IssueType.CONFIG,
+                });
+            });
+            it('should validate federatedId in federatedMapping', () => {
+                const data = [{ code: 'test1', option: 'option1', name: 'Test 1' }];
+                const config = {
+                    ...loaderProcess,
+                    federatedMappings: {
+                        itemFamilyFederatedId: 'code',
+                        itemOptionFederatedId: 'option',
+                    },
+                };
+                const result = item_processor_1.ItemProcessor.validateLoadFile(data, config);
+                expect(result.generalErrors).not.toContainEqual({
+                    message: constants_1.ITEM_PROCESSOR_WARNINGS.OPTION_FEDERATED_ID_UNMAPPED,
+                    issueType: entity_types_1.IssueType.CONFIG,
+                });
+            });
+            it('should warning error if itemOptionfederatedId is missing in federatedmapping config, csv header and conditional column', () => {
+                const data = [{ name: 'color1', option: 'option1' }];
+                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',
+                        },
+                    ],
+                    federatedMappings: {
+                        name: 'name',
+                        optionName: 'option',
+                    },
+                };
+                const result = item_processor_1.ItemProcessor.validateLoadFile(data, config);
+                expect(result.generalWarnings).toEqual([
+                    {
+                        message: constants_1.ITEM_PROCESSOR_WARNINGS.OPTION_FEDERATED_ID_UNMAPPED,
+                        issueType: entity_types_1.IssueType.CONFIG,
+                    },
+                ]);
+            });
+            it('should return error if itemOptionFederatedId is mapped incorrectly in federatedMappings', () => {
+                const lineSheetData = [{ header1: 'value1', test1: 'test1' }];
+                const config = {
+                    loadType: ['ITEM'],
+                    federatedMappings: {
+                        name: 'header1',
+                        itemFamilyFederatedId: 'someId',
+                        optionName: 'test1',
+                        itemOptionFederatedId: 'test2',
+                    },
+                };
+                const result = item_processor_1.ItemProcessor.validateLoadFile(lineSheetData, config);
+                expect(result.generalWarnings).toEqual([
+                    {
+                        message: constants_1.ITEM_PROCESSOR_WARNINGS.OPTION_FEDERATED_ID_NOT_FOUND('test2'),
+                        issueType: entity_types_1.IssueType.CONFIG,
+                    },
+                ]);
+            });
+        });
+        describe('validate itemOptionName', () => {
+            it('should validate optionName in conditional columns', () => {
+                const data = [{ federatedId: 'test1' }];
+                const config = {
+                    ...loaderProcess,
+                    federatedMappings: {},
+                    conditionalColumns: [
+                        {
+                            toProperty: 'name',
+                            default: 'Test {federatedId}',
+                        },
+                        {
+                            toProperty: 'optionName',
+                            default: 'Test1 {federatedId}',
+                        },
+                    ],
+                };
+                const result = item_processor_1.ItemProcessor.validateLoadFile(data, config);
+                console.log(JSON.stringify(result, null, 2));
+                expect(result.generalWarnings).not.toContainEqual({
+                    message: constants_1.ITEM_PROCESSOR_WARNINGS.OPTIONNAME_UNMAPPED,
+                    issueType: entity_types_1.IssueType.CONFIG,
+                });
+            });
+            it('should validate name in CSV data', () => {
+                const data = [{ federatedId: 'test1', name: 'Test 1', optionName: 'Option 1' }];
+                const result = item_processor_1.ItemProcessor.validateLoadFile(data, loaderProcess);
+                expect(result.generalWarnings).not.toContainEqual({
+                    message: constants_1.ITEM_PROCESSOR_WARNINGS.OPTIONNAME_UNMAPPED,
+                    issueType: entity_types_1.IssueType.CONFIG,
+                });
+            });
+            it('should return warning if optionName is missing in federatedMappings, config and conditional column', () => {
+                const data = [{ id: 'custom-entity1', optionId: 'option1' }];
+                const config = {
+                    ...loaderProcess,
+                    loadType: [entity_types_1.LoadType.CUSTOM_ENTITY],
+                    federatedMappings: {
+                        federatedId: 'id',
+                        itemOptionFederatedId: 'optionId',
+                    },
+                };
+                const result = item_processor_1.ItemProcessor.validateLoadFile(data, config);
+                expect(result.generalWarnings).toEqual([
+                    {
+                        message: constants_1.ITEM_PROCESSOR_WARNINGS.OPTIONNAME_UNMAPPED,
+                        issueType: entity_types_1.IssueType.CONFIG,
+                    },
+                ]);
+            });
+            it('should validate name in federatedMapping', () => {
+                const data = [
+                    {
+                        federatedId: 'test1',
+                        display_name: 'Test 1',
+                        display_option: 'Option 1',
+                    },
+                ];
+                const config = {
+                    ...loaderProcess,
+                    federatedMappings: {
+                        name: 'display_name',
+                        optionName: 'display_option',
+                    },
+                };
+                const result = item_processor_1.ItemProcessor.validateLoadFile(data, config);
+                expect(result.generalWarnings).not.toContainEqual({
+                    message: constants_1.ITEM_PROCESSOR_WARNINGS.OPTIONNAME_UNMAPPED,
+                    issueType: entity_types_1.IssueType.CONFIG,
+                });
+            });
+            it('should return a warning if optionName is not mapped in federatedMappings', () => {
+                const data = [
+                    {
+                        name: 'item1',
+                        family_federated_id: 'family_1',
+                        input_col_1: 'value_1',
+                        input_col_2: 'value_2',
+                    },
+                    {
+                        name: 'item2',
+                        family_federated_id: 'family_2',
+                        input_col_1: 'value_3',
+                        input_col_2: 'value_4',
+                    },
+                    {
+                        name: 'item3',
+                        family_federated_id: 'family_3',
+                        input_col_1: 'value_5',
+                        input_col_2: 'value_6',
+                    },
+                ];
+                const config = {
+                    ...loaderProcess,
+                    conditionalColumns: [],
+                    federatedMappings: {
+                        itemFamilyFederatedId: 'family_federated_id',
+                        itemOptionFederatedId: 'input_col_1',
+                    },
+                };
+                const result = item_processor_1.ItemProcessor.validateLoadFile(data, config);
+                expect(result.generalWarnings).toEqual([
+                    {
+                        message: constants_1.ITEM_PROCESSOR_WARNINGS.OPTIONNAME_UNMAPPED,
+                        issueType: entity_types_1.IssueType.CONFIG,
+                    },
+                ]);
+            });
+            it('should return a warning if optionName is mapped incorrectly in federatedMappings', () => {
+                const data = [
+                    {
+                        name: 'item1',
+                        family_federated_id: 'family_1',
+                        input_col_1: 'value_1',
+                        input_col_2: 'value_2',
+                    },
+                    {
+                        name: 'item2',
+                        family_federated_id: 'family_2',
+                        input_col_1: 'value_3',
+                        input_col_2: 'value_4',
+                    },
+                    {
+                        name: 'item3',
+                        family_federated_id: 'family_3',
+                        input_col_1: 'value_5',
+                        input_col_2: 'value_6',
+                    },
+                ];
+                const config = {
+                    ...loaderProcess,
+                    conditionalColumns: [],
+                    federatedMappings: {
+                        itemFamilyFederatedId: 'family_federated_id',
+                        itemOptionFederatedId: 'input_col_1',
+                        optionName: 'input_col_3',
+                    },
+                };
+                const result = item_processor_1.ItemProcessor.validateLoadFile(data, config);
+                expect(result.generalWarnings).toEqual([
+                    {
+                        message: '"input_col_3" column not found in the CSV file',
+                        issueType: entity_types_1.IssueType.CONFIG,
+                    },
+                ]);
+            });
+            it('should throw error for the duplicate itemOptionFederatedId', () => {
+                const lineSheetData = [
+                    {
+                        itemName: 'foo',
+                        itemFamilyFederatedId: '1',
+                        itemOptionFederatedId: '11',
+                    },
+                    {
+                        itemName: 'foo',
+                        itemFamilyFederatedId: '1',
+                        itemOptionFederatedId: '11',
+                    },
+                    {
+                        itemName: 'bar',
+                        itemFamilyFederatedId: '2',
+                        itemOptionFederatedId: '12',
+                    },
+                ];
+                const config = {
+                    loadType: ['ITEM'],
+                    federatedMappings: {
+                        name: 'itemName',
+                        itemFamilyFederatedId: 'itemFamilyFederatedId',
+                    },
+                };
+                const result = item_processor_1.ItemProcessor.validateLoadFile(lineSheetData, config);
+                expect(result.errors).toEqual([
+                    {
+                        rowNumber: 2,
+                        columnIssues: [
+                            {
+                                columnName: 'itemOptionFederatedId',
+                                message: 'Duplicate federatedId found: 11',
+                                issueType: entity_types_1.IssueType.DUPLICATE_FEDERATED_ID,
+                                data: '{"itemName":"foo","itemFamilyFederatedId":"1","itemOptionFederatedId":"11"}',
+                            },
+                        ],
+                    },
+                    {
+                        rowNumber: 3,
+                        columnIssues: [
+                            {
+                                columnName: 'itemOptionFederatedId',
+                                message: 'Duplicate federatedId found: 11',
+                                issueType: entity_types_1.IssueType.DUPLICATE_FEDERATED_ID,
+                                data: '{"itemName":"foo","itemFamilyFederatedId":"1","itemOptionFederatedId":"11"}',
+                            },
+                        ],
+                    },
+                ]);
+            });
+        });
+        describe('validate duplicate optionName within family', () => {
+            it('should return errors when options in the same family have duplicate optionNames', () => {
+                const data = [
+                    { itemFamilyFederatedId: '1', itemOptionFederatedId: 'opt1', optionName: 'Red', name: 'Shirt' },
+                    { itemFamilyFederatedId: '1', itemOptionFederatedId: 'opt2', optionName: 'Red', name: 'Shirt' },
+                    { itemFamilyFederatedId: '1', itemOptionFederatedId: 'opt3', optionName: 'Blue', name: 'Shirt' },
+                ];
+                const config = {
+                    loadType: ['ITEM'],
+                    federatedMappings: {
+                        name: 'name',
+                        itemFamilyFederatedId: 'itemFamilyFederatedId',
+                    },
+                };
+                const result = item_processor_1.ItemProcessor.validateLoadFile(data, config);
+                const duplicateNameErrors = result.errors.filter((e) => e.columnIssues.some((c) => c.message.includes('Duplicate optionName')));
+                expect(duplicateNameErrors.length).toBe(2);
+                expect(duplicateNameErrors[0].columnIssues[0].message).toContain('Duplicate optionName "Red" found within item family');
+            });
+            it('should allow same optionName across different families', () => {
+                const data = [
+                    { itemFamilyFederatedId: '1', itemOptionFederatedId: 'opt1', optionName: 'Red', name: 'Shirt' },
+                    { itemFamilyFederatedId: '2', itemOptionFederatedId: 'opt2', optionName: 'Red', name: 'Pants' },
+                ];
+                const config = {
+                    loadType: ['ITEM'],
+                    federatedMappings: {
+                        name: 'name',
+                        itemFamilyFederatedId: 'itemFamilyFederatedId',
+                    },
+                };
+                const result = item_processor_1.ItemProcessor.validateLoadFile(data, config);
+                const duplicateNameErrors = result.errors.filter((e) => e.columnIssues.some((c) => c.message.includes('Duplicate optionName')));
+                expect(duplicateNameErrors.length).toBe(0);
+            });
+            it('should not check duplicate optionName if optionName is not mapped', () => {
+                const data = [
+                    { itemFamilyFederatedId: '1', itemOptionFederatedId: 'opt1', name: 'Shirt' },
+                    { itemFamilyFederatedId: '1', itemOptionFederatedId: 'opt2', name: 'Shirt' },
+                ];
+                const config = {
+                    loadType: ['ITEM'],
+                    federatedMappings: {
+                        name: 'name',
+                        itemFamilyFederatedId: 'itemFamilyFederatedId',
+                    },
+                };
+                const result = item_processor_1.ItemProcessor.validateLoadFile(data, config);
+                const duplicateNameErrors = result.errors.filter((e) => e.columnIssues.some((c) => c.message.includes('Duplicate optionName')));
+                expect(duplicateNameErrors.length).toBe(0);
+            });
+        });
+        describe('validate itemFamilyFederatedId', () => {
+            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 = item_processor_1.ItemProcessor.validateLoadFile(lineSheetData, config);
+                expect(result.errors).toEqual([
+                    {
+                        rowNumber: 0,
+                        columnIssues: [
+                            {
+                                columnName: 'itemFamilyFederatedId',
+                                message: 'itemFamilyFederatedId is null or undefined or empty in the CSV file',
+                                issueType: entity_types_1.IssueType.CONFIG,
+                                data: JSON.stringify(lineSheetData[0]),
+                            },
+                        ],
+                    },
+                    {
+                        rowNumber: 1,
+                        columnIssues: [
+                            {
+                                columnName: 'itemFamilyFederatedId',
+                                message: 'itemFamilyFederatedId is null or undefined or empty in the CSV file',
+                                issueType: entity_types_1.IssueType.CONFIG,
+                                data: JSON.stringify(lineSheetData[1]),
+                            },
+                        ],
+                    },
+                    {
+                        rowNumber: 3,
+                        columnIssues: [
+                            {
+                                columnName: 'itemFamilyFederatedId',
+                                message: 'itemFamilyFederatedId is null or undefined or empty in the CSV file',
+                                issueType: entity_types_1.IssueType.CONFIG,
+                                data: JSON.stringify(lineSheetData[3]),
+                            },
+                        ],
+                    },
+                ]);
+            });
+            it('should throw an error duplicate itemFamilyFederatedId is present in data file with different name', () => {
+                const lineSheetData = [
+                    {
+                        itemFamilyFederatedId: '1',
+                        name: 'foo',
+                    },
+                    {
+                        itemFamilyFederatedId: '1',
+                        name: 'bar',
+                    },
+                    {
+                        itemFamilyFederatedId: '3',
+                        name: 'test',
+                    },
+                ];
+                const config = {
+                    loadType: ['ITEM'],
+                    federatedMappings: {
+                        itemFamilyFederatedId: 'itemFamilyFederatedId',
+                    },
+                };
+                const result = item_processor_1.ItemProcessor.validateLoadFile(lineSheetData, config);
+                expect(result.generalErrors).toEqual([
+                    {
+                        message: constants_1.ITEM_PROCESSOR_ERRORS.CONFLICTING_IDS('(1: (foo, bar))'),
+                        issueType: entity_types_1.IssueType.CONFIG,
+                    },
+                ]);
+            });
+            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 = item_processor_1.ItemProcessor.validateLoadFile(lineSheetData, config);
+                expect(result.errors.length).toBe(0);
+            });
+        });
+    });
+});