@contrail/cli 3.4.5 → 3.4.6-alpha.cffb28e

package/node_modules/@contrail/loader/lib/common/data-transformer.spec.js

@@ -0,0 +1,744 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const entity_types_1 = require("@contrail/entity-types");
+const data_transformer_functions_1 = require("./data-transformer-functions");
+const types_1 = require("@contrail/types");
+describe('Data Transformer Functions', () => {
+    const mockClient = {
+        create: jest.fn(),
+        update: jest.fn(),
+        getAllReferences: jest.fn(),
+        get: jest.fn(),
+        delete: jest.fn(),
+        batchCreate: jest.fn(),
+        batchUpdate: jest.fn(),
+        batchDelete: jest.fn(),
+    };
+    const mockData = [
+        { name: 'item1', displayValue: 'Display 1', bool: 'true' },
+        { name: 'item2', displayValue: 'Display 2', bool: 'false' },
+    ];
+    const mockTypes = [
+        {
+            id: 'type1',
+            slug: 'item',
+            label: 'Item',
+            typePath: 'item',
+            typeProperties: [
+                {
+                    slug: 'displayValue',
+                    label: 'Display Value',
+                    propertyType: types_1.PropertyType.SingleSelect,
+                    options: [
+                        { value: '1', display: 'Display 1' },
+                        { value: '2', display: 'Display 2' },
+                    ],
+                },
+                { slug: 'bool', label: 'Boolean', propertyType: types_1.PropertyType.Boolean },
+            ],
+        },
+    ];
+    describe('applyFederatedMappings', () => {
+        it('should add fields from mappings', async () => {
+            const data = [
+                {
+                    id: 'fakeId',
+                    btpString: 'btp',
+                    color: 'blue',
+                },
+                {
+                    id: 'fakeId2',
+                    btpString: 'btp2',
+                    color: 'red',
+                },
+            ];
+            const federatedMappings = {
+                federatedId: 'btpString',
+                familyId: 'color',
+            };
+            const { errors, rows } = (0, data_transformer_functions_1.applyFederatedMappings)(data, { federatedMappings });
+            expect(errors.length).toBe(0);
+            expect(rows[0].federatedId).toEqual('btp');
+            expect(rows[0].familyId).toEqual('blue');
+            expect(rows[1].federatedId).toEqual('btp2');
+            expect(rows[1].familyId).toEqual('red');
+        });
+        it('should not add federatedId if it exists', async () => {
+            const data = [
+                {
+                    id: 'fakeId',
+                    btpString: 'btp',
+                    federatedId: 'blue',
+                },
+                {
+                    id: 'fakeId2',
+                    btpString: 'btp2',
+                    federatedId: 'red',
+                },
+            ];
+            const federatedMappings = {
+                federatedId: 'btpString',
+            };
+            const { rows, errors } = (0, data_transformer_functions_1.applyFederatedMappings)(data, { federatedMappings });
+            expect(errors.length).toBe(0);
+            expect(rows[0].federatedId).toEqual('blue');
+            expect(rows[1].federatedId).toEqual('red');
+        });
+        it('should leave field null if there is no value to add', async () => {
+            const data = [
+                {
+                    id: 'fakeId',
+                    color: 'blue',
+                },
+                {
+                    id: 'fakeId2',
+                    color: 'red',
+                },
+            ];
+            const federatedMappings = {
+                federatedId: 'btpString',
+            };
+            const { errors, rows } = (0, data_transformer_functions_1.applyFederatedMappings)(data, { federatedMappings });
+            expect(errors.length).toBe(0);
+            expect(rows[0].federatedId).toBeUndefined();
+            expect(rows[1].federatedId).toBeUndefined();
+        });
+    });
+    describe('removeUnwantedProperties', () => {
+        it('should remove unwanted properties', () => {
+            const config = { propertiesToRemove: ['displayValue'] };
+            const result = (0, data_transformer_functions_1.removeUnwantedProperties)(mockData, config);
+            expect(result.rows).toEqual([
+                { name: 'item1', bool: 'true' },
+                { name: 'item2', bool: 'false' },
+            ]);
+        });
+    });
+    describe('trimValues', () => {
+        it('should trim leading and trailing whitespace from string values', () => {
+            const data = [
+                { name: '  item1  ', color: ' red ', size: 'large' },
+                { name: 'item2', color: '  blue', size: 'small  ' },
+            ];
+            const result = (0, data_transformer_functions_1.trimValues)(data, {});
+            expect(result.rows).toEqual([
+                { name: 'item1', color: 'red', size: 'large' },
+                { name: 'item2', color: 'blue', size: 'small' },
+            ]);
+        });
+        it('should not modify non-string values', () => {
+            const data = [
+                { name: '  item1  ', count: 42, active: true, notes: null, meta: undefined },
+            ];
+            const result = (0, data_transformer_functions_1.trimValues)(data, {});
+            expect(result.rows[0].name).toBe('item1');
+            expect(result.rows[0].count).toBe(42);
+            expect(result.rows[0].active).toBe(true);
+            expect(result.rows[0].notes).toBeNull();
+            expect(result.rows[0].meta).toBeUndefined();
+        });
+        it('should not mutate the original rows', () => {
+            const data = [{ name: '  item1  ' }];
+            (0, data_transformer_functions_1.trimValues)(data, {});
+            expect(data[0].name).toBe('  item1  ');
+        });
+        it('should return empty errors and warnings', () => {
+            const data = [{ name: '  item1  ' }];
+            const result = (0, data_transformer_functions_1.trimValues)(data, {});
+            expect(result.errors).toEqual([]);
+            expect(result.warnings).toEqual([]);
+            expect(result.generalErrors).toEqual([]);
+        });
+    });
+    describe('transformDataBasedOnTypes', () => {
+        it('should transform data based on types', () => {
+            const config = { federatedMappings: { federatedId: 'name' } };
+            const { typePropertiesBySlug, typePropertiesByLabel } = (0, data_transformer_functions_1.getPropertiesBySlugAndLabel)(mockTypes);
+            const optionSetUsingTypePropertiesBySlug = (0, data_transformer_functions_1.getOptionSetsUsingTypePropertiesBySlug)(mockTypes);
+            const typePropertyMaps = {
+                typePropertiesBySlug,
+                typePropertiesByLabel,
+                optionSetUsingTypePropertiesBySlug,
+            };
+            const result = (0, data_transformer_functions_1.transformDataBasedOnTypes)(mockData, config, typePropertyMaps);
+            expect(result.rows).toEqual([
+                { name: 'item1', displayValue: '1', bool: 'true' },
+                { name: 'item2', displayValue: '2', bool: 'false' },
+            ]);
+        });
+    });
+    describe('transformDataBasedOnTypesWithoutWarnings', () => {
+        it('should transform data based on types without warnings', () => {
+            const config = { federatedMappings: { federatedId: 'name' } };
+            const { typePropertiesBySlug, typePropertiesByLabel } = (0, data_transformer_functions_1.getPropertiesBySlugAndLabel)(mockTypes);
+            const optionSetUsingTypePropertiesBySlug = (0, data_transformer_functions_1.getOptionSetsUsingTypePropertiesBySlug)(mockTypes);
+            const typePropertyMaps = {
+                typePropertiesBySlug,
+                typePropertiesByLabel,
+                optionSetUsingTypePropertiesBySlug,
+            };
+            const result = (0, data_transformer_functions_1.transformDataBasedOnTypesWithoutWarnings)(mockData, config, typePropertyMaps);
+            expect(result.rows).toEqual([
+                { name: 'item1', displayValue: '1', bool: 'true' },
+                { name: 'item2', displayValue: '2', bool: 'false' },
+            ]);
+        });
+    });
+    describe('applyConditionalColumns', () => {
+        it('should apply conditional columns', () => {
+            const config = {
+                conditionalColumns: [{ toProperty: 'conditional', default: 'default' }],
+            };
+            const result = (0, data_transformer_functions_1.applyConditionalColumns)(mockData, config);
+            expect(result.rows).toEqual([
+                {
+                    name: 'item1',
+                    displayValue: 'Display 1',
+                    bool: 'true',
+                    conditional: 'default',
+                },
+                {
+                    name: 'item2',
+                    displayValue: 'Display 2',
+                    bool: 'false',
+                    conditional: 'default',
+                },
+            ]);
+        });
+    });
+    describe('convertFromLabelToSlug', () => {
+        it('should convert from label to slug', () => {
+            const csvJSON = [
+                {
+                    id: '1',
+                    Color: 'Red',
+                    Size: 'Small',
+                },
+                {
+                    id: '2',
+                    Color: 'Blue',
+                    Size: 'Large',
+                },
+            ];
+            const typePropertiesBySlug = {
+                color: {},
+                size: {},
+            };
+            const typePropertiesByLabel = {
+                Color: { slug: 'colorSlug' },
+                Size: { slug: 'sizeSlug' },
+            };
+            const convertedFields = {};
+            const warnings = (0, data_transformer_functions_1.convertFromLabelToSlug)(csvJSON, typePropertiesBySlug, typePropertiesByLabel, convertedFields);
+            expect(csvJSON[0].colorSlug).toEqual('Red');
+            expect(csvJSON[0].sizeSlug).toEqual('Small');
+            expect(csvJSON[1].colorSlug).toEqual('Blue');
+            expect(csvJSON[1].sizeSlug).toEqual('Large');
+            expect(csvJSON[0].Color).toEqual('Red');
+            expect(csvJSON[0].Size).toEqual('Small');
+            expect(csvJSON[1].Color).toEqual('Blue');
+            expect(csvJSON[1].Size).toEqual('Large');
+            expect(warnings).toEqual([
+                {
+                    columnIssues: [
+                        {
+                            columnName: 'id',
+                            data: '',
+                            issueType: 'HEADER_MISMATCH',
+                            message: 'Type property id does not have any mapping via CSV column or Config. This property will not be loaded into.',
+                        },
+                    ],
+                    rowNumber: 1,
+                },
+            ]);
+        });
+        it('should skip logging when skipLogs is true', () => {
+            const csvJSON = [
+                {
+                    id: '1',
+                    Color: 'Red',
+                    Size: 'Small',
+                },
+                {
+                    id: '2',
+                    Color: 'Blue',
+                    Size: 'Large',
+                },
+            ];
+            const typePropertiesBySlug = {
+                id: {},
+                color: {},
+                size: {},
+            };
+            const typePropertiesByLabel = {
+                Color: { slug: 'colorSlug' },
+                Size: { slug: 'sizeSlug' },
+            };
+            const convertedFields = {};
+            const warnings = (0, data_transformer_functions_1.convertFromLabelToSlug)(csvJSON, typePropertiesBySlug, typePropertiesByLabel, convertedFields);
+            expect(csvJSON[0].colorSlug).toEqual('Red');
+            expect(csvJSON[0].sizeSlug).toEqual('Small');
+            expect(csvJSON[1].colorSlug).toEqual('Blue');
+            expect(csvJSON[1].sizeSlug).toEqual('Large');
+            expect(warnings).toEqual([]);
+        });
+        describe('archived properties handling', () => {
+            it('should add warning when property is archived in slugProperty', () => {
+                const csvJSON = [{ color: 'red' }];
+                const typePropertiesBySlug = {
+                    color: {
+                        slug: 'color',
+                        isArchived: true,
+                    },
+                };
+                const typePropertiesByLabel = {};
+                const convertedFields = {};
+                const warnings = (0, data_transformer_functions_1.convertFromLabelToSlug)(csvJSON, typePropertiesBySlug, typePropertiesByLabel, convertedFields);
+                expect(warnings).toEqual([
+                    {
+                        rowNumber: 1,
+                        columnIssues: [
+                            {
+                                columnName: 'color',
+                                message: "Property color is disabled. This property's data will not be processed.",
+                                issueType: entity_types_1.IssueType.HEADER_MISMATCH,
+                                data: '',
+                            },
+                        ],
+                    },
+                ]);
+            });
+            it('should add warning when property is archived in labelProperty', () => {
+                const csvJSON = [{ Color: 'red' }];
+                const typePropertiesBySlug = {};
+                const typePropertiesByLabel = {
+                    Color: {
+                        slug: 'color',
+                        isArchived: true,
+                    },
+                };
+                const convertedFields = {};
+                const warnings = (0, data_transformer_functions_1.convertFromLabelToSlug)(csvJSON, typePropertiesBySlug, typePropertiesByLabel, convertedFields);
+                expect(warnings).toEqual([
+                    {
+                        rowNumber: 1,
+                        columnIssues: [
+                            {
+                                columnName: 'Color',
+                                message: "Property Color is disabled. This property's data will not be processed.",
+                                issueType: entity_types_1.IssueType.HEADER_MISMATCH,
+                                data: '',
+                            },
+                        ],
+                    },
+                ]);
+            });
+            it('should not convert archived properties to slug', () => {
+                const csvJSON = [{ Color: 'red' }];
+                const typePropertiesBySlug = {};
+                const typePropertiesByLabel = {
+                    Color: {
+                        slug: 'color',
+                        isArchived: true,
+                    },
+                };
+                const convertedFields = {};
+                (0, data_transformer_functions_1.convertFromLabelToSlug)(csvJSON, typePropertiesBySlug, typePropertiesByLabel, convertedFields);
+                expect(csvJSON[0]).not.toHaveProperty('color');
+                expect(csvJSON[0]).toEqual({ Color: 'red' });
+            });
+            it('should handle multiple archived properties', () => {
+                const csvJSON = [
+                    {
+                        Color: 'red',
+                        Size: 'large',
+                        weight: '100',
+                    },
+                ];
+                const typePropertiesBySlug = {
+                    weight: {
+                        slug: 'weight',
+                        isArchived: true,
+                    },
+                };
+                const typePropertiesByLabel = {
+                    Color: {
+                        slug: 'color',
+                        isArchived: true,
+                    },
+                };
+                const convertedFields = {};
+                const warnings = (0, data_transformer_functions_1.convertFromLabelToSlug)(csvJSON, typePropertiesBySlug, typePropertiesByLabel, convertedFields);
+                expect(warnings[0].columnIssues).toHaveLength(2);
+                expect(warnings[0].columnIssues).toEqual(expect.arrayContaining([
+                    {
+                        columnName: 'Color',
+                        message: "Property Color is disabled. This property's data will not be processed.",
+                        issueType: entity_types_1.IssueType.HEADER_MISMATCH,
+                        data: '',
+                    },
+                    {
+                        columnName: 'weight',
+                        message: "Property weight is disabled. This property's data will not be processed.",
+                        issueType: entity_types_1.IssueType.HEADER_MISMATCH,
+                        data: '',
+                    },
+                ]));
+            });
+            it('should ignore archived properties but process non-archived ones', () => {
+                const csvJSON = [
+                    {
+                        Color: 'red',
+                        Size: 'large',
+                    },
+                ];
+                const typePropertiesBySlug = {};
+                const typePropertiesByLabel = {
+                    Color: {
+                        slug: 'color',
+                        isArchived: true,
+                    },
+                    Size: {
+                        slug: 'size',
+                        isArchived: false,
+                    },
+                };
+                const convertedFields = {};
+                (0, data_transformer_functions_1.convertFromLabelToSlug)(csvJSON, typePropertiesBySlug, typePropertiesByLabel, convertedFields);
+                expect(csvJSON[0]).not.toHaveProperty('color');
+                expect(csvJSON[0]).toHaveProperty('size');
+            });
+        });
+    });
+    describe('convertFromDisplayToValue', () => {
+        it('should convert display values to optionSet values', () => {
+            const csvJSON = [
+                {
+                    id: '1',
+                    color: 'Red',
+                    size: 'Small',
+                },
+                {
+                    id: '2',
+                    color: 'Blue',
+                    size: 'Large',
+                },
+            ];
+            const optionSetUsingTypePropertiesBySlug = {
+                color: {
+                    propertyType: 'choice',
+                    optionLookupByDisplay: {
+                        Red: { value: 'red' },
+                        Blue: { value: 'blue' },
+                    },
+                    optionLookupByValue: {},
+                },
+                size: {
+                    propertyType: 'choice',
+                    optionLookupByDisplay: {
+                        Small: { value: 'small' },
+                        Large: { value: 'large' },
+                    },
+                    optionLookupByValue: {},
+                },
+            };
+            (0, data_transformer_functions_1.convertFromDisplayToValue)(csvJSON, optionSetUsingTypePropertiesBySlug, [], []);
+            expect(csvJSON[0].color).toEqual('red');
+            expect(csvJSON[0].size).toEqual('small');
+            expect(csvJSON[1].color).toEqual('blue');
+            expect(csvJSON[1].size).toEqual('large');
+        });
+        it('should handle unknown optionSet values', () => {
+            const csvJSON = [
+                {
+                    id: '1',
+                    color: 'Red',
+                    size: 'Medium',
+                },
+                {
+                    id: '2',
+                    color: 'Green',
+                    size: 'Large',
+                },
+            ];
+            const optionSetUsingTypePropertiesBySlug = {
+                color: {
+                    propertyType: 'choice',
+                    optionLookupByDisplay: {
+                        Red: { value: 'red' },
+                        Blue: { value: 'blue' },
+                    },
+                    optionLookupByValue: {},
+                },
+                size: {
+                    propertyType: 'choice',
+                    optionLookupByDisplay: {
+                        Small: { value: 'small' },
+                        Large: { value: 'large' },
+                    },
+                    optionLookupByValue: {},
+                },
+            };
+            const warnings = (0, data_transformer_functions_1.convertFromDisplayToValue)(csvJSON, optionSetUsingTypePropertiesBySlug, [], []);
+            expect(csvJSON[0].color).toEqual('red');
+            expect(csvJSON[0].size).toEqual('Medium');
+            expect(csvJSON[1].color).toEqual('Green');
+            expect(csvJSON[1].size).toEqual('large');
+            expect(warnings).toEqual([
+                {
+                    columnIssues: [
+                        {
+                            columnName: 'size',
+                            issueType: 'VALIDATION_ERROR',
+                            message: 'Property: size has unknown optionSet value: Medium.',
+                            data: '{"id":"1","color":"red","size":"Medium"}',
+                        },
+                    ],
+                    rowNumber: 2,
+                },
+                {
+                    columnIssues: [
+                        {
+                            columnName: 'color',
+                            issueType: 'VALIDATION_ERROR',
+                            message: 'Property: color has unknown optionSet value: Green.',
+                            data: '{"id":"2","color":"Green","size":"Large"}',
+                        },
+                    ],
+                    rowNumber: 3,
+                },
+            ]);
+        });
+        it('should skip logging unknown optionSet values', () => {
+            const csvJSON = [
+                {
+                    id: '1',
+                    color: 'Red',
+                    size: 'Small',
+                },
+                {
+                    id: '2',
+                    color: 'Blue',
+                    size: 'Large',
+                },
+            ];
+            const optionSetUsingTypePropertiesBySlug = {
+                color: {
+                    propertyType: 'choice',
+                    optionLookupByDisplay: {
+                        Red: { value: 'red' },
+                        Blue: { value: 'blue' },
+                    },
+                    optionLookupByValue: {},
+                },
+                size: {
+                    propertyType: 'choice',
+                    optionLookupByDisplay: {
+                        Small: { value: 'small' },
+                        Large: { value: 'large' },
+                    },
+                    optionLookupByValue: {},
+                },
+            };
+            const warnings = (0, data_transformer_functions_1.convertFromDisplayToValue)(csvJSON, optionSetUsingTypePropertiesBySlug, [], []);
+            expect(csvJSON[0].color).toEqual('red');
+            expect(csvJSON[0].size).toEqual('small');
+            expect(csvJSON[1].color).toEqual('blue');
+            expect(csvJSON[1].size).toEqual('large');
+            expect(warnings).toEqual([]);
+        });
+        it('should convert multi select values', () => {
+            const csvJSON = [
+                {
+                    id: '1',
+                    color: 'Red,Blue',
+                },
+                {
+                    id: '2',
+                    color: 'Blue',
+                },
+            ];
+            const optionSetUsingTypePropertiesBySlug = {
+                color: {
+                    propertyType: 'multi_select',
+                    optionLookupByDisplay: {
+                        Red: { value: 'red' },
+                        Blue: { value: 'blue' },
+                    },
+                    optionLookupByValue: {},
+                },
+            };
+            (0, data_transformer_functions_1.convertFromDisplayToValue)(csvJSON, optionSetUsingTypePropertiesBySlug, [], []);
+            expect(csvJSON[0].color).toEqual('red,blue');
+            expect(csvJSON[1].color).toEqual('blue');
+        });
+        it('should handle empty values for multi select values, returning the same values', () => {
+            const csvJSON = [
+                {
+                    id: '1',
+                    color: '',
+                },
+                {
+                    id: '2',
+                    color: null,
+                },
+                {
+                    id: '2',
+                    color: undefined,
+                },
+            ];
+            const optionSetUsingTypePropertiesBySlug = {
+                color: {
+                    propertyType: 'multi_select',
+                    optionLookupByDisplay: {
+                        Red: { value: 'red' },
+                        Blue: { value: 'blue' },
+                    },
+                    optionLookupByValue: {},
+                },
+            };
+            (0, data_transformer_functions_1.convertFromDisplayToValue)(csvJSON, optionSetUsingTypePropertiesBySlug, [], []);
+            expect(csvJSON[0].color).toEqual('');
+            expect(csvJSON[1].color).toEqual(null);
+            expect(csvJSON[2].color).toEqual(undefined);
+        });
+    });
+    describe('convertToBoolean', () => {
+        it('should convert string booleans to booleans', () => {
+            const result = (0, data_transformer_functions_1.convertToBoolean)(mockData);
+            expect(result.rows).toEqual([
+                { name: 'item1', displayValue: 'Display 1', bool: true },
+                { name: 'item2', displayValue: 'Display 2', bool: false },
+            ]);
+        });
+    });
+    describe('getReducedTypes', () => {
+        it('should get reduced types', async () => {
+            mockClient.get.mockResolvedValueOnce([
+                { id: 'type1', typePath: 'item' },
+                { id: 'type2', typePath: 'product' },
+            ]);
+            mockClient.get.mockResolvedValueOnce({
+                id: 'type1',
+                typePath: 'item',
+                typeProperties: [
+                    {
+                        slug: 'displayValue',
+                        label: 'Display Value',
+                        propertyType: 'choice',
+                    },
+                ],
+            });
+            const result = await (0, data_transformer_functions_1.getReducedTypes)(['item'], mockClient);
+            expect(result).toEqual([
+                {
+                    id: 'type1',
+                    typePath: 'item',
+                    typeProperties: [
+                        {
+                            slug: 'displayValue',
+                            label: 'Display Value',
+                            propertyType: 'choice',
+                        },
+                    ],
+                },
+            ]);
+        });
+    });
+    describe('removeOptionOrFamilySuffix', () => {
+        it('should remove "Family" suffix from the property name', () => {
+            const result = (0, data_transformer_functions_1.removeOptionOrFamilySuffix)('lifecycleStageFamily');
+            expect(result).toBe('lifecycleStage');
+        });
+        it('should remove "Option" suffix from the property name', () => {
+            const result = (0, data_transformer_functions_1.removeOptionOrFamilySuffix)('lifecycleStageOption');
+            expect(result).toBe('lifecycleStage');
+        });
+        it('should return the same property name if it does not end with "Family" or "Option"', () => {
+            const result = (0, data_transformer_functions_1.removeOptionOrFamilySuffix)('lifecycleStage');
+            expect(result).toBe('lifecycleStage');
+        });
+        it('should handle empty strings correctly', () => {
+            const result = (0, data_transformer_functions_1.removeOptionOrFamilySuffix)('');
+            expect(result).toBe('');
+        });
+        it('should handle property names that contain "Family" or "Option" but do not end with them', () => {
+            const result = (0, data_transformer_functions_1.removeOptionOrFamilySuffix)('FamilyOptionTest');
+            expect(result).toBe('FamilyOptionTest');
+        });
+    });
+});
+describe('identifyKeysInProperties', () => {
+    it('should identify keys matching property slugs and labels', () => {
+        const csvJSON = [
+            {
+                lifecycleStage: 'Active',
+                logoFamily: 'Family A',
+                someOtherProp: 'foo',
+                'Some Label': 'bar',
+            },
+        ];
+        const typePropertySlugs = ['lifecycleStage', 'logoFamily'];
+        const typePropertyLabels = ['Some Label', 'Logo Family'];
+        const { keysInPropertySlugs, keysInPropertyLabels } = (0, data_transformer_functions_1.identifyKeysInProperties)(csvJSON, typePropertySlugs, typePropertyLabels);
+        expect(keysInPropertySlugs.get('lifecycleStage')).toBeTruthy();
+        expect(keysInPropertySlugs.get('logoFamily')).toBeTruthy();
+        expect(keysInPropertySlugs.get('someOtherProp')).toBeFalsy();
+        expect(keysInPropertySlugs.get('Some Label')).toBeFalsy();
+        expect(keysInPropertyLabels.get('lifecycleStage')).toBeFalsy();
+        expect(keysInPropertyLabels.get('logoFamily')).toBeFalsy();
+        expect(keysInPropertyLabels.get('someOtherProp')).toBeFalsy();
+        expect(keysInPropertyLabels.get('Some Label')).toBeTruthy();
+    });
+    it('should handle empty CSV data without erroring out', () => {
+        const csvJSON = [];
+        const typePropertySlugs = ['lifecycleStage', 'logoFamily'];
+        const typePropertyLabels = ['Lifecycle Stage', 'Logo Family'];
+        const { keysInPropertySlugs, keysInPropertyLabels } = (0, data_transformer_functions_1.identifyKeysInProperties)(csvJSON, typePropertySlugs, typePropertyLabels);
+        expect(keysInPropertySlugs.size).toBe(0);
+        expect(keysInPropertyLabels.size).toBe(0);
+    });
+    it('should return false for all keys when CSV data has no matching property slugs or labels', () => {
+        const csvJSON = [{ color: 'Red', size: 'Large', price: 100 }];
+        const typePropertySlugs = ['lifecycleStage', 'logoFamily'];
+        const typePropertyLabels = ['Lifecycle Stage', 'Logo Family'];
+        const { keysInPropertySlugs, keysInPropertyLabels } = (0, data_transformer_functions_1.identifyKeysInProperties)(csvJSON, typePropertySlugs, typePropertyLabels);
+        expect(keysInPropertySlugs.get('color')).toBeFalsy();
+        expect(keysInPropertySlugs.get('size')).toBeFalsy();
+        expect(keysInPropertySlugs.get('price')).toBeFalsy();
+        expect(keysInPropertyLabels.get('color')).toBeFalsy();
+        expect(keysInPropertyLabels.get('size')).toBeFalsy();
+        expect(keysInPropertyLabels.get('price')).toBeFalsy();
+    });
+    it('should return false for all keys when property slug and label arrays are empty', () => {
+        const csvJSON = [{ color: 'Red', size: 'Large', price: 100 }];
+        const typePropertySlugs = [];
+        const typePropertyLabels = [];
+        const { keysInPropertySlugs, keysInPropertyLabels } = (0, data_transformer_functions_1.identifyKeysInProperties)(csvJSON, typePropertySlugs, typePropertyLabels);
+        expect(keysInPropertySlugs.get('color')).toBeFalsy();
+        expect(keysInPropertySlugs.get('size')).toBeFalsy();
+        expect(keysInPropertySlugs.get('price')).toBeFalsy();
+        expect(keysInPropertyLabels.get('color')).toBeFalsy();
+        expect(keysInPropertyLabels.get('size')).toBeFalsy();
+        expect(keysInPropertyLabels.get('price')).toBeFalsy();
+    });
+    it('should handle case sensitivity in property matching', () => {
+        const csvJSON = [
+            {
+                lifecycleStage: 'Active',
+                logoFamily: 'Family A',
+                LifecycleStage: 'Inactive',
+                'Some Label': 'value',
+            },
+        ];
+        const typePropertySlugs = ['lifecycleStage', 'logoFamily'];
+        const typePropertyLabels = ['Lifecycle Stage', 'Logo Family', 'Some Label'];
+        const { keysInPropertySlugs, keysInPropertyLabels } = (0, data_transformer_functions_1.identifyKeysInProperties)(csvJSON, typePropertySlugs, typePropertyLabels);
+        console.log('keysInPropertySlugs', keysInPropertySlugs);
+        console.log('keysInPropertyLabels', keysInPropertyLabels);
+        expect(keysInPropertySlugs.get('lifecycleStage')).toBeTruthy();
+        expect(keysInPropertySlugs.get('LifecycleStage')).toBeFalsy();
+        expect(keysInPropertyLabels.get('some label')).toBeFalsy();
+        expect(keysInPropertyLabels.get('Some Label')).toBeTruthy();
+    });
+});