@contrail/flexplm 1.4.0 → 1.5.0-alpha.0d65410

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

@@ -509,6 +509,463 @@ describe('getObjectReferenceValue bad value', () =>{
 
 });
 
+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');
@@ -594,6 +1051,51 @@ describe('getObjectReferenceValue - use mapping', () => {
   });
 });
 
+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',