fix(metadata-editor): Handle new taxonomy API (#4049)

Author: kajarosz

src/elements/content-sidebar/__tests__/metadataTaxonomyFetcher.test.ts

@@ -95,7 +95,8 @@ describe('metadataTaxonomyFetcher', () => {
     });
 });
 
-describe('metadataNodeTaxonomiesFetcher', () => {
+// TODO: delete whole section during clean up as for now we have to handle both new and old naming convention
+describe('metadataTaxonomyNodeAncestorsFetcher (old keys naming convention)', () => {
     const fileID = '12345';
     const scope = 'global';
     const taxonomyKey = 'taxonomy_123';
@@ -199,6 +200,112 @@ describe('metadataNodeTaxonomiesFetcher', () => {
 
         expect(result).toEqual(expectedResult);
     });
+});
+
+describe('metadataTaxonomyNodeAncestorsFetcher (new keys naming convention)', () => {
+    const fileID = '12345';
+    const scope = 'global';
+    const taxonomyKey = 'taxonomy_123';
+    const nodeID = 'node_abc';
+
+    let apiMock: jest.Mocked<API>;
+
+    beforeEach(() => {
+        apiMock = {
+            getMetadataAPI: jest.fn().mockReturnValue({
+                getMetadataTaxonomy: jest.fn(),
+                getMetadataTaxonomyNode: jest.fn(),
+            }),
+        };
+    });
+
+    test('should fetch taxonomy and node data and return formatted data', async () => {
+        const mockTaxonomy = {
+            display_name: 'Geography',
+            namespace: 'my_enterprise',
+            id: 'my_id',
+            key: 'geography',
+            levels: [
+                { level: 1, display_name: 'Level 1', description: 'Description 1' },
+                { level: 2, display_name: 'Level 2', description: 'Description 2' },
+                { level: 3, display_name: 'Level 3', description: 'Description 3' },
+            ],
+        };
+
+        const mockTaxonomyNode = {
+            id: 'node_abc',
+            level: 1,
+            display_name: 'Node ABC',
+            ancestors: [{ id: 'ancestor_1', level: 2, display_name: 'Ancestor 1' }],
+        };
+
+        apiMock.getMetadataAPI(false).getMetadataTaxonomy.mockResolvedValue(mockTaxonomy);
+        apiMock.getMetadataAPI(false).getMetadataTaxonomyNode.mockResolvedValue(mockTaxonomyNode);
+
+        const result = await metadataTaxonomyNodeAncestorsFetcher(apiMock, fileID, scope, taxonomyKey, nodeID);
+
+        const expectedResult = [
+            {
+                level: 1,
+                levelName: 'Level 1',
+                description: 'Description 1',
+                id: 'node_abc',
+                levelValue: 'Node ABC',
+            },
+            {
+                level: 2,
+                levelName: 'Level 2',
+                description: 'Description 2',
+                id: 'ancestor_1',
+                levelValue: 'Ancestor 1',
+            },
+        ];
+
+        expect(apiMock.getMetadataAPI).toHaveBeenCalledWith(false);
+        expect(apiMock.getMetadataAPI(false).getMetadataTaxonomy).toHaveBeenCalledWith(fileID, scope, taxonomyKey);
+        expect(apiMock.getMetadataAPI(false).getMetadataTaxonomyNode).toHaveBeenCalledWith(
+            fileID,
+            scope,
+            taxonomyKey,
+            nodeID,
+            true,
+        );
+        expect(result).toEqual(expectedResult);
+    });
+
+    test('should handle empty ancestors array', async () => {
+        const mockTaxonomy = {
+            display_name: 'Geography',
+            namespace: 'my_enterprise',
+            id: 'my_id',
+            key: 'geography',
+            levels: [{ level: 1, display_name: 'Level 1', description: 'Description 1' }],
+        };
+
+        const mockTaxonomyNode = {
+            id: 'node_abc',
+            level: 1,
+            display_name: 'Node ABC',
+            ancestors: [],
+        };
+
+        apiMock.getMetadataAPI(false).getMetadataTaxonomy.mockResolvedValue(mockTaxonomy);
+        apiMock.getMetadataAPI(false).getMetadataTaxonomyNode.mockResolvedValue(mockTaxonomyNode);
+
+        const result = await metadataTaxonomyNodeAncestorsFetcher(apiMock, fileID, scope, taxonomyKey, nodeID);
+
+        const expectedResult = [
+            {
+                level: 1,
+                levelName: 'Level 1',
+                description: 'Description 1',
+                id: 'node_abc',
+                levelValue: 'Node ABC',
+            },
+        ];
+
+        expect(result).toEqual(expectedResult);
+    });
 
     test('should throw an error if getMetadataTaxonomy fails', async () => {
         const error = new Error('API Error');

src/elements/content-sidebar/fetchers/metadataTaxonomyFetcher.ts

@@ -53,7 +53,7 @@ export const metadataTaxonomyNodeAncestorsFetcher = async (
     for (const item of metadataTaxonomy.levels) {
         const levelData = {
             level: item.level,
-            levelName: item.displayName,
+            levelName: item.displayName || item.display_name,
             description: item.description,
         };
 
@@ -62,7 +62,7 @@ export const metadataTaxonomyNodeAncestorsFetcher = async (
             levelsMap.set(item.level, {
                 ...levelData,
                 id: metadataTaxonomyNode.id,
-                levelValue: metadataTaxonomyNode.displayName,
+                levelValue: metadataTaxonomyNode.displayName || metadataTaxonomyNode.display_name,
             });
             // If the level is not the metadataTaxonomyNode level, just add the level data
         } else {
@@ -75,7 +75,7 @@ export const metadataTaxonomyNodeAncestorsFetcher = async (
             const levelData = levelsMap.get(ancestor.level);
 
             if (levelData) {
-                levelsMap.set(ancestor.level, { ...levelData, levelValue: ancestor.displayName, id: ancestor.id });
+                levelsMap.set(ancestor.level, { ...levelData, levelValue: ancestor.displayName || ancestor.display_name, id: ancestor.id });
             }
         }
     }