@contrail/flexplm 1.5.0-alpha.98b8b06 → 1.5.0

package/src/util/data-converter.spec.ts

@@ -0,0 +1,1622 @@
+const mockObj1234 = {
+  id: 1234,
+  typePath: 'color'
+};
+const mockObj2222 = {
+  id: 2222,
+  typePath: 'color'
+};
+const mockGetFunction = jest.fn((options) =>{
+  return (options?.criteria?.id === 1234)
+    ?[mockObj1234]
+    :[mockObj2222];
+});
+jest.mock('@contrail/sdk', () => {
+  const origModule = jest.requireActual('@contrail/sdk');
+  return {
+    __esModule: true,
+    ...origModule,
+    Entities: class {
+      get = mockGetFunction;
+    },
+  };
+});
+
+import { Entities } from '@contrail/sdk';
+import { MapFileUtil } from '@contrail/transform-data';
+import { DataConverter } from './data-converter';
+import { FCConfig } from '../interfaces/interfaces';
+import { TypeConversionUtils } from './type-conversion-utils';
+import { MapUtil } from './map-utils';
+
+describe('getFlexPLMValue multi_select', () => {
+  const config: FCConfig = {
+    apiHost: 'host',
+    userName: () => 'user',
+    password: () => 'pass',
+    urlContext: 'xxx',
+    vibeEventEndpoint: '/rfa/vibeiq/vibeEvents',
+    csrfEndpoint: '/servlet/rest/security/csrf',
+    itemPreDevelopmentLifecycleStages: ['concept']
+  };
+
+  const mapFileUtil = new MapFileUtil(new Entities());
+  const dc = new DataConverter(config, mapFileUtil);
+  const enumAtt = {
+    id: 'cJoZQvoj7dkfCBJq',
+    propertyType: 'multi_select',
+    slug: 'flexMultiSelect',
+    label: 'Flex Multi Select',
+    options: [
+      {
+        value: 'one',
+        display: 'One'
+      },
+      {
+        value: 'two',
+        display: 'Two'
+      },
+      {
+        value: 'three',
+        display: 'Three'
+      }
+    ],
+  };
+
+  it('multi_select_null', async () => {
+    const newData = {
+      flexMultiSelect: null
+    };
+    const returnValue = await dc.getFlexPLMValue(enumAtt, newData, true);
+    expect(returnValue).toEqual([]);
+  });
+
+  it('multi_select_no_values', async () => {
+    const newData = {
+      flexMultiSelect: []
+    };
+    const returnValue = await dc.getFlexPLMValue(enumAtt, newData, true);
+    expect(returnValue).toEqual(newData.flexMultiSelect);
+  });
+
+  it('multi_select_two_values', async () => {
+    const newData = {
+      flexMultiSelect: ['one', 'three']
+    };
+    const optionValues = [
+      { value: 'one', display: 'One' },
+      { value: 'three', display: 'Three' }
+    ];
+    const returnValue = await dc.getFlexPLMValue(enumAtt, newData, true);
+    expect(returnValue).toEqual(optionValues);
+  });
+});
+
+describe('getEnumerationValue', () =>{
+  const config: FCConfig = {
+    apiHost: 'host',
+    userName: () => 'user',
+    password: () => 'pass',
+    urlContext: 'xxx',
+    vibeEventEndpoint: '/rfa/vibeiq/vibeEvents',
+    csrfEndpoint: '/servlet/rest/security/csrf',
+    itemPreDevelopmentLifecycleStages: ['concept']
+  };
+
+  const mapFileUtil = new MapFileUtil(new Entities());
+  const dc = new DataConverter(config, mapFileUtil);
+  const enumProp = {
+    id: 'cJoZQvoj7dkfCBJq',
+    propertyType: 'choice',
+    slug: 'flexChoice',
+    label: 'Flex Choice',
+    options: [
+      {
+        value: 'one',
+        display: 'One'
+      },
+      {
+        value: 'two',
+        display: 'Two'
+      },
+      {
+        value: 'three',
+        display: 'Three'
+      }
+    ],
+  };
+
+  const enumPropNoList = {
+    id: 'cJoZQvoj7dkfCBJq',
+    propertyType: 'choice',
+    slug: 'flexChoice',
+    label: 'Flex Choice',
+  };
+
+  it('match 1 key', () =>{
+    const nd = 'one';
+    const expectedValue = {value: 'one', display: 'One'};
+
+    const returnValue = dc.getEnumerationValue(enumProp, nd);
+    expect(returnValue).toEqual(expectedValue);
+  });
+
+  it('wrong key', () =>{
+    const nd = 'one1';
+    const expectedValue = {};
+
+    const returnValue = dc.getEnumerationValue(enumProp, nd);
+    expect(returnValue).toEqual(expectedValue);
+  });
+
+  it('property no list', () =>{
+    const nd = 'one1';
+    const expectedValue = {};
+
+    const returnValue = dc.getEnumerationValue(enumPropNoList, nd);
+    expect(returnValue).toEqual(expectedValue);
+  });
+
+});
+
+describe('getEnumerationValue multi_select', () => {
+  const config: FCConfig = {
+    apiHost: 'host',
+    userName: () => 'user',
+    password: () => 'pass',
+    urlContext: 'xxx',
+    vibeEventEndpoint: '/rfa/vibeiq/vibeEvents',
+    csrfEndpoint: '/servlet/rest/security/csrf',
+    itemPreDevelopmentLifecycleStages: ['concept']
+  };
+
+  const mapFileUtil = new MapFileUtil(new Entities());
+  const dc = new DataConverter(config, mapFileUtil);
+  const enumAtt = {
+    id: 'cJoZQvoj7dkfCBJq',
+    propertyType: 'multi_select',
+    slug: 'flexMultiSelect',
+    label: 'Flex Multi Select',
+    options: [
+      {
+        value: 'one',
+        display: 'One'
+      },
+      {
+        value: 'two',
+        display: 'Two'
+      },
+      {
+        value: 'three',
+        display: 'Three'
+      }
+    ],
+  };
+
+
+  it('multi_select_null', async () => {
+    const nd = null;
+    const returnValue = await dc.getEnumerationValue(enumAtt, nd);
+    expect(returnValue).toEqual([]);
+  });
+
+  it('multi_select_no_values', async () => {
+    const nd = [];
+    const returnValue = await dc.getEnumerationValue(enumAtt, nd);
+    expect(returnValue).toEqual(nd);
+  });
+
+  it('multi select one string value', async () =>{
+    const nd = 'one';
+    const optionValues = [
+      { value: 'one', display: 'One' }
+    ];
+    const returnValue = await dc.getEnumerationValue(enumAtt, nd);
+    expect(returnValue).toEqual(optionValues);
+  });
+
+  it('multi_select_two_values', async () => {
+    const nd = ['one', 'three'];
+    const optionValues = [
+      { value: 'one', display: 'One' },
+      { value: 'three', display: 'Three' }
+    ];
+    const returnValue = await dc.getEnumerationValue(enumAtt, nd);
+    expect(returnValue).toEqual(optionValues);
+  });
+
+});
+
+describe('getPersistableChanges', () =>{
+  const config: FCConfig = {
+    apiHost: 'host',
+    userName: () => 'user',
+    password: () => 'pass',
+    urlContext: 'xxx',
+    vibeEventEndpoint: '/rfa/vibeiq/vibeEvents',
+    csrfEndpoint: '/servlet/rest/security/csrf',
+    itemPreDevelopmentLifecycleStages: ['concept']
+  };
+
+  const mapFileUtil = new MapFileUtil(new Entities());
+  const dc = new DataConverter(config, mapFileUtil);
+  it('no changes', () =>{
+    const entity = {
+      num: 1
+    };
+    const potentialChanges = {};
+
+    const diffs = dc.getPersistableChanges(entity, potentialChanges);
+    expect(Object.getOwnPropertyNames(diffs).length).toEqual(0);
+  });
+
+  it('same value', () =>{
+    const entity = {
+      str: 'test',
+      num: 1
+    };
+    const potentialChanges = {
+      str: 'test',
+      num: 1
+    };
+
+    const diffs = dc.getPersistableChanges(entity, potentialChanges);
+    expect(Object.getOwnPropertyNames(diffs).length).toEqual(0);
+  });
+
+  it('diff num value', () =>{
+    const entity = {
+      str: 'option 1 string-Changed',
+      num: 12
+    };
+    const potentialChanges = {
+      str: 'option 1 string-Changed',
+      num: 1
+    };
+
+    const diffs = dc.getPersistableChanges(entity, potentialChanges);
+    expect(Object.getOwnPropertyNames(diffs).length).toEqual(1);
+    expect(diffs['num']).toEqual(potentialChanges['num']);
+  });
+
+  it('zero num value', () =>{
+    const entity = {
+      str: 'option 1 string-Changed',
+      num: 12
+    };
+    const potentialChanges = {
+      str: 'option 1 string-Changed',
+      num: 0
+    };
+
+    const diffs = dc.getPersistableChanges(entity, potentialChanges);
+    expect(Object.getOwnPropertyNames(diffs).length).toEqual(1);
+    expect(diffs['num']).toEqual(potentialChanges['num']);
+  });
+
+  it('diff str value', () =>{
+    const entity = {
+      str: 'test',
+      num: 1
+    };
+    const potentialChanges = {
+      str: 'test-1',
+      num: 1
+    };
+
+    const diffs = dc.getPersistableChanges(entity, potentialChanges);
+    expect(Object.getOwnPropertyNames(diffs).length).toEqual(1);
+    expect(diffs['str']).toEqual(potentialChanges['str']);
+  });
+
+  it('empty str value', () =>{
+    const entity = {
+      str: 'test',
+      num: 1
+    };
+    const potentialChanges = {
+      str: '',
+      num: 1
+    };
+
+    const diffs = dc.getPersistableChanges(entity, potentialChanges);
+    expect(Object.getOwnPropertyNames(diffs).length).toEqual(1);
+    expect(diffs['str']).toBeNull();
+  });
+
+});
+
+describe('getObjectReferenceValue cache', () =>{
+  const config: FCConfig = {
+    apiHost: 'host',
+    userName: () => 'user',
+    password: () => 'pass',
+    urlContext: 'xxx',
+    vibeEventEndpoint: '/rfa/vibeiq/vibeEvents',
+    csrfEndpoint: '/servlet/rest/security/csrf',
+    itemPreDevelopmentLifecycleStages: ['concept']
+  };
+
+  const mapFileUtil = new MapFileUtil(new Entities());
+  const dc = new DataConverter(config, mapFileUtil);
+  const ref1Prop = {
+    id: 'cJoZQvoj7dkfCBJq',
+    propertyType: 'object_reference',
+    slug: 'ref1',
+    label: 'Object Ref#1',
+    referencedTypeRootSlug: 'color'
+
+  };
+  const ref2Prop = {
+    id: 'cJoZQvoj7dkfCBJq',
+    propertyType: 'object_reference',
+    slug: 'ref2',
+    label: 'Object Ref#2',
+    referencedTypeRootSlug: 'color'
+
+  };
+  const ref3Prop = {
+    id: 'cJoZQvoj7dkfCBJq',
+    propertyType: 'object_reference',
+    slug: 'ref3',
+    label: 'Object Ref#3',
+    referencedTypeRootSlug: 'color'
+
+  };
+  const newData = {
+    ref1Id: 1234,
+    ref2Id: 2222,
+    ref3Id: 1234
+  };
+
+  it('cache hit', async () =>{
+    const oobFunction = dc.getFlexPLMObjectData;
+    try {
+      dc.getFlexPLMObjectData = async (newData, /*dataToSkip: string[], inflateObjRef: boolean*/) => {
+        return newData;
+      };
+      mockGetFunction.mockClear();
+
+      const r1 = await dc.getObjectReferenceValue(ref1Prop, newData, true);
+      const r2 = await dc.getObjectReferenceValue(ref2Prop, newData, true);
+      const r3 = await dc.getObjectReferenceValue(ref3Prop, newData, true);
+
+      expect(mockGetFunction).toHaveBeenCalledTimes(2);
+      expect(r1).toEqual(mockObj1234);
+      expect(r2).toEqual(mockObj2222);
+      expect(r3).toEqual(mockObj1234);
+
+    } finally {
+      dc.getFlexPLMObjectData = oobFunction;
+    }
+  });
+});
+describe('getObjectReferenceValue bad value', () =>{
+    const config: FCConfig = {
+      apiHost: 'host',
+      userName: () => 'user',
+      password: () => 'pass',
+      urlContext: 'xxx',
+      vibeEventEndpoint: '/rfa/vibeiq/vibeEvents',
+      csrfEndpoint: '/servlet/rest/security/csrf',
+      itemPreDevelopmentLifecycleStages: ['concept']
+    };
+
+    const mapFileUtil = new MapFileUtil(new Entities());
+    const dc = new DataConverter(config, mapFileUtil);
+    const ref1Prop = {
+      id: 'cJoZQvoj7dkfCBJq',
+      propertyType: 'object_reference',
+      slug: 'ref1',
+      label: 'Object Ref#1',
+      referencedTypeRootSlug: 'color'
+
+    };
+    const ref2Prop = {
+      id: 'cJoZQvoj7dkfCBJq',
+      propertyType: 'object_reference',
+      slug: 'ref2',
+      label: 'Object Ref#2',
+      referencedTypeRootSlug: 'color'
+
+    };
+    const ref3Prop = {
+      id: 'cJoZQvoj7dkfCBJq',
+      propertyType: 'object_reference',
+      slug: 'ref3',
+      label: 'Object Ref#3',
+      referencedTypeRootSlug: 'color'
+
+    };
+    const newData = {
+      ref1Id: 1234,
+      ref2Id: 2222,
+      ref3Id: 1234,
+      ref3: 'old value'
+    };
+
+    it('old string value', async () =>{
+      const oobFunction = dc.getFlexPLMObjectData;
+      try {
+        dc.getFlexPLMObjectData = async (newData, /*dataToSkip: string[], inflateObjRef: boolean*/) => {
+          return newData;
+        };
+        mockGetFunction.mockClear();
+        const r3 = await dc.getObjectReferenceValue(ref3Prop, newData, true);
+        expect(r3).toEqual(mockObj1234);
+
+      } finally {
+        dc.getFlexPLMObjectData = oobFunction;
+      }
+    });
+
+    it('only id', async () =>{
+      const oobFunction = dc.getFlexPLMObjectData;
+      try {
+        dc.getFlexPLMObjectData = async (newData, /*dataToSkip: string[], inflateObjRef: boolean*/) => {
+          return newData;
+        };
+        mockGetFunction.mockClear();
+        const r2 = await dc.getObjectReferenceValue(ref2Prop, newData, true);
+        expect(r2).toEqual(mockObj2222);
+
+      } finally {
+        dc.getFlexPLMObjectData = oobFunction;
+      }
+    });
+
+    it('already references object', async () =>{
+      const testData = {
+        ref1Id: 1234,
+        ref1: mockObj1234,
+        ref2Id: 2222,
+        ref3Id: 1234,
+        ref3: 'old value'
+      };
+
+      const oobFunction = dc.getFlexPLMObjectData;
+      try {
+        dc.getFlexPLMObjectData = async (newData, /*dataToSkip: string[], inflateObjRef: boolean*/) => {
+          return newData;
+        };
+        mockGetFunction.mockClear();
+        const r1 = await dc.getObjectReferenceValue(ref1Prop, testData, true);
+        expect(r1).toEqual(mockObj1234);
+
+      } finally {
+        dc.getFlexPLMObjectData = oobFunction;
+      }
+    });
+
+    it('old string value, no refId', async () =>{
+      const testData = {
+        ref1: 'old value'
+      };
+
+      const oobFunction = dc.getFlexPLMObjectData;
+      try {
+        dc.getFlexPLMObjectData = async (newData, /*dataToSkip: string[], inflateObjRef: boolean*/) => {
+          return newData;
+        };
+        mockGetFunction.mockClear();
+        const r1 = await dc.getObjectReferenceValue(ref1Prop, testData, true);
+        expect(r1).toEqual({});
+
+      } finally {
+        dc.getFlexPLMObjectData = oobFunction;
+      }
+    });
+
+});
+
+describe('setObjectReferenceValue - identity service', () => {
+  const baseConfig = (): FCConfig => ({
+    apiHost: 'host',
+    userName: () => 'user',
+    password: () => 'pass',
+    urlContext: 'xxx',
+    vibeEventEndpoint: '/rfa/vibeiq/vibeEvents',
+    csrfEndpoint: '/servlet/rest/security/csrf',
+    itemPreDevelopmentLifecycleStages: ['concept']
+  });
+
+  const refProp = {
+    id: 'cJoZQvoj7dkfCBJq',
+    propertyType: 'object_reference',
+    slug: 'material',
+    label: 'Material',
+    referencedTypeRootSlug: 'item',
+    referencedTypePath: 'item:material'
+  };
+
+  let identifierSpy: jest.SpyInstance;
+  let poolKeySpy: jest.SpyInstance;
+  let getByRootAndPathSpy: jest.SpyInstance;
+  let filterTypePropertiesSpy: jest.SpyInstance;
+
+  const setupTypeUtilsSpies = (dc: DataConverter, rootPropSlugs: string[] = ['itemNumber']) => {
+    getByRootAndPathSpy = jest.spyOn(dc['typeUtils'], 'getByRootAndPath')
+      .mockImplementation(async () => ({ typePath: 'item', typeProperties: [] }) as any);
+    filterTypePropertiesSpy = jest.spyOn(dc['typeUtils'], 'filterTypeProperties')
+      .mockImplementation(() => rootPropSlugs.map(slug => ({ slug })) as any);
+  };
+
+  afterEach(() => {
+    identifierSpy?.mockRestore();
+    poolKeySpy?.mockRestore();
+    getByRootAndPathSpy?.mockRestore();
+    filterTypePropertiesSpy?.mockRestore();
+    mockGetFunction.mockReset();
+    mockGetFunction.mockImplementation((options) =>
+      ((options?.criteria?.id === 1234) ? [mockObj1234] : [mockObj2222]) as any
+    );
+  });
+
+  it('flag off - uses getAllObjectReferences path', async () => {
+    const dc = new DataConverter(baseConfig(), new MapFileUtil(new Entities()));
+    setupTypeUtilsSpies(dc, ['itemNumber', 'roles']);
+
+    identifierSpy = jest.spyOn(TypeConversionUtils, 'getIdentifierPropertiesFromObject')
+      .mockImplementation(async () => ['itemNumber', 'roles']);
+    poolKeySpy = jest.spyOn(TypeConversionUtils, 'getUniquenessPoolKeyFromObject')
+      .mockImplementation(async () => 'item:material');
+
+    mockGetFunction.mockClear();
+    mockGetFunction.mockImplementation(() => [{ id: 'abc123', typePath: 'item:material' }] as any);
+
+    const nd = { itemNumber: 'MAT-100', roles: ['family'] };
+    const result = await dc.setObjectReferenceValue(refProp, nd);
+
+    expect(mockGetFunction).toHaveBeenCalled();
+    const callArg = mockGetFunction.mock.calls[0][0];
+    expect(callArg.entityName).toEqual('item');
+    expect(callArg.entityName).not.toEqual('identity');
+    expect(result).toEqual('abc123');
+    expect(poolKeySpy).not.toHaveBeenCalled();
+  });
+
+  it('flag on, single identity match - returns parsed id', async () => {
+    const config = baseConfig();
+    config.search = { item: { useIdentityServiceForInboundData: true } };
+    const dc = new DataConverter(config, new MapFileUtil(new Entities()));
+    setupTypeUtilsSpies(dc);
+
+    identifierSpy = jest.spyOn(TypeConversionUtils, 'getIdentifierPropertiesFromObject')
+      .mockImplementation(async () => ['itemNumber', 'roles']);
+    poolKeySpy = jest.spyOn(TypeConversionUtils, 'getUniquenessPoolKeyFromObject')
+      .mockImplementation(async () => 'item:material');
+
+    mockGetFunction.mockClear();
+    mockGetFunction.mockImplementation(() => [{ entityReference: 'item:abc123' }] as any);
+
+    const nd = { itemNumber: 'MAT-100', roles: ['family'] };
+    const result = await dc.setObjectReferenceValue(refProp, nd);
+
+    expect(mockGetFunction).toHaveBeenCalledTimes(1);
+    const callArg = mockGetFunction.mock.calls[0][0];
+    expect(callArg.entityName).toEqual('identity');
+    expect(callArg.criteria).toEqual({
+      poolKey: 'item:material',
+      propertyName: 'itemNumber',
+      propertyValue: 'MAT-100'
+    });
+    expect(result).toEqual('abc123');
+  });
+
+  it('flag on, no identity match - returns empty and warns', async () => {
+    const config = baseConfig();
+    config.search = { item: { useIdentityServiceForInboundData: true } };
+    const dc = new DataConverter(config, new MapFileUtil(new Entities()));
+    setupTypeUtilsSpies(dc);
+
+    identifierSpy = jest.spyOn(TypeConversionUtils, 'getIdentifierPropertiesFromObject')
+      .mockImplementation(async () => ['itemNumber', 'roles']);
+    poolKeySpy = jest.spyOn(TypeConversionUtils, 'getUniquenessPoolKeyFromObject')
+      .mockImplementation(async () => 'item:material');
+
+    mockGetFunction.mockClear();
+    mockGetFunction.mockImplementation(() => [] as any);
+    const warnSpy = jest.spyOn(console, 'warn').mockImplementation(() => {});
+    const getAllSpy = jest.spyOn(dc, 'getAllObjectReferences');
+
+    try {
+      const result = await dc.setObjectReferenceValue(refProp, { itemNumber: 'MAT-100', roles: ['family'] });
+      expect(result).toEqual('');
+      expect(warnSpy).toHaveBeenCalled();
+      expect(getAllSpy).not.toHaveBeenCalled();
+    } finally {
+      warnSpy.mockRestore();
+      getAllSpy.mockRestore();
+    }
+  });
+
+  it('flag on, multiple identity matches - returns empty and does not throw', async () => {
+    const config = baseConfig();
+    config.search = { item: { useIdentityServiceForInboundData: true } };
+    const dc = new DataConverter(config, new MapFileUtil(new Entities()));
+    setupTypeUtilsSpies(dc);
+
+    identifierSpy = jest.spyOn(TypeConversionUtils, 'getIdentifierPropertiesFromObject')
+      .mockImplementation(async () => ['itemNumber', 'roles']);
+    poolKeySpy = jest.spyOn(TypeConversionUtils, 'getUniquenessPoolKeyFromObject')
+      .mockImplementation(async () => 'item:material');
+
+    mockGetFunction.mockClear();
+    mockGetFunction.mockImplementation(() => [
+      { entityReference: 'item:abc123' },
+      { entityReference: 'item:def456' }
+    ] as any);
+    const warnSpy = jest.spyOn(console, 'warn').mockImplementation(() => {});
+
+    try {
+      const result = await dc.setObjectReferenceValue(refProp, { itemNumber: 'MAT-100', roles: ['family'] });
+      expect(result).toEqual('');
+      expect(warnSpy).toHaveBeenCalled();
+    } finally {
+      warnSpy.mockRestore();
+    }
+  });
+
+  it('flag on, ambiguous identifier set - falls back to getAllObjectReferences', async () => {
+    const config = baseConfig();
+    config.search = { item: { useIdentityServiceForInboundData: true } };
+    const dc = new DataConverter(config, new MapFileUtil(new Entities()));
+    setupTypeUtilsSpies(dc, ['itemNumber', 'season', 'roles']);
+
+    identifierSpy = jest.spyOn(TypeConversionUtils, 'getIdentifierPropertiesFromObject')
+      .mockImplementation(async () => ['itemNumber', 'season', 'roles']);
+    poolKeySpy = jest.spyOn(TypeConversionUtils, 'getUniquenessPoolKeyFromObject')
+      .mockImplementation(async () => 'item:material');
+
+    mockGetFunction.mockClear();
+    mockGetFunction.mockImplementation(() => [{ id: 'abc123', typePath: 'item:material' }] as any);
+
+    const nd = { itemNumber: 'MAT-100', season: 'SS24', roles: ['family'] };
+    const result = await dc.setObjectReferenceValue(refProp, nd);
+
+    expect(mockGetFunction).toHaveBeenCalled();
+    const callArg = mockGetFunction.mock.calls[0][0];
+    expect(callArg.entityName).toEqual('item');
+    expect(callArg.entityName).not.toEqual('identity');
+    expect(result).toEqual('abc123');
+    expect(poolKeySpy).not.toHaveBeenCalled();
+  });
+
+  it('flag on, cache hit - second call short-circuits', async () => {
+    const config = baseConfig();
+    config.search = { item: { useIdentityServiceForInboundData: true } };
+    const dc = new DataConverter(config, new MapFileUtil(new Entities()));
+    setupTypeUtilsSpies(dc);
+
+    identifierSpy = jest.spyOn(TypeConversionUtils, 'getIdentifierPropertiesFromObject')
+      .mockImplementation(async () => ['itemNumber', 'roles']);
+    poolKeySpy = jest.spyOn(TypeConversionUtils, 'getUniquenessPoolKeyFromObject')
+      .mockImplementation(async () => 'item:material');
+
+    mockGetFunction.mockClear();
+    mockGetFunction.mockImplementation(() => [{ entityReference: 'item:abc123' }] as any);
+
+    const nd = { itemNumber: 'MAT-100', roles: ['family'] };
+    const r1 = await dc.setObjectReferenceValue(refProp, nd);
+    const r2 = await dc.setObjectReferenceValue(refProp, nd);
+
+    expect(r1).toEqual('abc123');
+    expect(r2).toEqual('abc123');
+    expect(mockGetFunction).toHaveBeenCalledTimes(1);
+  });
+
+  it('flag on, project-item entityType - roles is filtered, identity path used', async () => {
+    const projectItemProp = {
+      ...refProp,
+      referencedTypeRootSlug: 'project-item',
+      referencedTypePath: 'project-item'
+    };
+    const config = baseConfig();
+    config.search = { 'project-item': { useIdentityServiceForInboundData: true } };
+    const dc = new DataConverter(config, new MapFileUtil(new Entities()));
+    setupTypeUtilsSpies(dc, ['itemNumber', 'roles']);
+
+    identifierSpy = jest.spyOn(TypeConversionUtils, 'getIdentifierPropertiesFromObject')
+      .mockImplementation(async () => ['itemNumber', 'roles']);
+    poolKeySpy = jest.spyOn(TypeConversionUtils, 'getUniquenessPoolKeyFromObject')
+      .mockImplementation(async () => 'project-item');
+
+    mockGetFunction.mockClear();
+    mockGetFunction.mockImplementation(() => [{ entityReference: 'project-item:pi-789' }] as any);
+
+    const result = await dc.setObjectReferenceValue(projectItemProp, { itemNumber: 'X1', roles: ['family'] });
+
+    expect(mockGetFunction).toHaveBeenCalledTimes(1);
+    const callArg = mockGetFunction.mock.calls[0][0];
+    expect(callArg.entityName).toEqual('identity');
+    expect(callArg.criteria.propertyName).toEqual('itemNumber');
+    expect(result).toEqual('pi-789');
+  });
+
+  it('flag on, non-item entityType - roles is NOT filtered, falls back to query path', async () => {
+    const colorProp = {
+      ...refProp,
+      referencedTypeRootSlug: 'color',
+      referencedTypePath: 'color'
+    };
+    const config = baseConfig();
+    config.search = { color: { useIdentityServiceForInboundData: true } };
+    const dc = new DataConverter(config, new MapFileUtil(new Entities()));
+    setupTypeUtilsSpies(dc, ['colorNumber', 'roles']);
+
+    identifierSpy = jest.spyOn(TypeConversionUtils, 'getIdentifierPropertiesFromObject')
+      .mockImplementation(async () => ['colorNumber', 'roles']);
+    poolKeySpy = jest.spyOn(TypeConversionUtils, 'getUniquenessPoolKeyFromObject')
+      .mockImplementation(async () => 'color');
+
+    mockGetFunction.mockClear();
+    mockGetFunction.mockImplementation(() => [{ id: 'col-1', typePath: 'color' }] as any);
+
+    const result = await dc.setObjectReferenceValue(colorProp, { colorNumber: 'C1', roles: ['family'] });
+
+    expect(mockGetFunction).toHaveBeenCalled();
+    const callArg = mockGetFunction.mock.calls[0][0];
+    expect(callArg.entityName).toEqual('color');
+    expect(callArg.entityName).not.toEqual('identity');
+    expect(result).toEqual('col-1');
+    expect(poolKeySpy).not.toHaveBeenCalled();
+  });
+
+  it('query path, multiple matches - returns empty with single warn (no double warn)', async () => {
+    const dc = new DataConverter(baseConfig(), new MapFileUtil(new Entities()));
+    setupTypeUtilsSpies(dc, ['itemNumber']);
+
+    identifierSpy = jest.spyOn(TypeConversionUtils, 'getIdentifierPropertiesFromObject')
+      .mockImplementation(async () => ['itemNumber']);
+
+    mockGetFunction.mockClear();
+    mockGetFunction.mockImplementation(() => [
+      { id: 'a1', typePath: 'item:material' },
+      { id: 'a2', typePath: 'item:material' }
+    ] as any);
+    const warnSpy = jest.spyOn(console, 'warn').mockImplementation(() => {});
+
+    try {
+      const result = await dc.setObjectReferenceValue(refProp, { itemNumber: 'MAT-100' });
+      expect(result).toEqual('');
+      expect(warnSpy).toHaveBeenCalledTimes(1);
+      expect(warnSpy.mock.calls[0][0]).toMatch(/duplicate records/);
+    } finally {
+      warnSpy.mockRestore();
+    }
+  });
+
+  it('flag on, identity returns null - normalized to empty array, returns empty', async () => {
+    const config = baseConfig();
+    config.search = { item: { useIdentityServiceForInboundData: true } };
+    const dc = new DataConverter(config, new MapFileUtil(new Entities()));
+    setupTypeUtilsSpies(dc);
+
+    identifierSpy = jest.spyOn(TypeConversionUtils, 'getIdentifierPropertiesFromObject')
+      .mockImplementation(async () => ['itemNumber', 'roles']);
+    poolKeySpy = jest.spyOn(TypeConversionUtils, 'getUniquenessPoolKeyFromObject')
+      .mockImplementation(async () => 'item:material');
+
+    mockGetFunction.mockClear();
+    mockGetFunction.mockImplementation(() => null as any);
+    const warnSpy = jest.spyOn(console, 'warn').mockImplementation(() => {});
+
+    try {
+      const result = await dc.setObjectReferenceValue(refProp, { itemNumber: 'MAT-100', roles: ['family'] });
+      expect(result).toEqual('');
+      expect(warnSpy).toHaveBeenCalled();
+    } finally {
+      warnSpy.mockRestore();
+    }
+  });
+
+  it('null nd - returns empty string and does not query', async () => {
+    const dc = new DataConverter(baseConfig(), new MapFileUtil(new Entities()));
+    mockGetFunction.mockClear();
+    const result = await dc.setObjectReferenceValue(refProp, null);
+    expect(result).toEqual('');
+    expect(mockGetFunction).not.toHaveBeenCalled();
+  });
+
+  it('zero identifier keys - warns and returns empty string', async () => {
+    const dc = new DataConverter(baseConfig(), new MapFileUtil(new Entities()));
+    setupTypeUtilsSpies(dc);
+    identifierSpy = jest.spyOn(TypeConversionUtils, 'getIdentifierPropertiesFromObject')
+      .mockImplementation(async () => []);
+    mockGetFunction.mockClear();
+    const warnSpy = jest.spyOn(console, 'warn').mockImplementation(() => {});
+
+    try {
+      const result = await dc.setObjectReferenceValue(refProp, { itemNumber: 'MAT-100' });
+      expect(result).toEqual('');
+      expect(warnSpy).toHaveBeenCalledWith(expect.stringMatching(/doesnt have all "identifier" properties/));
+      expect(mockGetFunction).not.toHaveBeenCalled();
+    } finally {
+      warnSpy.mockRestore();
+    }
+  });
+
+  it('missing identifier keys on nd - warns and returns empty string', async () => {
+    const dc = new DataConverter(baseConfig(), new MapFileUtil(new Entities()));
+    setupTypeUtilsSpies(dc);
+    identifierSpy = jest.spyOn(TypeConversionUtils, 'getIdentifierPropertiesFromObject')
+      .mockImplementation(async () => ['itemNumber', 'season']);
+    mockGetFunction.mockClear();
+    const warnSpy = jest.spyOn(console, 'warn').mockImplementation(() => {});
+
+    try {
+      const result = await dc.setObjectReferenceValue(refProp, { itemNumber: 'MAT-100' });
+      expect(result).toEqual('');
+      expect(warnSpy).toHaveBeenCalledWith(expect.stringMatching(/doesnt have all "identifier" properties/));
+      expect(mockGetFunction).not.toHaveBeenCalled();
+    } finally {
+      warnSpy.mockRestore();
+    }
+  });
+
+  it('transformMapFile set - applyInboundTransformMap is invoked before context build', async () => {
+    const config = baseConfig();
+    config['transformMapFile'] = 'file1';
+    const dc = new DataConverter(config, new MapFileUtil(new Entities()));
+    setupTypeUtilsSpies(dc, ['itemNumber', 'roles']);
+
+    identifierSpy = jest.spyOn(TypeConversionUtils, 'getIdentifierPropertiesFromObject')
+      .mockImplementation(async () => ['itemNumber', 'roles']);
+    const mapKeySpy = jest.spyOn(TypeConversionUtils, 'getMapKeyFromObject')
+      .mockImplementation(async () => 'LCSMaterial');
+    const applyMapSpy = jest.spyOn(MapUtil, 'applyTransformMap')
+      .mockImplementation(async (...args) => args[2]);
+
+    mockGetFunction.mockClear();
+    mockGetFunction.mockImplementation(() => [{ id: 'q-1', typePath: 'item:material' }] as any);
+
+    try {
+      const result = await dc.setObjectReferenceValue(refProp, { itemNumber: 'MAT-100', roles: ['family'] });
+      expect(mapKeySpy).toHaveBeenCalledTimes(1);
+      expect(applyMapSpy).toHaveBeenCalledTimes(1);
+      expect(applyMapSpy.mock.calls[0][3]).toEqual('LCSMaterial');
+      expect(result).toEqual('q-1');
+    } finally {
+      mapKeySpy.mockRestore();
+      applyMapSpy.mockRestore();
+    }
+  });
+
+  it('transformMapFile unset - applyInboundTransformMap does not invoke map utilities', async () => {
+    const dc = new DataConverter(baseConfig(), new MapFileUtil(new Entities()));
+    setupTypeUtilsSpies(dc, ['itemNumber', 'roles']);
+
+    identifierSpy = jest.spyOn(TypeConversionUtils, 'getIdentifierPropertiesFromObject')
+      .mockImplementation(async () => ['itemNumber', 'roles']);
+    const mapKeySpy = jest.spyOn(TypeConversionUtils, 'getMapKeyFromObject');
+    const applyMapSpy = jest.spyOn(MapUtil, 'applyTransformMap');
+
+    mockGetFunction.mockClear();
+    mockGetFunction.mockImplementation(() => [{ id: 'q-2', typePath: 'item:material' }] as any);
+
+    try {
+      const result = await dc.setObjectReferenceValue(refProp, { itemNumber: 'MAT-100', roles: ['family'] });
+      expect(mapKeySpy).not.toHaveBeenCalled();
+      expect(applyMapSpy).not.toHaveBeenCalled();
+      expect(result).toEqual('q-2');
+    } finally {
+      mapKeySpy.mockRestore();
+      applyMapSpy.mockRestore();
+    }
+  });
+
+  it('query path success - writes id to cache (second call short-circuits)', async () => {
+    const dc = new DataConverter(baseConfig(), new MapFileUtil(new Entities()));
+    setupTypeUtilsSpies(dc, ['itemNumber', 'roles']);
+
+    identifierSpy = jest.spyOn(TypeConversionUtils, 'getIdentifierPropertiesFromObject')
+      .mockImplementation(async () => ['itemNumber', 'roles']);
+
+    mockGetFunction.mockClear();
+    mockGetFunction.mockImplementation(() => [{ id: 'cached-q', typePath: 'item:material' }] as any);
+
+    const nd = { itemNumber: 'MAT-100', roles: ['family'] };
+    const r1 = await dc.setObjectReferenceValue(refProp, nd);
+    const callsAfterFirst = mockGetFunction.mock.calls.length;
+    const r2 = await dc.setObjectReferenceValue(refProp, nd);
+
+    expect(r1).toEqual('cached-q');
+    expect(r2).toEqual('cached-q');
+    expect(mockGetFunction.mock.calls.length).toEqual(callsAfterFirst);
+  });
+
+  it('query path with subtype filter - applies checkKeysAndValues when entityType !== entityTypePath', async () => {
+    const dc = new DataConverter(baseConfig(), new MapFileUtil(new Entities()));
+    setupTypeUtilsSpies(dc, ['itemNumber']);
+
+    identifierSpy = jest.spyOn(TypeConversionUtils, 'getIdentifierPropertiesFromObject')
+      .mockImplementation(async () => ['itemNumber', 'season']);
+    const checkSpy = jest.spyOn(dc, 'checkKeysAndValues')
+      .mockImplementation((_criteria, arr) => arr);
+
+    mockGetFunction.mockClear();
+    mockGetFunction.mockImplementation(() => [{ id: 'sub-1', typePath: 'item:material' }] as any);
+
+    try {
+      const result = await dc.setObjectReferenceValue(refProp, { itemNumber: 'MAT-100', season: 'SS24' });
+      expect(checkSpy).toHaveBeenCalledTimes(1);
+      expect(checkSpy.mock.calls[0][2]).toEqual('item:material');
+      expect(result).toEqual('sub-1');
+    } finally {
+      checkSpy.mockRestore();
+    }
+  });
+
+  it('pickSingleResult single result - identity branch parses id from entityReference', async () => {
+    const config = baseConfig();
+    config.search = { item: { useIdentityServiceForInboundData: true } };
+    const dc = new DataConverter(config, new MapFileUtil(new Entities()));
+    setupTypeUtilsSpies(dc);
+
+    identifierSpy = jest.spyOn(TypeConversionUtils, 'getIdentifierPropertiesFromObject')
+      .mockImplementation(async () => ['itemNumber', 'roles']);
+    poolKeySpy = jest.spyOn(TypeConversionUtils, 'getUniquenessPoolKeyFromObject')
+      .mockImplementation(async () => 'item:material');
+
+    mockGetFunction.mockClear();
+    mockGetFunction.mockImplementation(() => [{ entityReference: 'item:parsed-id-from-ref' }] as any);
+
+    const result = await dc.setObjectReferenceValue(refProp, { itemNumber: 'MAT-100', roles: ['family'] });
+    expect(result).toEqual('parsed-id-from-ref');
+  });
+});
+
+describe('getObjectReferenceValue - use mapping', () => {
+
+  const maps = require('./data-converter-spec-mockData');
+  const mapping = maps['mapping'];
+  const config: FCConfig = {
+    apiHost: 'host',
+    userName: () => 'user',
+    password: () => 'pass',
+    urlContext: 'xxx',
+    transformMapFile: 'file1',
+    vibeEventEndpoint: '/rfa/vibeiq/vibeEvents',
+    csrfEndpoint: '/servlet/rest/security/csrf',
+    itemPreDevelopmentLifecycleStages: ['concept']
+  } as any;
+
+  const mapFileUtil = new MapFileUtil(new Entities());
+  const dc = new DataConverter(config, mapFileUtil);
+
+  const ref1Prop = {
+    id: 'cJoZQvoj7dkfCBJq',
+    propertyType: 'object_reference',
+    slug: 'ref1',
+    label: 'Object Ref#1',
+    referencedTypeRootSlug: 'color'
+
+  };
+  const ref2Prop = {
+    id: 'cJoZQvoj7dkfCBJq',
+    propertyType: 'object_reference',
+    slug: 'ref2',
+    label: 'Object Ref#2',
+    referencedTypeRootSlug: 'color'
+
+  };
+  const ref3Prop = {
+    id: 'cJoZQvoj7dkfCBJq',
+    propertyType: 'object_reference',
+    slug: 'ref3',
+    label: 'Object Ref#3',
+    referencedTypeRootSlug: 'color'
+
+  };
+  const newData = {
+    ref1Id: 1234,
+    ref1: mockObj1234,
+    ref2Id: 2222,
+    ref2: mockObj2222,
+    ref3Id: 1234,
+    ref3: mockObj1234
+  };
+
+  it('mapping test', async () =>{
+    const oobFunction = dc.getFlexPLMObjectData;
+    try {
+      dc.getFlexPLMObjectData = async (newData, /*dataToSkip: string[], inflateObjRef: boolean*/) => {
+        return newData;
+      };
+      mockGetFunction.mockClear();
+
+      let spyGetObjectClass = jest.spyOn(TypeConversionUtils, 'getObjectClass')
+        .mockImplementation(async () => {return 'LCSColor'});
+
+      let spyGetObjectTypePath = jest.spyOn(TypeConversionUtils, 'getObjectTypePath')
+        .mockImplementation(async () => {return 'Color'});
+
+      let spyGetMapKey = jest.spyOn(TypeConversionUtils, 'getMapKey')
+        .mockImplementation(async () => {return 'LCSColor'});
+
+      let spyApplyTransformMap = jest.spyOn(MapUtil, 'applyTransformMap')
+        .mockImplementation(async (...args) => {return args[2]});
+
+      const r1 = await dc.getObjectReferenceValue(ref1Prop, newData, true);
+      const r2 = await dc.getObjectReferenceValue(ref2Prop, newData, true);
+
+      expect(spyGetObjectClass).toHaveBeenCalledTimes(2);
+      expect(spyGetObjectTypePath).toHaveBeenCalledTimes(2);
+      expect(spyGetMapKey).toHaveBeenCalledTimes(2);
+      expect(spyApplyTransformMap).toHaveBeenCalledTimes(2);
+
+    } finally {
+      dc.getFlexPLMObjectData = oobFunction;
+    }
+  });
+});
+
+describe('getEntityValues', () => {
+  const config: FCConfig = {
+    apiHost: 'host',
+    userName: () => 'user',
+    password: () => 'pass',
+    urlContext: 'xxx',
+    vibeEventEndpoint: '/rfa/vibeiq/vibeEvents',
+    csrfEndpoint: '/servlet/rest/security/csrf',
+    itemPreDevelopmentLifecycleStages: ['concept']
+  };
+  const mapFileUtil = new MapFileUtil(new Entities());
+  const dc = new DataConverter(config, mapFileUtil);
+
+  const runWithStubs = async (typePath: string, objectClass: string, data: any) => {
+    const tcoSpy = jest.spyOn(dc['typeUtils'], 'getEntityTypeClientOptionsUsingMapping')
+      .mockImplementation(async () => ({ root: 'item' }));
+    const typeSpy = jest.spyOn(dc['typeUtils'], 'getByRootAndPath')
+      .mockImplementation(async () => ({ typePath, typeProperties: [] }));
+    const filterSpy = jest.spyOn(dc['typeUtils'], 'filterTypeProperties')
+      .mockImplementation(() => []);
+    try {
+      return await dc.getEntityValues(objectClass, data);
+    } finally {
+      tcoSpy.mockRestore();
+      typeSpy.mockRestore();
+      filterSpy.mockRestore();
+    }
+  };
+
+  it('LCSProduct -> roles family', async () => {
+    const result = await runWithStubs('item', 'LCSProduct', { itemNumber: 'X1' });
+    expect(result['roles']).toEqual(['family']);
+  });
+
+  it('LCSSKU -> roles color, option', async () => {
+    const result = await runWithStubs('item', 'LCSSKU', { itemNumber: 'X1' });
+    expect(result['roles']).toEqual(['color', 'option']);
+  });
+
+  it('LCSMaterial -> roles family', async () => {
+    const result = await runWithStubs('item:material', 'LCSMaterial', { itemNumber: 'MAT-100' });
+    expect(result['roles']).toEqual(['family']);
+  });
+});
+
+describe('setEnumerationKeys', () =>{
+  const config: FCConfig = {
+    apiHost: 'host',
+    userName: () => 'user',
+    password: () => 'pass',
+    urlContext: 'xxx',
+    vibeEventEndpoint: '/rfa/vibeiq/vibeEvents',
+    csrfEndpoint: '/servlet/rest/security/csrf',
+    itemPreDevelopmentLifecycleStages: ['concept']
+  };
+
+  const mapFileUtil = new MapFileUtil(new Entities());
+  const dc = new DataConverter(config, mapFileUtil);
+  const enumProp = {
+    id: 'cJoZQvoj7dkfCBJq',
+    propertyType: 'multi_select',
+    slug: 'flexMultiSelect',
+    label: 'Flex Multi Select',
+    options: [
+      {
+        value: 'one',
+        display: 'One'
+      },
+      {
+        value: 'two',
+        display: 'Two'
+      },
+      {
+        value: 'three',
+        display: 'Three'
+      }
+    ],
+  };
+
+  const enumPropNoList = {
+    id: 'cJoZQvoj7dkfCBJq',
+    propertyType: 'multi_select',
+    slug: 'flexMultiSelect',
+    label: 'Flex Multi Select',
+  };
+
+  it('match 1 key', () =>{
+    const newData = [{value: 'one', display: 'One'}];
+
+    const returnValue = dc.setEnumerationKeys(enumProp, newData, false);
+    expect(returnValue).toEqual(['one']);
+  });
+
+  it('match 2 key', () =>{
+    const newData = [{value: 'one', display: 'One'}, {value: 'two', display: 'Two'}];
+
+    const returnValue = dc.setEnumerationKeys(enumProp, newData, false);
+    expect(returnValue).toEqual(['one', 'two']);
+  });
+
+  it('match 1 display', () =>{
+    const newData = [{value: 'one', display: 'One'}];
+
+    const returnValue = dc.setEnumerationKeys(enumProp, newData, true);
+    expect(returnValue).toEqual(['one']);
+  });
+
+  it('match 2 display', () =>{
+    const newData = [{value: 'one', display: 'One'}, {value: 'two', display: 'Two'}];
+
+    const returnValue = dc.setEnumerationKeys(enumProp, newData, true);
+    expect(returnValue).toEqual(['one', 'two']);
+  });
+
+  it('property no list', () =>{
+    const newData = [{value: 'one', display: 'One'}, {value: 'two', display: 'Two'}];
+
+    const returnValue = dc.setEnumerationKeys(enumPropNoList, newData, false);
+    expect(returnValue).toEqual([]);
+  });
+
+});
+
+describe('checkKeysAndValues', () =>{
+  const config: FCConfig = {
+    apiHost: 'host',
+    userName: () => 'user',
+    password: () => 'pass',
+    urlContext: 'xxx',
+    vibeEventEndpoint: '/rfa/vibeiq/vibeEvents',
+    csrfEndpoint: '/servlet/rest/security/csrf',
+    itemPreDevelopmentLifecycleStages: ['concept']
+  };
+
+  const mapFileUtil = new MapFileUtil(new Entities());
+  const dc = new DataConverter(config, mapFileUtil);
+  const groupData = [
+    {name: 'Group 1', typePath: 'custom-entity:grouping'},
+    {name: 'Group 2', typePath: 'custom-entity:grouping'},
+    {name: 'Group 2', typePath: 'custom-entity:grouping'},
+    {name: 'Group 4', typePath: 'custom-entity:grouping'},
+    {name: 'Group 4', typePath: 'custom-entity:grouping:sub'},
+    {name: 'Group 5', typePath: 'custom-entity:grouping:sub'}
+  ];
+  //item:product:newBalance:accessories, item:product:newBalance:apparel
+
+  it('Group 1', () =>{
+    const criteria = {
+      name: 'Group 1'
+    }
+    const typePath = 'custom-entity:grouping';
+    const results = dc.checkKeysAndValues(criteria, groupData, typePath);
+    expect(results.length).toBe(1);
+  });
+
+  it('Group 5 - sub type of typePath', () =>{
+    const criteria = {
+      name: 'Group 5'
+    }
+    const typePath = 'custom-entity:grouping';
+    const results = dc.checkKeysAndValues(criteria, groupData, typePath);
+    expect(results.length).toBe(1);
+  });
+  it('Group 2 - returns the 2 matching', () =>{
+    const criteria = {
+      name: 'Group 2'
+    }
+    const typePath = 'custom-entity:grouping';
+    const results = dc.checkKeysAndValues(criteria, groupData, typePath);
+    expect(results.length).toBe(2);
+  });
+
+  it('2 Same Name - but 1 is a sub type; returns 2', () =>{
+    const criteria = {
+      name: 'Group 4'
+    }
+    const typePath = 'custom-entity:grouping';
+    const results = dc.checkKeysAndValues(criteria, groupData, typePath);
+    expect(results.length).toBe(2);
+  });
+
+  it('2 Same Name - but 1 wrong type', () =>{
+    const criteria = {
+      name: 'Group 1'
+    }
+    const testData =[...groupData];
+    testData.push({name: 'Group 1', typePath: 'custom-entity:label'});
+    const typePath = 'custom-entity:grouping';
+    const results = dc.checkKeysAndValues(criteria, testData, typePath);
+    expect(results.length).toBe(1);
+  });
+
+  it('first & last entity have the wrong typePath', () =>{
+    const criteria ={
+      objectId: "2562",
+    };
+    const typePath = 'custom-entity:group2';
+
+    const testData = [
+      {"typePath":"custom-entity:group1","name":"BLACK (BK)","id":"o1v2rh8olgQ78GcL","objectId":"2562","entityType":"custom-entity"},
+      {"typePath":"custom-entity:group2","name":"BLACK (BK)","id":"t5n22S2gqswe8GcL","objectId":"2562","entityType":"custom-entity"},
+      {"typePath":"custom-entity:group1","name":"BLACK (BK)","id":"t5rh8o2gqswk3drt","objectId":"2562","entityType":"custom-entity"}
+    ];
+    const results = dc.checkKeysAndValues(criteria, testData, typePath);
+    expect(results.length).toBe(1);
+
+  });
+});
+
+describe('filterOutArchivedAndTrashedEntities', () =>{
+    const config: FCConfig = {
+    apiHost: 'host',
+    userName: () => 'user',
+    password: () => 'pass',
+    urlContext: 'xxx',
+    vibeEventEndpoint: '/rfa/vibeiq/vibeEvents',
+    csrfEndpoint: '/servlet/rest/security/csrf',
+    itemPreDevelopmentLifecycleStages: ['concept']
+  };
+
+  const mapFileUtil = new MapFileUtil(new Entities());
+  const dc = new DataConverter(config, mapFileUtil);
+
+  it('filter out isArchived and isTrashed entities', () =>{
+    const entities = [
+      {id: '1', name: 'Entity 1', isArchived: false, isTrashed: false},
+      {id: '2', name: 'Entity 2', isArchived: true, isTrashed: false},
+      {id: '3', name: 'Entity 3', isArchived: false, isTrashed: true},
+      {id: '4', name: 'Entity 4', isArchived: false, isTrashed: false}
+    ];
+
+    const filteredEntities = dc.filterOutArchivedAndTrashedEntities(entities);
+    expect(filteredEntities.length).toBe(2);
+    expect(filteredEntities).toEqual([
+      {id: '1', name: 'Entity 1', isArchived: false, isTrashed: false},
+      {id: '4', name: 'Entity 4', isArchived: false, isTrashed: false}
+    ]);
+  });
+  it('no entities to filter', () =>{
+    const entities = [];
+    const filteredEntities = dc.filterOutArchivedAndTrashedEntities(entities);
+    expect(filteredEntities.length).toBe(0);
+  });
+  it('all entities are archived or trashed', () =>{
+    const entities = [
+      {id: '1', name: 'Entity 1', isArchived: true, isTrashed: false},
+      {id: '2', name: 'Entity 2', isArchived: false, isTrashed: true}
+    ];
+
+    const filteredEntities = dc.filterOutArchivedAndTrashedEntities(entities);
+    expect(filteredEntities.length).toBe(0);
+  });
+});
+
+describe('setUserListValue', () =>{
+  const config: FCConfig = {
+    apiHost: 'host',
+    userName: () => 'user',
+    password: () => 'pass',
+    urlContext: 'xxx',
+    vibeEventEndpoint: '/rfa/vibeiq/vibeEvents',
+    csrfEndpoint: '/servlet/rest/security/csrf',
+    itemPreDevelopmentLifecycleStages: ['concept']
+  };
+  const userListProp1 = {};
+  const userEmailMapping = [
+    {
+      id: "gxgr46kvdeEOn4cH",
+      email: "jessica.smith@vibeiq.com"
+    },
+
+    {
+      id: "Rl5D0sjuAwelScEK",
+      email: "adam.smith@vibeiq.com"
+    }
+  ];
+
+  const mapFileUtil = new MapFileUtil(new Entities());
+  const dc = new DataConverter(config, mapFileUtil);
+  let spyGetUserByEmail = jest.spyOn(dc, 'getUserByEmail')
+  .mockImplementation(async (nd) => {
+    let emaildInput = nd?.email.toLowerCase();
+    return userEmailMapping.find((user) => user.email === emaildInput);
+  });
+  let spyProcessGroupMemberCheck = jest.spyOn(dc, 'processGroupMemberCheck')
+  .mockImplementation(async (nd) => { return; });
+
+  afterEach(() => {
+    spyGetUserByEmail.mockClear();
+    spyProcessGroupMemberCheck.mockClear();
+    DataConverter.clearStaticUserCache();
+  });
+  afterAll(() => {
+    spyGetUserByEmail.mockRestore();
+    spyProcessGroupMemberCheck.mockRestore();
+  });
+
+  it('no value', async () =>{
+    const newData = {};
+    const returnValue = await dc.setUserListValue(userListProp1, newData);
+
+    expect(returnValue).toEqual('');
+  });
+
+  it('miss cache', async () =>{
+    const newData = {email: 'adam.smith@vibeiq.com'};
+    const returnValue = await dc.setUserListValue(userListProp1, newData);
+    console.log('returnValue', JSON.stringify(returnValue));
+    expect(returnValue).toEqual('Rl5D0sjuAwelScEK');
+    expect(spyGetUserByEmail).toHaveBeenCalledTimes(1);
+    expect(spyProcessGroupMemberCheck).toHaveBeenCalledTimes(1);
+  });
+
+  it('miss cache - two different emails', async () =>{
+    let newData = {email: 'adam.smith@vibeiq.com'};
+    let returnValue = await dc.setUserListValue(userListProp1, newData);
+    expect(returnValue).toEqual('Rl5D0sjuAwelScEK');
+    expect(spyGetUserByEmail).toHaveBeenCalledTimes(1);
+    expect(spyProcessGroupMemberCheck).toHaveBeenCalledTimes(1);
+
+    newData = {email: 'jessica.smith@vibeiq.com'};
+    returnValue = await dc.setUserListValue(userListProp1, newData);
+    expect(spyGetUserByEmail).toHaveBeenCalledTimes(2);
+    expect(spyProcessGroupMemberCheck).toHaveBeenCalledTimes(2);
+  });
+
+  it('hit cache same email', async () =>{
+    const newData = {email: 'adam.smith@vibeiq.com'};
+    let returnValue = await dc.setUserListValue(userListProp1, newData);
+    expect(returnValue).toEqual('Rl5D0sjuAwelScEK');
+    expect(spyGetUserByEmail).toHaveBeenCalledTimes(1);
+    expect(spyProcessGroupMemberCheck).toHaveBeenCalledTimes(1);
+
+    returnValue = await dc.setUserListValue(userListProp1, newData);
+    expect(returnValue).toEqual('Rl5D0sjuAwelScEK');
+    expect(spyGetUserByEmail).toHaveBeenCalledTimes(1);
+    expect(spyProcessGroupMemberCheck).toHaveBeenCalledTimes(2);
+  });
+
+  it('hit cache same email - new DataConverter entity', async () =>{
+    const newData = {email: 'adam.smith@vibeiq.com'};
+    let returnValue = await dc.setUserListValue(userListProp1, newData);
+    expect(returnValue).toEqual('Rl5D0sjuAwelScEK');
+    expect(spyGetUserByEmail).toHaveBeenCalledTimes(1);
+    expect(spyProcessGroupMemberCheck).toHaveBeenCalledTimes(1);
+
+    const dc2 = new DataConverter(config, mapFileUtil);
+    let spyGetUserByEmail2 = jest.spyOn(dc2, 'getUserByEmail')
+    .mockImplementation(async (nd) => {
+      let emaildInput = nd?.email.toLowerCase();
+      return userEmailMapping.find((user) => user.email === emaildInput);
+    });
+    let spyProcessGroupMemberCheck2 = jest.spyOn(dc2, 'processGroupMemberCheck')
+    .mockImplementation(async (nd) => { return; });
+
+    returnValue = await dc2.setUserListValue(userListProp1, newData);
+    expect(returnValue).toEqual('Rl5D0sjuAwelScEK');
+    expect(spyGetUserByEmail2).toHaveBeenCalledTimes(0);
+    expect(spyProcessGroupMemberCheck2).toHaveBeenCalledTimes(1);
+
+    spyGetUserByEmail2.mockRestore();
+    spyProcessGroupMemberCheck2.mockRestore();
+  });
+
+});
+
+describe('getUserListValue', () =>{
+  const config: FCConfig = {
+    apiHost: 'host',
+    userName: () => 'user',
+    password: () => 'pass',
+    urlContext: 'xxx',
+    vibeEventEndpoint: '/rfa/vibeiq/vibeEvents',
+    csrfEndpoint: '/servlet/rest/security/csrf',
+    itemPreDevelopmentLifecycleStages: ['concept']
+  };
+  const userListProp1 = {
+    slug: 'userList1'
+  };
+  const userEmailMapping = [
+    {
+      id: "gxgr46kvdeEOn4cH",
+      email: "jessica.smith@vibeiq.com",
+      first: 'Jessica',
+      last: 'Smith'
+    },
+
+    {
+      id: "Rl5D0sjuAwelScEK",
+      email: "adam.smith@vibeiq.com",
+      first: 'Adam',
+      last: 'Smith'
+    }
+  ];
+
+  const mapFileUtil = new MapFileUtil(new Entities());
+  const dc = new DataConverter(config, mapFileUtil);
+
+  //getUserById
+  let spyGetUserById = jest.spyOn(dc, 'getUserById')
+  .mockImplementation(async (nd) => {
+    return userEmailMapping.find((user) => user.id === nd);
+  });
+
+  afterEach(() => {
+    spyGetUserById.mockClear();
+    DataConverter.clearStaticUserCache();
+  });
+  afterAll(() => {
+    spyGetUserById.mockRestore();
+  });
+
+  it('no value', async () =>{
+    const newData = {};
+    const returnValue = await dc.getUserListValue(userListProp1, newData);
+
+    expect(returnValue).toEqual({});
+  });
+
+  it('miss cache', async () =>{
+    const newData = {
+      userList1Id: 'gxgr46kvdeEOn4cH'
+    };
+
+    const returnValue = await dc.getUserListValue(userListProp1, newData);
+
+    expect(spyGetUserById).toHaveBeenCalledTimes(1);
+    expect(returnValue.email).toEqual('jessica.smith@vibeiq.com');
+    expect(returnValue.firstName).toEqual('Jessica');
+    expect(returnValue.lastName).toEqual('Smith');
+
+  });
+
+  it('miss cache - two different emails', async () =>{
+    let newData = { userList1Id: 'gxgr46kvdeEOn4cH'};
+    let returnValue = await dc.getUserListValue(userListProp1, newData);
+
+    expect(spyGetUserById).toHaveBeenCalledTimes(1);
+    expect(returnValue.email).toEqual('jessica.smith@vibeiq.com');
+    expect(returnValue.firstName).toEqual('Jessica');
+    expect(returnValue.lastName).toEqual('Smith');
+
+    newData = { userList1Id: 'Rl5D0sjuAwelScEK' };
+    returnValue = await dc.getUserListValue(userListProp1, newData);
+
+    expect(spyGetUserById).toHaveBeenCalledTimes(2);
+    expect(returnValue.email).toEqual('adam.smith@vibeiq.com');
+    expect(returnValue.firstName).toEqual('Adam');
+    expect(returnValue.lastName).toEqual('Smith');
+  });
+
+  it('hit cache same email', async () =>{
+    const newData = { userList1Id: 'gxgr46kvdeEOn4cH'};
+    let returnValue = await dc.getUserListValue(userListProp1, newData);
+
+    expect(spyGetUserById).toHaveBeenCalledTimes(1);
+    expect(returnValue.email).toEqual('jessica.smith@vibeiq.com');
+    expect(returnValue.firstName).toEqual('Jessica');
+    expect(returnValue.lastName).toEqual('Smith');
+
+    returnValue = await dc.getUserListValue(userListProp1, newData);
+    expect(spyGetUserById).toHaveBeenCalledTimes(1);
+    expect(returnValue.email).toEqual('jessica.smith@vibeiq.com');
+    expect(returnValue.firstName).toEqual('Jessica');
+    expect(returnValue.lastName).toEqual('Smith');
+  });
+
+  it('hit cache same email - new DataConverter entity', async () =>{
+    const newData = { userList1Id: 'gxgr46kvdeEOn4cH'};
+    let returnValue = await dc.getUserListValue(userListProp1, newData);
+
+    expect(spyGetUserById).toHaveBeenCalledTimes(1);
+    expect(returnValue.email).toEqual('jessica.smith@vibeiq.com');
+    expect(returnValue.firstName).toEqual('Jessica');
+    expect(returnValue.lastName).toEqual('Smith');
+
+    const dc2 = new DataConverter(config, mapFileUtil);
+    let spyGetUserById2 = jest.spyOn(dc2, 'getUserById')
+    .mockImplementation(async (nd) => {
+      return userEmailMapping.find((user) => user.id === nd);
+    });
+
+    returnValue = await dc2.getUserListValue(userListProp1, newData);
+    expect(spyGetUserById2).toHaveBeenCalledTimes(0);
+    expect(returnValue.email).toEqual('jessica.smith@vibeiq.com');
+    expect(returnValue.firstName).toEqual('Jessica');
+    expect(returnValue.lastName).toEqual('Smith');
+  });
+
+});
+
+
+describe('getFlexPLMValue size_range', () => {                                                                                                                                                                                
+  const config: FCConfig = {                                                                                                                                                                                                
+    apiHost: 'host',                                                                                                                                                                                                          
+    userName: () => 'user',                                                                                                                                                                                                   
+    password: () => 'pass',                                                                                                                                                                                                   
+    urlContext: 'xxx',                                                                                                                                                                                                      
+    vibeEventEndpoint: '/rfa/vibeiq/vibeEvents',
+    csrfEndpoint: '/servlet/rest/security/csrf',
+    itemPreDevelopmentLifecycleStages: ['concept']
+  };
+
+  const mapFileUtil = new MapFileUtil(new Entities());
+  const dc = new DataConverter(config, mapFileUtil);
+
+  const sizeRangeProp = {
+    propertyType: 'size_range',
+    slug: 'sizeRange',
+    label: 'Size Range',
+  };
+
+  it('returns sizeRange object when value is present', async () => {
+    const newData = { sizeRange: { sizes: ['PRE', 'NB'] } };
+    const returnValue = await dc.getFlexPLMValue(sizeRangeProp, newData, true);
+    expect(returnValue).toEqual({ sizes: ['PRE', 'NB'] });
+  });
+
+  it('returns null when sizeRange is null', async () => {
+    const newData = { sizeRange: null };
+    const returnValue = await dc.getFlexPLMValue(sizeRangeProp, newData, true);
+    expect(returnValue).toBeNull();
+  });
+
+  it('returns undefined when sizeRange is missing', async () => {
+    const newData = {};
+    const returnValue = await dc.getFlexPLMValue(sizeRangeProp, newData, true);
+    expect(returnValue).toBeUndefined();
+  });
+});
+
+describe('getEntityValue size_range', () => {
+  const config: FCConfig = {
+    apiHost: 'host',
+    userName: () => 'user',
+    password: () => 'pass',
+    urlContext: 'xxx',
+    vibeEventEndpoint: '/rfa/vibeiq/vibeEvents',
+    csrfEndpoint: '/servlet/rest/security/csrf',
+    itemPreDevelopmentLifecycleStages: ['concept']
+  };
+
+  const mapFileUtil = new MapFileUtil(new Entities());
+  const dc = new DataConverter(config, mapFileUtil);
+
+  const sizeRangeProp = {
+    propertyType: 'size_range',
+    slug: 'sizeRange',
+    label: 'Size Range',
+  };
+
+  it('returns sizeRange object when value is present', async () => {
+    const data = { sizeRange: { sizes: ['PRE', 'NB'] } };
+    const returnValue = await dc.getEntityValue(sizeRangeProp, data);
+    expect(returnValue).toEqual({ sizes: ['PRE', 'NB'] });
+  });
+
+  it('returns null when sizeRange is null', async () => {
+    const data = { sizeRange: null };
+    const returnValue = await dc.getEntityValue(sizeRangeProp, data);
+    expect(returnValue).toBeNull();
+  });
+
+  it('returns undefined when sizeRange is missing', async () => {
+    const data = {};
+    const returnValue = await dc.getEntityValue(sizeRangeProp, data);
+    expect(returnValue).toBeUndefined();
+  });
+});