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

package/src/modules/TestDataProvider.ts

@@ -115,20 +115,45 @@ export default class TestDataProvider {
     return descriptions;
   }
 
+  // DFS pre-order flatten of a suite payload that may be a nested tree (asTreeView=true),
+  // a flat list whose elements also carry populated `children[]`, or a plain flat list.
+  // The `seen` guard means a suite is only emitted once even if it appears both in the
+  // top-level array and nested under a `children` array, so tree order always wins when
+  // available, with no duplicates and no change in behavior when `children` is absent.
+  private flattenSuitesTreeOrder(suites: any[]): any[] {
+    const flat: any[] = [];
+    const seen = new Set<any>();
+
+    const visit = (suite: any) => {
+      if (!suite || seen.has(suite.id)) return;
+      seen.add(suite.id);
+      const { children, ...rest } = suite;
+      flat.push(rest);
+      if (Array.isArray(children)) {
+        children.forEach(visit);
+      }
+    };
+
+    suites.forEach(visit);
+    return flat;
+  }
+
   private async normalizeAndEnrichSuitesResponse(project: string, data: any): Promise<any> {
-    const suites = Array.isArray(data?.testSuites)
+    const rawSuites = Array.isArray(data?.testSuites)
       ? data.testSuites
       : Array.isArray(data?.value)
       ? data.value
       : Array.isArray(data)
       ? data
       : [];
+    const suites = this.flattenSuitesTreeOrder(rawSuites);
 
-    const mapped = suites.map((suite: any) => ({
+    const mapped = suites.map((suite: any, index: number) => ({
       ...suite,
       title: suite?.title || suite?.name || '',
       parentSuiteId: suite?.parentSuiteId ?? suite?.parentSuite?.id ?? 0,
       description: this.getSuiteDescription(suite),
+      treeOrder: index,
     }));
 
     const missingDescriptionIds = mapped
@@ -190,7 +215,7 @@ export default class TestDataProvider {
 
     // Bearer branch — follow x-ms-continuationtoken until the server stops returning it.
     // Doc: https://learn.microsoft.com/en-us/rest/api/azure/devops/testplan/test-suites/get-test-suites-for-plan?view=azure-devops-rest-7.0
-    const base = `${this.joinOrgProject(project)}/_apis/testplan/Plans/${planid}/suites?expand=children&api-version=7.0`;
+    const base = `${this.joinOrgProject(project)}/_apis/testplan/Plans/${planid}/suites?expand=children&asTreeView=true&api-version=7.0`;
     const cacheKey = `${base}__all_pages`;
 
     if (this.cache.has(cacheKey)) {
@@ -277,6 +302,14 @@ export default class TestDataProvider {
         }
       }
 
+      // Multiple hierarchies must be emitted in tree order, not in the order the
+      // caller happened to list suiteIdsFilter.
+      topLevelSuites.sort((a, b) => {
+        const orderA = suiteMap.get(a)?.treeOrder ?? suiteMap.get(parseInt(a))?.treeOrder ?? 0;
+        const orderB = suiteMap.get(b)?.treeOrder ?? suiteMap.get(parseInt(b))?.treeOrder ?? 0;
+        return orderA - orderB;
+      });
+
       if (topLevelSuites.length === 0) {
         // Fallback: use first suite if no clear top-level suites found
         const selectedSuiteId = suiteIdsFilter[0].toString();

package/src/tests/helpers/helper.test.ts

@@ -4,9 +4,6 @@ import { Query, Workitem } from '../../models/tfs-data';
 describe('Helper', () => {
   beforeEach(() => {
     // Reset static state before each test
-    Helper.suitList = [];
-    Helper.level = 1;
-    Helper.first = true;
     Helper.levelList = [];
   });
 
@@ -241,6 +238,75 @@ describe('Helper', () => {
       // Assert
       expect(result.length).toBe(5);
     });
+
+    it('should emit siblings in array (tree) order even when their ids are not ascending', () => {
+      // Arrange - array order mirrors a manually reordered ADO tree: D, B, A, C
+      const suits = [
+        { id: '1', title: 'Root', parentSuiteId: 0 },
+        { id: '40', title: 'Suite D', parentSuiteId: '1' },
+        { id: '20', title: 'Suite B', parentSuiteId: '1' },
+        { id: '10', title: 'Suite A', parentSuiteId: '1' },
+        { id: '30', title: 'Suite C', parentSuiteId: '1' },
+      ];
+
+      // Act
+      const result = Helper.findSuitesRecursive(mockPlanId, mockUrl, mockProject, suits, '1', true);
+
+      // Assert
+      expect(result.map((s) => s.name)).toEqual(['Suite D', 'Suite B', 'Suite A', 'Suite C']);
+    });
+
+    it('should emit the selected nested suite first even when it appears last in the source array', () => {
+      // Arrange
+      const suits = [
+        { id: '3', title: 'Grandchild Suite', parentSuiteId: '2' },
+        { id: '1', title: 'Root Suite', parentSuiteId: 0 },
+        { id: '2', title: 'Child Suite 1', parentSuiteId: '1' },
+      ];
+
+      // Act
+      const result = Helper.findSuitesRecursive(mockPlanId, mockUrl, mockProject, suits, '2', true);
+
+      // Assert
+      expect(result.map((s) => s.name)).toEqual(['Child Suite 1', 'Grandchild Suite']);
+    });
+
+    it('should compute levels correctly regardless of source array position', () => {
+      // Arrange - grandchild appears before its parent in the array
+      const suits = [
+        { id: '3', title: 'Level 2', parentSuiteId: '2' },
+        { id: '1', title: 'Root', parentSuiteId: 0 },
+        { id: '2', title: 'Level 1', parentSuiteId: '1' },
+      ];
+
+      // Act
+      const result = Helper.findSuitesRecursive(mockPlanId, mockUrl, mockProject, suits, '1', true);
+
+      // Assert
+      expect(result.find((s) => s.name === 'Level 1')?.level).toBe(1);
+      expect(result.find((s) => s.name === 'Level 2')?.level).toBe(2);
+    });
+
+    it('should not leak state between sequential calls', () => {
+      // Arrange
+      const suitsA = [
+        { id: '1', title: 'Root A', parentSuiteId: 0 },
+        { id: '2', title: 'Child A', parentSuiteId: '1' },
+      ];
+      const suitsB = [
+        { id: '10', title: 'Root B', parentSuiteId: 0 },
+        { id: '20', title: 'Child B1', parentSuiteId: '10' },
+        { id: '30', title: 'Child B2', parentSuiteId: '10' },
+      ];
+
+      // Act
+      const resultA = Helper.findSuitesRecursive(mockPlanId, mockUrl, mockProject, suitsA, '1', true);
+      const resultB = Helper.findSuitesRecursive(mockPlanId, mockUrl, mockProject, suitsB, '10', true);
+
+      // Assert - resultB is unaffected by resultA's traversal
+      expect(resultA.map((s) => s.name)).toEqual(['Child A']);
+      expect(resultB.map((s) => s.name)).toEqual(['Child B1', 'Child B2']);
+    });
   });
 
   describe('LevelBuilder', () => {

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/testDataProvider.test.ts

@@ -326,7 +326,7 @@ describe('TestDataProvider', () => {
       const result = await bearerProvider.GetTestSuitesForPlan(mockProject, mockPlanId);
 
       expect(TFSServices.getItemContentWithHeaders).toHaveBeenCalledWith(
-        `${mockOrgUrl.replace(/\/+$/, '')}/${mockProject}/_apis/testplan/Plans/${mockPlanId}/suites?expand=children&api-version=7.0`,
+        `${mockOrgUrl.replace(/\/+$/, '')}/${mockProject}/_apis/testplan/Plans/${mockPlanId}/suites?expand=children&asTreeView=true&api-version=7.0`,
         mockBearerToken,
         'get',
         {},
@@ -368,7 +368,7 @@ describe('TestDataProvider', () => {
       const result = await bearerProvider.GetTestSuitesForPlan(mockProject, mockPlanId);
 
       expect(TFSServices.getItemContentWithHeaders).toHaveBeenCalledWith(
-        `${mockOrgUrl.replace(/\/+$/, '')}/${mockProject}/_apis/testplan/Plans/${mockPlanId}/suites?expand=children&api-version=7.0`,
+        `${mockOrgUrl.replace(/\/+$/, '')}/${mockProject}/_apis/testplan/Plans/${mockPlanId}/suites?expand=children&asTreeView=true&api-version=7.0`,
         mockBearerToken,
         'get',
         {},
@@ -407,6 +407,7 @@ describe('TestDataProvider', () => {
         const calledUrl = (TFSServices.getItemContentWithHeaders as jest.Mock).mock.calls[0][0] as string;
         expect(calledUrl).toContain(`/_apis/testplan/Plans/${mockPlanId}/suites`);
         expect(calledUrl).toContain('expand=children');
+        expect(calledUrl).toContain('asTreeView=true');
         expect(calledUrl).toContain('api-version=7.0');
         expect(calledUrl).not.toContain('includeChildren');
       });
@@ -480,6 +481,82 @@ describe('TestDataProvider', () => {
         expect(callCount).toBeGreaterThan(0);
         expect(logger.warn).toHaveBeenCalledWith(expect.stringContaining('reached MAX_PAGES'));
       });
+
+      it('should flatten a nested asTreeView=true payload into DFS pre-order', async () => {
+        const bearerProvider = new TestDataProvider(mockOrgUrl, mockBearerToken);
+        const treePayload = {
+          value: [
+            {
+              id: 1,
+              name: 'Root',
+              children: [
+                { id: 20, name: 'Suite B', parentSuite: { id: 1 } },
+                {
+                  id: 10,
+                  name: 'Suite A',
+                  parentSuite: { id: 1 },
+                  children: [{ id: 11, name: 'Suite A.1', parentSuite: { id: 10 } }],
+                },
+              ],
+            },
+          ],
+          count: 1,
+        };
+        (TFSServices.getItemContentWithHeaders as jest.Mock).mockResolvedValueOnce({
+          data: treePayload,
+          headers: {},
+        });
+
+        const result = await bearerProvider.GetTestSuitesForPlan(mockProject, mockPlanId);
+
+        expect(result.testSuites.map((s: any) => s.id)).toEqual([1, 20, 10, 11]);
+        expect(result.testSuites.map((s: any) => s.treeOrder)).toEqual([0, 1, 2, 3]);
+      });
+
+      it('should derive tree order from a flat list whose elements carry populated children[], without duplicating suites', async () => {
+        const bearerProvider = new TestDataProvider(mockOrgUrl, mockBearerToken);
+        // Server ignored/does-not-support asTreeView and returned a flat, id-ordered list,
+        // but each suite still carries its own children[] in display order.
+        const flatWithChildren = {
+          value: [
+            { id: 10, name: 'Suite A', parentSuite: { id: 1 }, children: [{ id: 11, name: 'Suite A.1' }] },
+            { id: 11, name: 'Suite A.1', parentSuite: { id: 10 } },
+            { id: 1, name: 'Root', children: [{ id: 10, name: 'Suite A' }, { id: 20, name: 'Suite B' }] },
+            { id: 20, name: 'Suite B', parentSuite: { id: 1 } },
+          ],
+          count: 4,
+        };
+        (TFSServices.getItemContentWithHeaders as jest.Mock).mockResolvedValueOnce({
+          data: flatWithChildren,
+          headers: {},
+        });
+
+        const result = await bearerProvider.GetTestSuitesForPlan(mockProject, mockPlanId);
+
+        expect(result.testSuites.map((s: any) => s.id)).toEqual([10, 11, 1, 20]);
+        expect(result.testSuites).toHaveLength(4);
+      });
+
+      it('should leave order unchanged for a flat list with no children field (regression guard)', async () => {
+        const bearerProvider = new TestDataProvider(mockOrgUrl, mockBearerToken);
+        const flatPayload = {
+          value: [
+            { id: 40, name: 'Suite D' },
+            { id: 20, name: 'Suite B' },
+            { id: 10, name: 'Suite A' },
+          ],
+          count: 3,
+        };
+        (TFSServices.getItemContentWithHeaders as jest.Mock).mockResolvedValueOnce({
+          data: flatPayload,
+          headers: {},
+        });
+
+        const result = await bearerProvider.GetTestSuitesForPlan(mockProject, mockPlanId);
+
+        expect(result.testSuites.map((s: any) => s.id)).toEqual([40, 20, 10]);
+        expect(result.testSuites.map((s: any) => s.treeOrder)).toEqual([0, 1, 2]);
+      });
     });
 
     describe('PAT-token branch — regression guard', () => {
@@ -548,7 +625,7 @@ describe('TestDataProvider', () => {
       const result = await bearerProvider.GetTestSuiteById(mockProject, mockPlanId, mockSuiteId, true);
 
       expect(TFSServices.getItemContentWithHeaders).toHaveBeenCalledWith(
-        `${mockOrgUrl.replace(/\/+$/, '')}/${mockProject}/_apis/testplan/Plans/${mockPlanId}/suites?expand=children&api-version=7.0`,
+        `${mockOrgUrl.replace(/\/+$/, '')}/${mockProject}/_apis/testplan/Plans/${mockPlanId}/suites?expand=children&asTreeView=true&api-version=7.0`,
         mockBearerToken,
         'get',
         {},
@@ -672,6 +749,31 @@ describe('TestDataProvider', () => {
       expect(res).toEqual([{ id: '10' }, { id: '11' }]);
     });
 
+    it('should emit multiple hierarchies in tree order, not in suiteIdsFilter order', async () => {
+      jest.spyOn(testDataProvider, 'GetTestSuitesForPlan').mockResolvedValueOnce({
+        testSuites: [
+          { id: 1, parentSuiteId: 0, treeOrder: 0 },
+          { id: 2, parentSuiteId: 0, treeOrder: 1 },
+          { id: 10, parentSuiteId: 1, treeOrder: 2 },
+          { id: 11, parentSuiteId: 2, treeOrder: 3 },
+        ],
+      } as any);
+
+      // Caller lists the second hierarchy's suite (11) before the first (10),
+      // but suite 10 (treeOrder 2) precedes suite 11 (treeOrder 3) in the tree.
+      const suiteIdsFilter = [11, 10];
+      const getByIdSpy = jest
+        .spyOn(testDataProvider, 'GetTestSuiteById')
+        .mockResolvedValueOnce([{ id: '10' }])
+        .mockResolvedValueOnce([{ id: '11' }]);
+
+      const res = await testDataProvider.GetTestSuitesByPlan(mockProject, mockPlanId, true, suiteIdsFilter);
+
+      expect(getByIdSpy).toHaveBeenNthCalledWith(1, mockProject, mockPlanId, '10', true, suiteIdsFilter);
+      expect(getByIdSpy).toHaveBeenNthCalledWith(2, mockProject, mockPlanId, '11', true, suiteIdsFilter);
+      expect(res).toEqual([{ id: '10' }, { id: '11' }]);
+    });
+
     it('should fallback to first suite when no top-level suites can be determined', async () => {
       jest.spyOn(testDataProvider, 'GetTestSuitesForPlan').mockResolvedValueOnce({
         testSuites: [{ id: 1, parentSuiteId: 0 }],