@elisra-devops/docgen-data-provider 1.136.3 → 1.136.5

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

@@ -4300,6 +4300,32 @@ describe('ResultDataProvider', () => {
 
       expect(res.testCaseResult).toEqual(expect.objectContaining({ url: '' }));
     });
+
+    it('should pass latest test case properties flag to the point result fetch', async () => {
+      const fetchResultDataBaseSpy = jest
+        .spyOn(resultDataProvider as any, 'fetchResultDataBase')
+        .mockResolvedValue({});
+
+      await (resultDataProvider as any).fetchResultDataForTestReporter(
+        mockProjectName,
+        'suite1',
+        { lastRunId: 456, lastResultId: 789, testCaseId: 123 },
+        ['Custom.SortIndex@testCaseWorkItemField'],
+        false,
+        false,
+        false,
+        true
+      );
+
+      expect(fetchResultDataBaseSpy.mock.calls[0][5]).toEqual([
+        ['Custom.SortIndex@testCaseWorkItemField'],
+        false,
+        { lastRunId: 456, lastResultId: 789, testCaseId: 123 },
+        false,
+        false,
+        true,
+      ]);
+    });
   });
 
   describe('fetchResultDataBasedOnWiBase', () => {
@@ -4352,6 +4378,95 @@ describe('ResultDataProvider', () => {
       );
     });
 
+    it('should use latest test case fields for executed points when latest properties mode is enabled', async () => {
+      const point = {
+        testCaseId: '123',
+        testCaseName: 'TC 123',
+        outcome: 'passed',
+        lastRunId: 456,
+        lastResultId: 789,
+        testSuite: { id: '1', name: 'Suite' },
+      };
+
+      (TFSServices.getItemContent as jest.Mock).mockResolvedValueOnce({
+        id: 123,
+        rev: 10,
+        fields: {
+          'System.State': 'Active',
+          'System.CreatedDate': '2024-01-01T00:00:00',
+          'Microsoft.VSTS.TCM.Priority': 1,
+          'Custom.SortIndex': 3,
+          'Microsoft.VSTS.TCM.Steps': '<steps></steps>',
+        },
+        relations: null,
+      });
+
+      const selectedFields = ['Custom.SortIndex@testCaseWorkItemField'];
+      const res = await (resultDataProvider as any).fetchResultDataBasedOnWiBase(
+        mockProjectName,
+        '456',
+        '789',
+        true,
+        selectedFields,
+        false,
+        point,
+        false,
+        false,
+        true
+      );
+
+      const calledUrls = (TFSServices.getItemContent as jest.Mock).mock.calls.map((args: any[]) => String(args[0]));
+      expect(calledUrls.some((url: string) => url.includes('/_apis/test/runs/456/results/789'))).toBe(false);
+      expect(calledUrls.some((url: string) => url.includes('/_apis/wit/workItems/123?$expand=all'))).toBe(true);
+      expect(res).toEqual(
+        expect.objectContaining({
+          testCaseRevision: 10,
+          filteredFields: { 'Custom.SortIndex': 3 },
+        })
+      );
+    });
+
+    it('should log latest properties mode when bypassing run revision data', async () => {
+      const point = {
+        testCaseId: '123',
+        testCaseName: 'TC 123',
+        outcome: 'passed',
+        lastRunId: 456,
+        lastResultId: 789,
+        testSuite: { id: '1', name: 'Suite' },
+      };
+
+      (TFSServices.getItemContent as jest.Mock).mockResolvedValueOnce({
+        id: 123,
+        rev: 10,
+        fields: {
+          'System.State': 'Active',
+          'System.CreatedDate': '2024-01-01T00:00:00',
+          'Microsoft.VSTS.TCM.Priority': 1,
+          'Custom.SortIndex': 3,
+          'Microsoft.VSTS.TCM.Steps': '<steps></steps>',
+        },
+        relations: null,
+      });
+
+      await (resultDataProvider as any).fetchResultDataBasedOnWiBase(
+        mockProjectName,
+        '456',
+        '789',
+        true,
+        ['Custom.SortIndex@testCaseWorkItemField'],
+        false,
+        point,
+        false,
+        false,
+        true
+      );
+
+      expect(logger.debug).toHaveBeenCalledWith(
+        expect.stringContaining('[TestReporter][LatestProperties] Fetching latest test case work item')
+      );
+    });
+
     it('should fetch no-run test case by suite test-case revision when provided', async () => {
       const point = {
         testCaseId: '123',

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'";