@elisra-devops/docgen-data-provider 1.74.0 → 1.75.0

package/src/modules/ResultDataProvider.ts

@@ -393,8 +393,7 @@ export default class ResultDataProvider {
   public async getMewpL2CoverageFlatResults(
     testPlanId: string,
     projectName: string,
-    selectedSuiteIds: number[] | undefined,
-    linkedQueryRequest?: any
+    selectedSuiteIds: number[] | undefined
   ) {
     const defaultPayload = {
       sheetName: `MEWP L2 Coverage - Plan ${testPlanId}`,
@@ -407,7 +406,7 @@ export default class ResultDataProvider {
       const suites = await this.fetchTestSuites(testPlanId, projectName, selectedSuiteIds, true);
       const testData = await this.fetchTestData(suites, projectName, testPlanId, false);
 
-      const requirements = await this.fetchMewpL2Requirements(projectName, linkedQueryRequest);
+      const requirements = await this.fetchMewpL2Requirements(projectName);
       if (requirements.length === 0) {
         return {
           ...defaultPayload,
@@ -560,9 +559,9 @@ export default class ResultDataProvider {
     testCaseTitle: string,
     stepSummary: { passed: number; failed: number; notRun: number }
   ) {
-    const customerId = String(requirement.requirementId || '').trim();
-    const customerTitle = String(requirement.title || '').trim();
-    const responsibility = String(requirement.responsibility || '').trim();
+    const customerId = this.formatMewpCustomerId(requirement.requirementId);
+    const customerTitle = this.toMewpComparableText(requirement.title);
+    const responsibility = this.toMewpComparableText(requirement.responsibility);
     const safeTestCaseId = Number.isFinite(testCaseId) && Number(testCaseId) > 0 ? Number(testCaseId) : '';
 
     return {
@@ -577,6 +576,15 @@ export default class ResultDataProvider {
     };
   }
 
+  private formatMewpCustomerId(rawValue: string): string {
+    const normalized = this.normalizeMewpRequirementCode(this.toMewpComparableText(rawValue));
+    if (normalized) return normalized;
+
+    const onlyDigits = String(rawValue || '').replace(/\D/g, '');
+    if (onlyDigits) return `SR${onlyDigits}`;
+    return '';
+  }
+
   private buildMewpCoverageRows(
     requirements: Array<{
       requirementId: string;
@@ -802,7 +810,7 @@ export default class ResultDataProvider {
     return `SR${digits}`;
   }
 
-  private async fetchMewpL2Requirements(projectName: string, linkedQueryRequest?: any): Promise<
+  private async fetchMewpL2Requirements(projectName: string): Promise<
     Array<{
       workItemId: number;
       requirementId: string;
@@ -811,11 +819,6 @@ export default class ResultDataProvider {
       linkedTestCaseIds: number[];
     }>
   > {
-    const queryHref = this.extractMewpQueryHref(linkedQueryRequest);
-    if (queryHref) {
-      return this.fetchMewpL2RequirementsFromQuery(projectName, queryHref);
-    }
-
     const workItemTypeNames = await this.fetchMewpRequirementTypeNames(projectName);
     if (workItemTypeNames.length === 0) {
       return [];
@@ -846,7 +849,7 @@ ORDER BY [System.Id]`;
       return {
         workItemId: Number(wi?.id || 0),
         requirementId: this.extractMewpRequirementIdentifier(fields, Number(wi?.id || 0)),
-        title: String(fields['System.Title'] || ''),
+        title: this.toMewpComparableText(fields?.['System.Title'] || wi?.title),
         responsibility: this.deriveMewpResponsibility(fields),
         linkedTestCaseIds: this.extractLinkedTestCaseIdsFromRequirement(wi?.relations || []),
       };
@@ -855,225 +858,6 @@ ORDER BY [System.Id]`;
     return requirements.sort((a, b) => String(a.requirementId).localeCompare(String(b.requirementId)));
   }
 
-  private extractMewpQueryHref(linkedQueryRequest?: any): string {
-    const mode = String(linkedQueryRequest?.linkedQueryMode || '')
-      .trim()
-      .toLowerCase();
-    if (mode !== 'query') return '';
-
-    return String(linkedQueryRequest?.testAssociatedQuery?.wiql?.href || '').trim();
-  }
-
-  private async fetchMewpL2RequirementsFromQuery(
-    projectName: string,
-    queryHref: string
-  ): Promise<
-    Array<{
-      workItemId: number;
-      requirementId: string;
-      title: string;
-      responsibility: string;
-      linkedTestCaseIds: number[];
-    }>
-  > {
-    try {
-      const ticketsDataProvider = new TicketsDataProvider(this.orgUrl, this.token);
-      const queryResult = await ticketsDataProvider.GetQueryResultsFromWiql(
-        queryHref,
-        true,
-        new Map<number, Set<any>>()
-      );
-
-      const requirementTypeNames = await this.fetchMewpRequirementTypeNames(projectName);
-      const requirementTypeSet = new Set(
-        requirementTypeNames.map((name) => String(name || '').trim().toLowerCase())
-      );
-
-      const requirementsById = new Map<
-        number,
-        {
-          workItemId: number;
-          requirementId: string;
-          title: string;
-          responsibility: string;
-          linkedTestCaseIds: Set<number>;
-        }
-      >();
-
-      const upsertRequirement = (workItem: any) => {
-        this.upsertMewpRequirement(requirementsById, workItem, requirementTypeSet);
-      };
-
-      const linkRequirementToTestCase = (requirementWorkItem: any, testCaseWorkItem: any) => {
-        const requirementId = Number(requirementWorkItem?.id || 0);
-        const testCaseId = Number(testCaseWorkItem?.id || 0);
-        if (!Number.isFinite(requirementId) || requirementId <= 0) return;
-        if (!Number.isFinite(testCaseId) || testCaseId <= 0) return;
-
-        upsertRequirement(requirementWorkItem);
-        const requirement = requirementsById.get(requirementId);
-        if (!requirement) return;
-        requirement.linkedTestCaseIds.add(testCaseId);
-      };
-
-      if (Array.isArray(queryResult?.fetchedWorkItems)) {
-        for (const workItem of queryResult.fetchedWorkItems) {
-          upsertRequirement(workItem);
-        }
-      }
-
-      if (queryResult?.sourceTargetsMap && typeof queryResult.sourceTargetsMap.entries === 'function') {
-        for (const [sourceItem, targets] of queryResult.sourceTargetsMap.entries()) {
-          const sourceType = this.getMewpWorkItemType(sourceItem);
-          const sourceIsRequirement = this.isMewpRequirementType(sourceType, requirementTypeSet);
-          const sourceIsTestCase = this.isMewpTestCaseType(sourceType);
-
-          if (sourceIsRequirement) {
-            upsertRequirement(sourceItem);
-          }
-
-          const relatedItems = Array.isArray(targets) ? targets : [];
-          for (const targetItem of relatedItems) {
-            const targetType = this.getMewpWorkItemType(targetItem);
-            const targetIsRequirement = this.isMewpRequirementType(targetType, requirementTypeSet);
-            const targetIsTestCase = this.isMewpTestCaseType(targetType);
-
-            if (targetIsRequirement) {
-              upsertRequirement(targetItem);
-            }
-
-            if (sourceIsRequirement && targetIsTestCase) {
-              linkRequirementToTestCase(sourceItem, targetItem);
-            } else if (sourceIsTestCase && targetIsRequirement) {
-              linkRequirementToTestCase(targetItem, sourceItem);
-            }
-          }
-        }
-      }
-
-      await this.hydrateMewpRequirementsFromWorkItems(projectName, requirementsById);
-
-      return [...requirementsById.values()]
-        .map((requirement) => ({
-          workItemId: requirement.workItemId,
-          requirementId: requirement.requirementId,
-          title: requirement.title,
-          responsibility: requirement.responsibility,
-          linkedTestCaseIds: [...requirement.linkedTestCaseIds].sort((a, b) => a - b),
-        }))
-        .sort((a, b) => String(a.requirementId).localeCompare(String(b.requirementId)));
-    } catch (error: any) {
-      logger.error(`Could not fetch MEWP requirements from query: ${error?.message || error}`);
-      return [];
-    }
-  }
-
-  private upsertMewpRequirement(
-    requirementsById: Map<
-      number,
-      {
-        workItemId: number;
-        requirementId: string;
-        title: string;
-        responsibility: string;
-        linkedTestCaseIds: Set<number>;
-      }
-    >,
-    workItem: any,
-    requirementTypeSet: Set<string>
-  ) {
-    const workItemId = Number(workItem?.id || 0);
-    if (!Number.isFinite(workItemId) || workItemId <= 0) return;
-
-    const fields = workItem?.fields || {};
-    const workItemType = this.getMewpWorkItemType(workItem);
-    if (!this.isMewpRequirementType(workItemType, requirementTypeSet)) return;
-
-    const existing = requirementsById.get(workItemId) || {
-      workItemId,
-      requirementId: String(workItemId),
-      title: '',
-      responsibility: '',
-      linkedTestCaseIds: new Set<number>(),
-    };
-
-    const extractedRequirementId = this.extractMewpRequirementIdentifier(fields, workItemId);
-    const extractedTitle = this.toMewpComparableText(fields?.['System.Title']);
-    const extractedResponsibility = this.deriveMewpResponsibility(fields);
-
-    existing.requirementId = extractedRequirementId || existing.requirementId || String(workItemId);
-    if (extractedTitle) {
-      existing.title = extractedTitle;
-    }
-    if (extractedResponsibility) {
-      existing.responsibility = extractedResponsibility;
-    }
-
-    requirementsById.set(workItemId, existing);
-  }
-
-  private async hydrateMewpRequirementsFromWorkItems(
-    projectName: string,
-    requirementsById: Map<
-      number,
-      {
-        workItemId: number;
-        requirementId: string;
-        title: string;
-        responsibility: string;
-        linkedTestCaseIds: Set<number>;
-      }
-    >
-  ) {
-    const requirementIds = [...requirementsById.keys()];
-    if (requirementIds.length === 0) return;
-
-    const fetchedRequirements = await this.fetchWorkItemsByIds(projectName, requirementIds, true);
-    for (const requirementWorkItem of fetchedRequirements) {
-      const workItemId = Number(requirementWorkItem?.id || 0);
-      if (!Number.isFinite(workItemId) || workItemId <= 0) continue;
-      const current = requirementsById.get(workItemId);
-      if (!current) continue;
-
-      const fields = requirementWorkItem?.fields || {};
-      const requirementId = this.extractMewpRequirementIdentifier(fields, workItemId);
-      const title = this.toMewpComparableText(fields?.['System.Title']);
-      const responsibility = this.deriveMewpResponsibility(fields);
-      const linkedTestCaseIds = this.extractLinkedTestCaseIdsFromRequirement(
-        requirementWorkItem?.relations || []
-      );
-
-      current.requirementId = requirementId || current.requirementId || String(workItemId);
-      if (title) {
-        current.title = title;
-      }
-      if (responsibility) {
-        current.responsibility = responsibility;
-      }
-      linkedTestCaseIds.forEach((testCaseId) => current.linkedTestCaseIds.add(testCaseId));
-    }
-  }
-
-  private getMewpWorkItemType(workItem: any): string {
-    return this.toMewpComparableText(workItem?.fields?.['System.WorkItemType']);
-  }
-
-  private isMewpRequirementType(workItemType: string, requirementTypeSet: Set<string>): boolean {
-    const normalized = String(workItemType || '')
-      .trim()
-      .toLowerCase();
-    if (!normalized) return false;
-    if (requirementTypeSet.has(normalized)) return true;
-    return normalized.includes('requirement') || normalized === 'epic';
-  }
-
-  private isMewpTestCaseType(workItemType: string): boolean {
-    const normalized = String(workItemType || '')
-      .trim()
-      .toLowerCase();
-    return normalized === 'test case' || normalized === 'testcase';
-  }
-
   private async fetchMewpRequirementTypeNames(projectName: string): Promise<string[]> {
     try {
       const url = `${this.orgUrl}${projectName}/_apis/wit/workitemtypes?api-version=7.1-preview.2`;
@@ -1175,10 +959,20 @@ ORDER BY [System.Id]`;
     const titleCode = this.normalizeMewpRequirementCode(title);
     if (titleCode) return titleCode;
 
-    return String(fallbackWorkItemId || '');
+    return fallbackWorkItemId ? `SR${fallbackWorkItemId}` : '';
   }
 
   private deriveMewpResponsibility(fields: Record<string, any>): string {
+    const explicitSapWbs = this.toMewpComparableText(fields?.['Custom.SAPWBS']);
+    const fromExplicitSapWbs = this.resolveMewpResponsibility(explicitSapWbs);
+    if (fromExplicitSapWbs) return fromExplicitSapWbs;
+    if (explicitSapWbs) return explicitSapWbs;
+
+    const explicitSapWbsByLabel = this.toMewpComparableText(fields?.['SAPWBS']);
+    const fromExplicitLabel = this.resolveMewpResponsibility(explicitSapWbsByLabel);
+    if (fromExplicitLabel) return fromExplicitLabel;
+    if (explicitSapWbsByLabel) return explicitSapWbsByLabel;
+
     const areaPath = this.toMewpComparableText(fields?.['System.AreaPath']);
     const fromAreaPath = this.resolveMewpResponsibility(areaPath);
     if (fromAreaPath) return fromAreaPath;
@@ -1225,6 +1019,8 @@ ORDER BY [System.Id]`;
       if (name) return String(name).trim();
       const uniqueName = (value as any).uniqueName;
       if (uniqueName) return String(uniqueName).trim();
+      const objectValue = (value as any).value;
+      if (objectValue !== undefined && objectValue !== null) return String(objectValue).trim();
     }
     return String(value).trim();
   }

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

@@ -1075,101 +1075,6 @@ describe('ResultDataProvider', () => {
   });
 
   describe('getMewpL2CoverageFlatResults', () => {
-    it('should support query-mode requirement scope for MEWP coverage', async () => {
-      jest.spyOn(resultDataProvider as any, 'fetchTestPlanName').mockResolvedValueOnce('Plan A');
-      jest.spyOn(resultDataProvider as any, 'fetchTestSuites').mockResolvedValueOnce([{ testSuiteId: 1 }]);
-      jest.spyOn(resultDataProvider as any, 'fetchTestData').mockResolvedValueOnce([
-        {
-          testPointsItems: [{ testCaseId: 101, lastRunId: 10, lastResultId: 20, testCaseName: 'TC 101' }],
-          testCasesItems: [
-            {
-              workItem: {
-                id: 101,
-                workItemFields: [{ key: 'System.Title', value: 'TC 101' }],
-              },
-            },
-          ],
-        },
-      ]);
-      jest.spyOn(resultDataProvider as any, 'fetchMewpRequirementTypeNames').mockResolvedValueOnce([
-        'Requirement',
-      ]);
-      jest.spyOn(resultDataProvider as any, 'fetchWorkItemsByIds').mockResolvedValueOnce([
-        {
-          id: 9001,
-          fields: {
-            'System.WorkItemType': 'Requirement',
-            'System.Title': 'Requirement from query',
-            'Custom.CustomerId': 'SR3001',
-            'System.AreaPath': 'MEWP\\IL',
-          },
-          relations: [
-            {
-              rel: 'Microsoft.VSTS.Common.TestedBy-Forward',
-              url: 'https://dev.azure.com/org/_apis/wit/workItems/101',
-            },
-          ],
-        },
-      ]);
-      jest.spyOn(resultDataProvider as any, 'fetchAllResultDataTestReporter').mockResolvedValueOnce([
-        {
-          testCaseId: 101,
-          testCase: { id: 101, name: 'TC 101' },
-          iteration: {
-            actionResults: [{ action: 'Validate SR3001', expected: '', outcome: 'Passed' }],
-          },
-        },
-      ]);
-
-      const TicketsProviderMock: any = require('../../modules/TicketsDataProvider').default;
-      TicketsProviderMock.mockImplementationOnce(() => ({
-        GetQueryResultsFromWiql: jest.fn().mockResolvedValue({
-          fetchedWorkItems: [
-            {
-              id: 9001,
-              fields: {
-                'System.WorkItemType': 'Requirement',
-                'System.Title': 'Requirement from query',
-                'Custom.CustomerId': 'SR3001',
-                'System.AreaPath': 'MEWP\\IL',
-              },
-            },
-          ],
-        }),
-      }));
-
-      const result = await (resultDataProvider as any).getMewpL2CoverageFlatResults(
-        '123',
-        mockProjectName,
-        [1],
-        {
-          linkedQueryMode: 'query',
-          testAssociatedQuery: { wiql: { href: 'https://example.com/wiql' } },
-        }
-      );
-
-      const row = result.rows.find((item: any) => item['Customer ID'] === 'SR3001');
-      expect(row).toEqual(
-        expect.objectContaining({
-          'Title (Customer name)': 'Requirement from query',
-          'Responsibility - SAPWBS (ESUK/IL)': 'IL',
-          'Test case id': 101,
-          'Test case title': 'TC 101',
-          'Number of passed steps': 1,
-          'Number of failed steps': 0,
-          'Number of not run tests': 0,
-        })
-      );
-
-      expect(TicketsProviderMock).toHaveBeenCalled();
-      const instance = TicketsProviderMock.mock.results[0].value;
-      expect(instance.GetQueryResultsFromWiql).toHaveBeenCalledWith(
-        'https://example.com/wiql',
-        true,
-        expect.any(Map)
-      );
-    });
-
     it('should map SR ids from steps and output requirement-test-case coverage rows', async () => {
       jest.spyOn(resultDataProvider as any, 'fetchTestPlanName').mockResolvedValueOnce('Plan A');
       jest.spyOn(resultDataProvider as any, 'fetchTestSuites').mockResolvedValueOnce([{ testSuiteId: 1 }]);
@@ -1387,7 +1292,16 @@ describe('ResultDataProvider', () => {
         4321
       );
 
-      expect(requirementId).toBe('4321');
+      expect(requirementId).toBe('SR4321');
+    });
+
+    it('should derive responsibility from Custom.SAPWBS when present', () => {
+      const responsibility = (resultDataProvider as any).deriveMewpResponsibility({
+        'Custom.SAPWBS': 'IL',
+        'System.AreaPath': 'MEWP\\ESUK',
+      });
+
+      expect(responsibility).toBe('IL');
     });
   });