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

package/src/modules/TestDataProvider.ts

@@ -59,6 +59,93 @@ export default class TestDataProvider {
     }
   }
 
+  private getSuiteDescription(suite: any): string {
+    return String(suite?.description || suite?.suiteDescription || '').trim();
+  }
+
+  private async getSuiteDescriptionsFromWorkItems(
+    project: string,
+    suiteIds: Array<string | number>
+  ): Promise<Map<string, string>> {
+    const ids = Array.from(
+      new Set(
+        suiteIds
+          .map((id) => Number(id))
+          .filter((id) => Number.isFinite(id) && id > 0)
+      )
+    );
+    if (ids.length === 0) {
+      return new Map<string, string>();
+    }
+
+    const url = `${this.joinOrgProject(project)}/_apis/wit/workitemsbatch?api-version=7.1`;
+    const maxBatchSize = 200;
+    const chunks: number[][] = [];
+    for (let i = 0; i < ids.length; i += maxBatchSize) {
+      chunks.push(ids.slice(i, i + maxBatchSize));
+    }
+    const descriptions = new Map<string, string>();
+
+    try {
+      for (const chunkIds of chunks) {
+        const payload = {
+          ids: chunkIds,
+          fields: ['System.Description'],
+          errorPolicy: 'Omit',
+        };
+        const response = await TFSServices.getItemContent(
+          url,
+          this.token,
+          'post',
+          payload,
+          { 'Content-Type': 'application/json' }
+        );
+        const items = Array.isArray(response?.value) ? response.value : [];
+        items.forEach((wi: any) => {
+          const desc = String(wi?.fields?.['System.Description'] || '').trim();
+          if (wi?.id && desc) {
+            descriptions.set(String(wi.id), desc);
+          }
+        });
+      }
+      return descriptions;
+    } catch (error: any) {
+      logger.warn(`Failed to enrich suite descriptions from work items batch: ${error?.message || error}`);
+      return new Map<string, string>();
+    }
+  }
+
+  private async normalizeAndEnrichSuitesResponse(project: string, data: any): Promise<any> {
+    const suites = Array.isArray(data?.testSuites)
+      ? data.testSuites
+      : Array.isArray(data?.value)
+      ? data.value
+      : Array.isArray(data)
+      ? data
+      : [];
+
+    const mapped = suites.map((suite: any) => ({
+      ...suite,
+      title: suite?.title || suite?.name || '',
+      parentSuiteId: suite?.parentSuiteId ?? suite?.parentSuite?.id ?? 0,
+      description: this.getSuiteDescription(suite),
+    }));
+
+    const missingDescriptionIds = mapped
+      .filter((suite: any) => !String(suite?.description || '').trim())
+      .map((suite: any) => suite?.id);
+    const descriptionBySuiteId = await this.getSuiteDescriptionsFromWorkItems(project, missingDescriptionIds);
+    const enriched = mapped.map((suite: any) => ({
+      ...suite,
+      description: suite?.description || descriptionBySuiteId.get(String(suite?.id)) || '',
+    }));
+
+    if (Array.isArray(data)) {
+      return { value: data, testSuites: enriched };
+    }
+    return { ...(data || {}), testSuites: enriched };
+  }
+
   async GetTestSuiteByTestCase(testCaseId: string): Promise<any> {
     const base = String(this.orgUrl || '').replace(/\/+$/, '');
     let url = `${base}/_apis/testplan/suites?testCaseId=${testCaseId}`;
@@ -87,23 +174,11 @@ export default class TestDataProvider {
     if (!planid) {
       throw new Error('Plan not selected');
     }
-    if (this.isBearerToken()) {
-      const url = `${this.joinOrgProject(
-        project
-      )}/_apis/testplan/Plans/${planid}/suites?includeChildren=true&api-version=7.0`;
-      const data = await this.fetchWithCache(url);
-      const suites = Array.isArray(data?.value) ? data.value : Array.isArray(data) ? data : [];
-      const mapped = suites.map((suite: any) => ({
-        ...suite,
-        title: suite?.title || suite?.name || '',
-        parentSuiteId: suite?.parentSuiteId ?? suite?.parentSuite?.id ?? 0,
-      }));
-      return { ...data, testSuites: mapped };
-    }
-    const url = `${this.joinOrgProject(
-      project
-    )}/_api/_testManagement/GetTestSuitesForPlan?__v=5&planId=${planid}`;
-    return await this.fetchWithCache(url);
+    const url = this.isBearerToken()
+      ? `${this.joinOrgProject(project)}/_apis/testplan/Plans/${planid}/suites?includeChildren=true&api-version=7.0`
+      : `${this.joinOrgProject(project)}/_api/_testManagement/GetTestSuitesForPlan?__v=5&planId=${planid}`;
+    const data = await this.fetchWithCache(url);
+    return this.normalizeAndEnrichSuitesResponse(project, data);
   }
 
   async GetTestSuitesByPlan(
@@ -130,16 +205,22 @@ export default class TestDataProvider {
       // These represent separate hierarchies that need to be processed independently
 
       const topLevelSuites: string[] = [];
+      const filterAsStrings = new Set(suiteIdsFilter.map((id) => id.toString()));
+      const filterAsNumbers = new Set(
+        suiteIdsFilter
+          .map((id) => Number(id))
+          .filter((id) => Number.isFinite(id))
+      );
 
       for (const filterSuiteId of suiteIdsFilter) {
         const suite = suiteMap.get(filterSuiteId) || suiteMap.get(parseInt(filterSuiteId.toString()));
         if (suite) {
+          const parentSuiteIdString = String(suite.parentSuiteId);
+          const parentSuiteIdNumber = Number(parentSuiteIdString);
           // Check if this suite's parent is NOT in our filter (making it a top-level suite for our selection)
-          const parentInFilter = suiteIdsFilter.some(
-            (id) =>
-              id.toString() === suite.parentSuiteId.toString() ||
-              parseInt(id.toString()) === suite.parentSuiteId
-          );
+          const parentInFilter =
+            filterAsStrings.has(parentSuiteIdString) ||
+            (Number.isFinite(parentSuiteIdNumber) && filterAsNumbers.has(parentSuiteIdNumber));
 
           if (!parentInFilter && suite.parentSuiteId !== 0) {
             topLevelSuites.push(filterSuiteId.toString());
@@ -322,6 +403,7 @@ export default class TestDataProvider {
           testCase.title = test.fields['System.Title'];
           testCase.area = test.fields['System.AreaPath'];
           testCase.description = test.fields['System.Description'];
+          testCase.testPhase = this.extractTestPhase(test.fields);
           testCase.url = url + test.id;
           //testCase.steps = test.fields["Microsoft.VSTS.TCM.Steps"];
           testCase.id = test.id;
@@ -460,6 +542,32 @@ export default class TestDataProvider {
     return newRequirementRelation;
   }
 
+  private extractTestPhase(fields: any): string {
+    if (!fields || typeof fields !== 'object') return '';
+
+    const direct =
+      fields['Custom.TestPhase'] ??
+      fields['Custom.Phase'] ??
+      fields['Microsoft.VSTS.Common.TestPhase'];
+    if (direct !== undefined && direct !== null) {
+      const value = typeof direct === 'object' ? direct?.displayName ?? direct?.name ?? direct : direct;
+      const normalized = String(value).trim();
+      if (normalized) return normalized;
+    }
+
+    const normalizedKey = Object.keys(fields).find((key) => key.toLowerCase().includes('testphase'));
+    if (normalizedKey) {
+      const value = fields[normalizedKey];
+      const normalized =
+        value && typeof value === 'object'
+          ? String(value.displayName ?? value.name ?? '').trim()
+          : String(value ?? '').trim();
+      if (normalized) return normalized;
+    }
+
+    return '';
+  }
+
   ParseSteps(steps: string) {
     let stepsLsist: Array<TestSteps> = new Array<TestSteps>();
     const start: string = ';P&gt;';

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

@@ -3505,6 +3505,100 @@ describe('ResultDataProvider', () => {
         })
       );
     });
+
+    it('should prefer latest test-case revision fields (title/description/steps) in internal validation flow', async () => {
+      jest.spyOn(resultDataProvider as any, 'fetchTestPlanName').mockResolvedValueOnce('Plan A');
+      jest.spyOn(resultDataProvider as any, 'fetchMewpScopedTestData').mockResolvedValueOnce([
+        {
+          testPointsItems: [{ testCaseId: 777, testCaseName: 'TC 777 (snapshot)' }],
+          testCasesItems: [
+            {
+              workItem: {
+                id: 777,
+                workItemFields: [
+                  { key: 'System.Title', value: 'TC 777 (snapshot title)' },
+                  {
+                    key: 'Microsoft.VSTS.TCM.Steps',
+                    value:
+                      '<steps><step id="2" type="ActionStep"><parameterizedString isformatted="true">Action</parameterizedString><parameterizedString isformatted="true">SR0001</parameterizedString></step></steps>',
+                  },
+                  { key: 'System.Description', value: '<p>Snapshot description</p>' },
+                ],
+              },
+            },
+          ],
+        },
+      ]);
+      jest.spyOn(resultDataProvider as any, 'fetchMewpL2Requirements').mockResolvedValueOnce([
+        {
+          workItemId: 9777,
+          requirementId: 'SR7777',
+          baseKey: 'SR7777',
+          title: 'Req 7777',
+          responsibility: 'ESUK',
+          linkedTestCaseIds: [777],
+          areaPath: 'MEWP\\Customer Requirements\\Level 2',
+        },
+      ]);
+      jest.spyOn(resultDataProvider as any, 'buildLinkedRequirementsByTestCase').mockResolvedValueOnce(
+        new Map([
+          [
+            777,
+            {
+              baseKeys: new Set(['SR7777']),
+              fullCodes: new Set(['SR7777']),
+            },
+          ],
+        ])
+      );
+      const fetchWorkItemsByIdsSpy = jest
+        .spyOn(resultDataProvider as any, 'fetchWorkItemsByIds')
+        .mockResolvedValueOnce([
+          {
+            id: 777,
+            fields: {
+              'System.Title': 'TC 777 (latest title)',
+              'System.Description':
+                '<p><b><u>Trial specific assumptions, constraints, dependencies and requirements</u></b></p><p>SR7777</p>',
+              'Microsoft.VSTS.TCM.Steps':
+                '<steps><step id="2" type="ActionStep"><parameterizedString isformatted="true">Action</parameterizedString><parameterizedString isformatted="true">SR7777</parameterizedString></step></steps>',
+            },
+          },
+        ]);
+      jest.spyOn((resultDataProvider as any).testStepParserHelper, 'parseTestSteps').mockImplementation(
+        async (...args: any[]) => [
+          {
+            stepId: '1',
+            stepPosition: '1',
+            action: 'Action',
+            expected: String(args?.[0] || '').includes('SR7777') ? 'SR7777' : 'SR0001',
+            isSharedStepTitle: false,
+          },
+        ]
+      );
+
+      const result = await (resultDataProvider as any).getMewpInternalValidationFlatResults(
+        '123',
+        mockProjectName,
+        [1]
+      );
+
+      expect(fetchWorkItemsByIdsSpy).toHaveBeenCalledWith(mockProjectName, [777], false);
+      expect((resultDataProvider as any).testStepParserHelper.parseTestSteps).toHaveBeenCalledWith(
+        expect.stringContaining('SR7777'),
+        expect.any(Map)
+      );
+      expect(result.rows).toHaveLength(1);
+      expect(result.rows[0]).toEqual(
+        expect.objectContaining({
+          'Test Case ID': 777,
+          'Test Case Title': 'TC 777 (latest title)',
+          'Mentioned but Not Linked': '',
+          'Linked but Not Mentioned': '',
+          'Validation Status': 'Pass',
+        })
+      );
+    });
   });
 
   describe('buildLinkedRequirementsByTestCase', () => {

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 = {