@elisra-devops/docgen-data-provider 1.136.4 → 1.136.6

package/src/tests/modules/pipelineDataProvider.test.ts

@@ -951,23 +951,28 @@ describe('PipelinesDataProvider', () => {
   });
 
   describe('GetRecentReleaseArtifactInfo', () => {
-    it('should return empty array when no releases exist', async () => {
+    it('should return empty array when release response has no artifacts', async () => {
       // Arrange
       const projectName = 'project1';
-      const mockResponse = { value: [] };
-      (TFSServices.getItemContent as jest.Mock).mockResolvedValueOnce(mockResponse);
+      const releaseId = 123;
+      const mockReleaseResponse = { artifacts: [] };
+      (TFSServices.getItemContent as jest.Mock).mockResolvedValueOnce(mockReleaseResponse);
 
       // Act
-      const result = await pipelinesDataProvider.GetRecentReleaseArtifactInfo(projectName);
+      const result = await pipelinesDataProvider.GetRecentReleaseArtifactInfo(projectName, releaseId);
 
       // Assert
+      expect(TFSServices.getItemContent).toHaveBeenCalledWith(
+        expect.stringContaining(`releases/${releaseId}`),
+        mockToken
+      );
       expect(result).toEqual([]);
     });
 
-    it('should return artifact info from most recent release', async () => {
+    it('should return artifact info for the specified release', async () => {
       // Arrange
       const projectName = 'project1';
-      const mockReleasesResponse = { value: [{ id: 123 }] };
+      const releaseId = 123;
       const mockReleaseResponse = {
         artifacts: [
           {
@@ -978,16 +983,44 @@ describe('PipelinesDataProvider', () => {
           },
         ],
       };
-      (TFSServices.getItemContent as jest.Mock)
-        .mockResolvedValueOnce(mockReleasesResponse)
-        .mockResolvedValueOnce(mockReleaseResponse);
+      (TFSServices.getItemContent as jest.Mock).mockResolvedValueOnce(mockReleaseResponse);
 
       // Act
-      const result = await pipelinesDataProvider.GetRecentReleaseArtifactInfo(projectName);
+      const result = await pipelinesDataProvider.GetRecentReleaseArtifactInfo(projectName, releaseId);
 
       // Assert
       expect(result).toEqual([{ artifactName: 'artifact1', artifactVersion: '1.0.0' }]);
     });
+
+    it('should return empty array without calling the API when releaseId is invalid', async () => {
+      // Arrange
+      const projectName = 'project1';
+
+      // Act
+      const resultForZero = await pipelinesDataProvider.GetRecentReleaseArtifactInfo(projectName, 0);
+      const resultForNaN = await pipelinesDataProvider.GetRecentReleaseArtifactInfo(projectName, NaN);
+      const resultForNegative = await pipelinesDataProvider.GetRecentReleaseArtifactInfo(projectName, -5);
+
+      // Assert
+      expect(resultForZero).toEqual([]);
+      expect(resultForNaN).toEqual([]);
+      expect(resultForNegative).toEqual([]);
+      expect(TFSServices.getItemContent).not.toHaveBeenCalled();
+    });
+
+    it('should return empty array when release response has no artifacts field at all', async () => {
+      // Arrange
+      const projectName = 'project1';
+      const releaseId = 123;
+      const mockReleaseResponse = { id: releaseId, name: 'Release-1' };
+      (TFSServices.getItemContent as jest.Mock).mockResolvedValueOnce(mockReleaseResponse);
+
+      // Act
+      const result = await pipelinesDataProvider.GetRecentReleaseArtifactInfo(projectName, releaseId);
+
+      // Assert
+      expect(result).toEqual([]);
+    });
   });
 
   describe('getPipelineResourcePipelinesFromObject', () => {

package/src/tests/modules/ticketsDataProvider.test.ts

@@ -911,6 +911,44 @@ describe('TicketsDataProvider', () => {
         ),
       ).rejects.toThrow('Target relation is missing');
     });
+
+    it('should order sourceTargetsMap by the query sortColumns (Node Name asc, Customer ID asc)', async () => {
+      // Root work items arrive in relation order 1, 2, 3 — sortColumns should reorder them
+      // by System.NodeName then CustomerRequirementId regardless of fetch order.
+      const rootFieldsById: Record<number, any> = {
+        1: { 'System.WorkItemType': 'Requirement', 'System.NodeName': 'B', CustomerRequirementId: 'C-20' },
+        2: { 'System.WorkItemType': 'Requirement', 'System.NodeName': 'A', CustomerRequirementId: 'C-10' },
+        3: { 'System.WorkItemType': 'Requirement', 'System.NodeName': 'A', CustomerRequirementId: 'C-5' },
+      };
+      jest
+        .spyOn(ticketsDataProvider as any, 'fetchWIForQueryResult')
+        .mockImplementation(async (...args: any[]) => {
+          const rel = args[0];
+          const id = rel?.target?.id ?? rel?.source?.id;
+          return { id, fields: rootFieldsById[id] };
+        });
+
+      const res = await (ticketsDataProvider as any).parseDirectLinkedQueryResultForTableFormat(
+        {
+          queryType: QueryType.OneHop,
+          columns: [],
+          sortColumns: [
+            { field: { referenceName: 'System.NodeName' }, descending: false },
+            { field: { referenceName: 'CustomerRequirementId' }, descending: false },
+          ],
+          workItemRelations: [
+            { source: null, target: { id: 1 } },
+            { source: null, target: { id: 2 } },
+            { source: null, target: { id: 3 } },
+          ],
+        } as any,
+        new Map(),
+      );
+
+      const orderedIds = Array.from(res.sourceTargetsMap.keys()).map((k: any) => k.id);
+      // Expect Node Name A-group (ids 3,2 sorted by Customer ID 5 then 10) before Node Name B (id 1)
+      expect(orderedIds).toEqual([3, 2, 1]);
+    });
   });
 
   describe('fetchWIForQueryResult', () => {
@@ -952,6 +990,45 @@ describe('TicketsDataProvider', () => {
     });
   });
 
+  describe('parseFlatQueryResultForTableFormat', () => {
+    it('should order fetchedWorkItems by the query sortColumns (Node Name asc, Customer ID asc)', async () => {
+      const fieldsById: Record<number, any> = {
+        1: { 'System.WorkItemType': 'Requirement', 'System.NodeName': 'B', CustomerRequirementId: 'C-20' },
+        2: { 'System.WorkItemType': 'Requirement', 'System.NodeName': 'A', CustomerRequirementId: 'C-10' },
+        3: { 'System.WorkItemType': 'Requirement', 'System.NodeName': 'A', CustomerRequirementId: 'C-5' },
+      };
+      jest
+        .spyOn(ticketsDataProvider as any, 'fetchWIForQueryResult')
+        .mockImplementation(async (...args: any[]) => {
+          const wi = args[0];
+          return { id: wi.id, fields: fieldsById[wi.id] };
+        });
+
+      const res = await (ticketsDataProvider as any).parseFlatQueryResultForTableFormat({
+        queryType: QueryType.Flat,
+        columns: [{ referenceName: 'CustomerRequirementId', name: 'CustomerRequirementId' }],
+        sortColumns: [
+          { field: { referenceName: 'System.NodeName' }, descending: false },
+          { field: { referenceName: 'CustomerRequirementId' }, descending: false },
+        ],
+        workItems: [{ id: 1 }, { id: 2 }, { id: 3 }],
+      } as any);
+
+      const orderedIds = res.fetchedWorkItems.map((wi: any) => wi.id);
+      expect(orderedIds).toEqual([3, 2, 1]);
+    });
+
+    it('should throw when workItems is an empty array', async () => {
+      await expect(
+        (ticketsDataProvider as any).parseFlatQueryResultForTableFormat({
+          queryType: QueryType.Flat,
+          columns: [],
+          workItems: [],
+        } as any),
+      ).rejects.toThrow('No work items were found');
+    });
+  });
+
   describe('isFlatQueryAllowedByTypeOrId', () => {
     it('should accept when allowedTypes is empty and WIQL references [System.WorkItemType]', async () => {
       const wiql = "SELECT * FROM WorkItems WHERE [System.WorkItemType] = 'Bug'";