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

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