@elisra-devops/docgen-data-provider 1.104.0 → 1.105.0

package/src/modules/TicketsDataProvider.ts

@@ -199,12 +199,25 @@ export default class TicketsDataProvider {
       const queriesWithChildren = await this.ensureQueryChildren(queries);
 
       switch (normalizedDocType) {
-        case 'std': {
-          const { root: stdRoot, found: stdRootFound } = await this.getDocTypeRoot(
-            queriesWithChildren,
-            'std'
+        case 'std':
+        case 'stp': {
+          const rootCandidates =
+            normalizedDocType === 'stp' ? (['stp', 'std'] as const) : (['std'] as const);
+          let stdRoot = queriesWithChildren;
+          let stdRootFound = false;
+          for (const candidate of rootCandidates) {
+            const lookup = await this.getDocTypeRoot(queriesWithChildren, candidate);
+            if (lookup.found) {
+              stdRoot = lookup.root;
+              stdRootFound = true;
+              break;
+            }
+          }
+          logger.debug(
+            `[GetSharedQueries][${normalizedDocType}] using ${
+              stdRootFound ? 'dedicated folder' : 'root queries'
+            }`
           );
-          logger.debug(`[GetSharedQueries][std] using ${stdRootFound ? 'dedicated folder' : 'root queries'}`);
           // Each branch describes the dedicated folder names, the fetch routine, and how to validate results.
           const stdBranches = await this.fetchDocTypeBranches(queriesWithChildren, stdRoot, [
             {

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

@@ -13,13 +13,14 @@ describe('Helper', () => {
   describe('suiteData class', () => {
     it('should create suiteData with correct properties', () => {
       // Act
-      const suite = new suiteData('Test Suite', '123', '456', 2);
+      const suite = new suiteData('Test Suite', '123', '456', 2, 'Suite description');
 
       // Assert
       expect(suite.name).toBe('Test Suite');
       expect(suite.id).toBe('123');
       expect(suite.parent).toBe('456');
       expect(suite.level).toBe(2);
+      expect(suite.description).toBe('Suite description');
       expect(suite.url).toBeUndefined();
     });
   });

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

@@ -204,8 +204,8 @@ describe('TestDataProvider', () => {
       // Arrange
       const mockData = {
         testSuites: [
-          { id: '123', name: 'Test Suite 1' },
-          { id: '456', name: 'Test Suite 2' },
+          { id: '123', name: 'Test Suite 1', suiteDescription: 'Legacy Desc 1' },
+          { id: '456', name: 'Test Suite 2', description: 'Legacy Desc 2' },
         ],
       };
       (TFSServices.getItemContent as jest.Mock).mockResolvedValueOnce(mockData);
@@ -214,19 +214,110 @@ describe('TestDataProvider', () => {
       const result = await testDataProvider.GetTestSuitesForPlan(mockProject, mockPlanId);
 
       // Assert
-      expect(result).toEqual(mockData);
+      expect(result.testSuites).toEqual(
+        expect.arrayContaining([
+          expect.objectContaining({
+            id: '123',
+            title: 'Test Suite 1',
+            parentSuiteId: 0,
+            description: 'Legacy Desc 1',
+          }),
+          expect.objectContaining({
+            id: '456',
+            title: 'Test Suite 2',
+            parentSuiteId: 0,
+            description: 'Legacy Desc 2',
+          }),
+        ])
+      );
       expect(TFSServices.getItemContent).toHaveBeenCalledWith(
         `${mockOrgUrl.replace(/\/+$/, '')}/${mockProject}/_api/_testManagement/GetTestSuitesForPlan?__v=5&planId=${mockPlanId}`,
         mockToken
       );
     });
 
+    it('should enrich missing suite descriptions via work items batch for PAT token', async () => {
+      const suitesPayload = {
+        testSuites: [
+          { id: 11, name: 'Suite A' },
+          { id: 22, name: 'Suite B', suiteDescription: 'From legacy payload' },
+        ],
+      };
+      const workItemsPayload = {
+        value: [{ id: 11, fields: { 'System.Description': '<div>WI Desc A</div>' } }],
+      };
+      (TFSServices.getItemContent as jest.Mock).mockImplementation((url: string) => {
+        if (url.includes('/_apis/wit/workitemsbatch')) {
+          return Promise.resolve(workItemsPayload);
+        }
+        return Promise.resolve(suitesPayload);
+      });
+
+      const result = await testDataProvider.GetTestSuitesForPlan(mockProject, mockPlanId);
+
+      expect(TFSServices.getItemContent).toHaveBeenNthCalledWith(
+        1,
+        `${mockOrgUrl.replace(/\/+$/, '')}/${mockProject}/_api/_testManagement/GetTestSuitesForPlan?__v=5&planId=${mockPlanId}`,
+        mockToken
+      );
+      expect(TFSServices.getItemContent).toHaveBeenNthCalledWith(
+        2,
+        `${mockOrgUrl.replace(/\/+$/, '')}/${mockProject}/_apis/wit/workitemsbatch?api-version=7.1`,
+        mockToken,
+        'post',
+        {
+          ids: [11],
+          fields: ['System.Description'],
+          errorPolicy: 'Omit',
+        },
+        { 'Content-Type': 'application/json' }
+      );
+      expect(result.testSuites).toEqual(
+        expect.arrayContaining([
+          expect.objectContaining({ id: 11, description: '<div>WI Desc A</div>' }),
+          expect.objectContaining({ id: 22, description: 'From legacy payload' }),
+        ])
+      );
+    });
+
+    it('should chunk work items batch requests when suite IDs exceed batch limit', async () => {
+      const suitesPayload = {
+        testSuites: Array.from({ length: 205 }, (_, i) => ({
+          id: i + 1,
+          name: `Suite ${i + 1}`,
+        })),
+      };
+      (TFSServices.getItemContent as jest.Mock).mockImplementation((url: string, _token: string, method?: string, data?: any) => {
+        if (url.includes('/_apis/wit/workitemsbatch') && method === 'post') {
+          const ids = Array.isArray(data?.ids) ? data.ids : [];
+          return Promise.resolve({
+            value: ids.map((id: number) => ({
+              id,
+              fields: { 'System.Description': `Desc ${id}` },
+            })),
+          });
+        }
+        return Promise.resolve(suitesPayload);
+      });
+
+      const result = await testDataProvider.GetTestSuitesForPlan(mockProject, mockPlanId);
+
+      expect((TFSServices.getItemContent as jest.Mock).mock.calls).toHaveLength(3);
+      expect((TFSServices.getItemContent as jest.Mock).mock.calls[1][2]).toBe('post');
+      expect((TFSServices.getItemContent as jest.Mock).mock.calls[1][3].ids).toHaveLength(200);
+      expect((TFSServices.getItemContent as jest.Mock).mock.calls[2][2]).toBe('post');
+      expect((TFSServices.getItemContent as jest.Mock).mock.calls[2][3].ids).toHaveLength(5);
+
+      expect(result.testSuites.find((s: any) => s.id === 1)?.description).toBe('Desc 1');
+      expect(result.testSuites.find((s: any) => s.id === 205)?.description).toBe('Desc 205');
+    });
+
     it('should use testplan suites endpoint for bearer token and normalize response', async () => {
       const bearerProvider = new TestDataProvider(mockOrgUrl, mockBearerToken);
       const mockData = {
         value: [
-          { id: '123', name: 'Suite 1' },
-          { id: '456', name: 'Suite 2', parentSuite: { id: '123' } },
+          { id: '123', name: 'Suite 1', description: 'Desc 1' },
+          { id: '456', name: 'Suite 2', parentSuite: { id: '123' }, suiteDescription: 'Desc 2' },
         ],
         count: 2,
       };
@@ -240,8 +331,58 @@ describe('TestDataProvider', () => {
       );
       expect(result.testSuites).toEqual(
         expect.arrayContaining([
-          expect.objectContaining({ id: '123', title: 'Suite 1', parentSuiteId: 0 }),
-          expect.objectContaining({ id: '456', title: 'Suite 2', parentSuiteId: '123' }),
+          expect.objectContaining({ id: '123', title: 'Suite 1', parentSuiteId: 0, description: 'Desc 1' }),
+          expect.objectContaining({
+            id: '456',
+            title: 'Suite 2',
+            parentSuiteId: '123',
+            description: 'Desc 2',
+          }),
+        ])
+      );
+    });
+
+    it('should enrich missing suite descriptions via work items batch for bearer token', async () => {
+      const bearerProvider = new TestDataProvider(mockOrgUrl, mockBearerToken);
+      const suitesPayload = {
+        value: [
+          { id: 101, name: 'Suite A' },
+          { id: 202, name: 'Suite B', description: 'Native Desc B' },
+        ],
+      };
+      const workItemsPayload = {
+        value: [{ id: 101, fields: { 'System.Description': 'Enriched Desc A' } }],
+      };
+      (TFSServices.getItemContent as jest.Mock).mockImplementation((url: string) => {
+        if (url.includes('/_apis/wit/workitemsbatch')) {
+          return Promise.resolve(workItemsPayload);
+        }
+        return Promise.resolve(suitesPayload);
+      });
+
+      const result = await bearerProvider.GetTestSuitesForPlan(mockProject, mockPlanId);
+
+      expect(TFSServices.getItemContent).toHaveBeenNthCalledWith(
+        1,
+        `${mockOrgUrl.replace(/\/+$/, '')}/${mockProject}/_apis/testplan/Plans/${mockPlanId}/suites?includeChildren=true&api-version=7.0`,
+        mockBearerToken
+      );
+      expect(TFSServices.getItemContent).toHaveBeenNthCalledWith(
+        2,
+        `${mockOrgUrl.replace(/\/+$/, '')}/${mockProject}/_apis/wit/workitemsbatch?api-version=7.1`,
+        mockBearerToken,
+        'post',
+        {
+          ids: [101],
+          fields: ['System.Description'],
+          errorPolicy: 'Omit',
+        },
+        { 'Content-Type': 'application/json' }
+      );
+      expect(result.testSuites).toEqual(
+        expect.arrayContaining([
+          expect.objectContaining({ id: 101, description: 'Enriched Desc A' }),
+          expect.objectContaining({ id: 202, description: 'Native Desc B' }),
         ])
       );
     });
@@ -268,7 +409,14 @@ describe('TestDataProvider', () => {
         mockPlanId,
         mockOrgUrl,
         mockProject,
-        mockTestSuites.testSuites,
+        expect.arrayContaining([
+          expect.objectContaining({
+            id: '123',
+            title: 'Test Suite 1',
+            parentSuiteId: 0,
+            description: '',
+          }),
+        ]),
         mockSuiteId,
         true
       );
@@ -278,7 +426,7 @@ describe('TestDataProvider', () => {
     it('should use bearer suites payload when token is bearer', async () => {
       const bearerProvider = new TestDataProvider(mockOrgUrl, mockBearerToken);
       const mockTestSuites = {
-        value: [{ id: '123', name: 'Suite 1', parentSuite: { id: 0 } }],
+        value: [{ id: '123', name: 'Suite 1', parentSuite: { id: 0 }, description: 'Suite Desc' }],
       };
       const mockSuiteData = [new suiteData('Suite 1', '123', '456', 1)];
       (TFSServices.getItemContent as jest.Mock).mockResolvedValueOnce(mockTestSuites);
@@ -1046,6 +1194,74 @@ describe('TestDataProvider', () => {
       );
     });
 
+    it('should populate testPhase from Custom.TestPhase', async () => {
+      const suite = { id: '1', name: 'Suite 1' } as any;
+      const testCases = {
+        count: 1,
+        value: [{ testCase: { id: 123, url: 'https://example.com/testcase/123' } }],
+      };
+
+      jest.spyOn(testDataProvider as any, 'fetchWithCache').mockResolvedValueOnce({
+        id: 123,
+        fields: {
+          'System.Title': 'TC 123',
+          'System.AreaPath': 'A',
+          'System.Description': 'D',
+          'Custom.TestPhase': 'SIT',
+          'Microsoft.VSTS.TCM.Steps': null,
+        },
+        relations: [],
+      });
+
+      const res = await testDataProvider.StructureTestCase(
+        mockProject,
+        testCases as any,
+        suite,
+        false,
+        false,
+        false,
+        new Map<string, string[]>(),
+        new Map<string, string[]>()
+      );
+
+      expect(res).toHaveLength(1);
+      expect(res[0].testPhase).toBe('SIT');
+    });
+
+    it('should extract testPhase from fallback key containing testphase', async () => {
+      const suite = { id: '1', name: 'Suite 1' } as any;
+      const testCases = {
+        count: 1,
+        value: [{ testCase: { id: 123, url: 'https://example.com/testcase/123' } }],
+      };
+
+      jest.spyOn(testDataProvider as any, 'fetchWithCache').mockResolvedValueOnce({
+        id: 123,
+        fields: {
+          'System.Title': 'TC 123',
+          'System.AreaPath': 'A',
+          'System.Description': 'D',
+          'Custom.MyTestPhaseField': { displayName: 'Regression' },
+          'Microsoft.VSTS.TCM.Steps': null,
+        },
+        relations: [],
+      });
+
+      const res = await testDataProvider.StructureTestCase(
+        mockProject,
+        testCases as any,
+        suite,
+        false,
+        false,
+        false,
+        new Map<string, string[]>(),
+        new Map<string, string[]>()
+      );
+
+      expect(res).toHaveLength(1);
+      expect(res[0].testPhase).toBe('Regression');
+    });
+
     it('should return empty list when test case fetch fails', async () => {
       const suite = { id: '1', name: 'Suite 1' } as any;
       const testCases = {

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

@@ -1848,6 +1848,81 @@ describe('TicketsDataProvider', () => {
   });
 
   describe('GetSharedQueries - docType branches', () => {
+    it('should handle STP docType', async () => {
+      // Arrange
+      const mockQueries = {
+        children: [{ name: 'STP', isFolder: true, children: [] }],
+      };
+      (TFSServices.getItemContent as jest.Mock).mockResolvedValue(mockQueries);
+
+      // Act
+      const result = await ticketsDataProvider.GetSharedQueries(mockProject, '', 'stp');
+
+      // Assert
+      expect(result).toBeDefined();
+    });
+
+    it('should fallback to STD root when STP root is missing', async () => {
+      const rootQueries = { id: 'root', children: [] };
+      const stdRoot = { id: 'std-root', children: [] };
+      (TFSServices.getItemContent as jest.Mock).mockResolvedValue(rootQueries);
+
+      const getDocTypeRootSpy = jest
+        .spyOn(ticketsDataProvider as any, 'getDocTypeRoot')
+        .mockImplementation(async (...args: any[]) => {
+          const docTypeName = String(args[1] || '');
+          if (docTypeName === 'stp') return { root: rootQueries, found: false };
+          if (docTypeName === 'std') return { root: stdRoot, found: true };
+          return { root: rootQueries, found: false };
+        });
+
+      const fetchDocTypeBranchesSpy = jest
+        .spyOn(ticketsDataProvider as any, 'fetchDocTypeBranches')
+        .mockResolvedValue({
+          reqToTest: { result: { reqTestTree: { id: 'req-tree' }, testReqTree: { id: 'fallback-tree' } } },
+          testToReq: { result: { testReqTree: { id: 'test-tree' } } },
+          mom: { result: { linkedMomTree: { id: 'mom-tree' } } },
+        });
+
+      const result = await ticketsDataProvider.GetSharedQueries(mockProject, '', 'stp');
+
+      expect(getDocTypeRootSpy).toHaveBeenNthCalledWith(1, rootQueries, 'stp');
+      expect(getDocTypeRootSpy).toHaveBeenNthCalledWith(2, rootQueries, 'std');
+      expect(fetchDocTypeBranchesSpy).toHaveBeenCalledWith(rootQueries, stdRoot, expect.any(Array));
+      expect(result.reqTestQueries.reqTestTree).toEqual({ id: 'req-tree' });
+      expect(result.reqTestQueries.testReqTree).toEqual({ id: 'test-tree' });
+      expect(result.linkedMomQueries.linkedMomTree).toEqual({ id: 'mom-tree' });
+    });
+
+    it('should prefer STP root over STD when both exist', async () => {
+      const rootQueries = { id: 'root', children: [] };
+      const stpRoot = { id: 'stp-root', children: [] };
+      (TFSServices.getItemContent as jest.Mock).mockResolvedValue(rootQueries);
+
+      const getDocTypeRootSpy = jest
+        .spyOn(ticketsDataProvider as any, 'getDocTypeRoot')
+        .mockImplementation(async (...args: any[]) => {
+          const docTypeName = String(args[1] || '');
+          if (docTypeName === 'stp') return { root: stpRoot, found: true };
+          if (docTypeName === 'std') return { root: { id: 'std-root', children: [] }, found: true };
+          return { root: rootQueries, found: false };
+        });
+
+      const fetchDocTypeBranchesSpy = jest
+        .spyOn(ticketsDataProvider as any, 'fetchDocTypeBranches')
+        .mockResolvedValue({
+          reqToTest: { result: { reqTestTree: { id: 'req-tree' }, testReqTree: null } },
+          testToReq: { result: { testReqTree: { id: 'test-tree' } } },
+          mom: { result: { linkedMomTree: null } },
+        });
+
+      await ticketsDataProvider.GetSharedQueries(mockProject, '', 'stp');
+
+      expect(getDocTypeRootSpy).toHaveBeenCalledTimes(1);
+      expect(getDocTypeRootSpy).toHaveBeenCalledWith(rootQueries, 'stp');
+      expect(fetchDocTypeBranchesSpy).toHaveBeenCalledWith(rootQueries, stpRoot, expect.any(Array));
+    });
+
     it('should handle STR docType', async () => {
       // Arrange
       const mockQueries = {