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

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

@@ -276,6 +276,50 @@ describe('MangementDataProvider', () => {
       );
     });
   });
+
+  describe('GetIdentityById', () => {
+    it('should call getItemContent with the exact documented URL shape', async () => {
+      const mockResponse = {
+        count: 1,
+        value: [{ id: 'id-1', properties: { Domain: { $value: 'GALAXY' }, Account: { $value: 'EdenS' } } }],
+      };
+      (TFSServices.getItemContent as jest.Mock).mockResolvedValueOnce(mockResponse);
+
+      const result = await managementDataProvider.GetIdentityById('69c3a88a-e668-4ed9-b9e8-9c2eb96fc30e');
+
+      expect(TFSServices.getItemContent).toHaveBeenCalledWith(
+        `${mockOrgUrl}_apis/identities?identityIds=69c3a88a-e668-4ed9-b9e8-9c2eb96fc30e&queryMembership=None&api-version=6.0`,
+        mockToken,
+        'get',
+        null,
+        null,
+        false
+      );
+      expect(result).toEqual(mockResponse);
+    });
+
+    it('should URL-encode an identity id that needs escaping', async () => {
+      (TFSServices.getItemContent as jest.Mock).mockResolvedValueOnce({ count: 0, value: [] });
+
+      await managementDataProvider.GetIdentityById('id with spaces');
+
+      expect(TFSServices.getItemContent).toHaveBeenCalledWith(
+        `${mockOrgUrl}_apis/identities?identityIds=id%20with%20spaces&queryMembership=None&api-version=6.0`,
+        mockToken,
+        'get',
+        null,
+        null,
+        false
+      );
+    });
+
+    it('should propagate an error from the API call', async () => {
+      const expectedError = new Error('Identities API call failed');
+      (TFSServices.getItemContent as jest.Mock).mockRejectedValueOnce(expectedError);
+
+      await expect(managementDataProvider.GetIdentityById('id-1')).rejects.toThrow('Identities API call failed');
+    });
+  });
 });
 
 describe('MangementDataProvider - Additional Tests', () => {

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 }],