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

package/src/modules/ResultDataProvider.ts

@@ -29,6 +29,17 @@ const pLimit = require('p-limit');
  * Instantiate the class with the organization URL and token, and use the provided methods to fetch and process test data.
  */
 export default class ResultDataProvider {
+  private static readonly MEWP_L2_COVERAGE_COLUMNS = [
+    'Customer ID',
+    'Title (Customer name)',
+    'Responsibility - SAPWBS (ESUK/IL)',
+    'Test case id',
+    'Test case title',
+    'Number of passed steps',
+    'Number of failed steps',
+    'Number of not run tests',
+  ];
+
   orgUrl: string = '';
   token: string = '';
   private limit = pLimit(10);
@@ -375,6 +386,127 @@ export default class ResultDataProvider {
     }
   }
 
+  /**
+   * Builds MEWP L2 requirement coverage rows for audit reporting.
+   * Rows are one Requirement-TestCase pair; uncovered requirements are emitted with empty test-case columns.
+   */
+  public async getMewpL2CoverageFlatResults(
+    testPlanId: string,
+    projectName: string,
+    selectedSuiteIds: number[] | undefined,
+    linkedQueryRequest?: any
+  ) {
+    const defaultPayload = {
+      sheetName: `MEWP L2 Coverage - Plan ${testPlanId}`,
+      columnOrder: [...ResultDataProvider.MEWP_L2_COVERAGE_COLUMNS],
+      rows: [] as any[],
+    };
+
+    try {
+      const planName = await this.fetchTestPlanName(testPlanId, projectName);
+      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);
+      if (requirements.length === 0) {
+        return {
+          ...defaultPayload,
+          sheetName: this.buildMewpCoverageSheetName(planName, testPlanId),
+        };
+      }
+
+      const requirementIndex = new Map<string, Map<number, { passed: number; failed: number; notRun: number }>>();
+      const observedTestCaseIdsByRequirement = new Map<string, Set<number>>();
+      const requirementKeys = new Set<string>();
+      requirements.forEach((requirement) => {
+        const key = this.toRequirementKey(requirement.requirementId);
+        if (!key) return;
+        requirementKeys.add(key);
+      });
+
+      const parsedDefinitionStepsByTestCase = new Map<number, TestSteps[]>();
+      const testCaseStepsXmlMap = this.buildTestCaseStepsXmlMap(testData);
+      const testCaseTitleMap = this.buildMewpTestCaseTitleMap(testData);
+
+      const runResults = await this.fetchAllResultDataTestReporter(testData, projectName, [], false, false);
+      for (const runResult of runResults) {
+        const testCaseId = this.extractMewpTestCaseId(runResult);
+        const runTestCaseTitle = this.toMewpComparableText(
+          runResult?.testCase?.name || runResult?.testCaseName || runResult?.testCaseTitle
+        );
+        if (Number.isFinite(testCaseId) && testCaseId > 0 && runTestCaseTitle && !testCaseTitleMap.has(testCaseId)) {
+          testCaseTitleMap.set(testCaseId, runTestCaseTitle);
+        }
+        const actionResults = Array.isArray(runResult?.iteration?.actionResults)
+          ? runResult.iteration.actionResults
+          : [];
+        const hasExecutedRun =
+          Number(runResult?.lastRunId || 0) > 0 && Number(runResult?.lastResultId || 0) > 0;
+
+        if (actionResults.length > 0) {
+          for (const actionResult of actionResults) {
+            if (actionResult?.isSharedStepTitle) continue;
+            const stepStatus = this.classifyRequirementStepOutcome(actionResult?.outcome);
+            this.accumulateRequirementCountsFromStepText(
+              `${String(actionResult?.action || '')} ${String(actionResult?.expected || '')}`,
+              stepStatus,
+              testCaseId,
+              requirementKeys,
+              requirementIndex,
+              observedTestCaseIdsByRequirement
+            );
+          }
+          continue;
+        }
+
+        // Do not force "not run" from definition steps when a run exists:
+        // some runs may have missing/unmapped actionResults.
+        if (hasExecutedRun) {
+          continue;
+        }
+
+        if (!Number.isFinite(testCaseId)) continue;
+        if (!parsedDefinitionStepsByTestCase.has(testCaseId)) {
+          const stepsXml = testCaseStepsXmlMap.get(testCaseId) || '';
+          const parsed =
+            stepsXml && String(stepsXml).trim() !== ''
+              ? await this.testStepParserHelper.parseTestSteps(stepsXml, new Map<number, number>())
+              : [];
+          parsedDefinitionStepsByTestCase.set(testCaseId, parsed);
+        }
+
+        const definitionSteps = parsedDefinitionStepsByTestCase.get(testCaseId) || [];
+        for (const step of definitionSteps) {
+          if (step?.isSharedStepTitle) continue;
+          this.accumulateRequirementCountsFromStepText(
+            `${String(step?.action || '')} ${String(step?.expected || '')}`,
+            'notRun',
+            testCaseId,
+            requirementKeys,
+            requirementIndex,
+            observedTestCaseIdsByRequirement
+          );
+        }
+      }
+
+      const rows = this.buildMewpCoverageRows(
+        requirements,
+        requirementIndex,
+        observedTestCaseIdsByRequirement,
+        testCaseTitleMap
+      );
+
+      return {
+        sheetName: this.buildMewpCoverageSheetName(planName, testPlanId),
+        columnOrder: [...ResultDataProvider.MEWP_L2_COVERAGE_COLUMNS],
+        rows,
+      };
+    } catch (error: any) {
+      logger.error(`Error during getMewpL2CoverageFlatResults: ${error.message}`);
+      return defaultPayload;
+    }
+  }
+
   /**
    * Mapping each attachment to a proper URL for downloading it
    * @param runResults Array of run results
@@ -413,6 +545,690 @@ export default class ResultDataProvider {
     });
   }
 
+  private buildMewpCoverageSheetName(planName: string, testPlanId: string): string {
+    const suffix = String(planName || '').trim() || `Plan ${testPlanId}`;
+    return `MEWP L2 Coverage - ${suffix}`;
+  }
+
+  private createMewpCoverageRow(
+    requirement: {
+      requirementId: string;
+      title: string;
+      responsibility: string;
+    },
+    testCaseId: number | undefined,
+    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 safeTestCaseId = Number.isFinite(testCaseId) && Number(testCaseId) > 0 ? Number(testCaseId) : '';
+
+    return {
+      'Customer ID': customerId,
+      'Title (Customer name)': customerTitle,
+      'Responsibility - SAPWBS (ESUK/IL)': responsibility,
+      'Test case id': safeTestCaseId,
+      'Test case title': String(testCaseTitle || '').trim(),
+      'Number of passed steps': Number.isFinite(stepSummary?.passed) ? stepSummary.passed : 0,
+      'Number of failed steps': Number.isFinite(stepSummary?.failed) ? stepSummary.failed : 0,
+      'Number of not run tests': Number.isFinite(stepSummary?.notRun) ? stepSummary.notRun : 0,
+    };
+  }
+
+  private buildMewpCoverageRows(
+    requirements: Array<{
+      requirementId: string;
+      title: string;
+      responsibility: string;
+      linkedTestCaseIds: number[];
+    }>,
+    requirementIndex: Map<string, Map<number, { passed: number; failed: number; notRun: number }>>,
+    observedTestCaseIdsByRequirement: Map<string, Set<number>>,
+    testCaseTitleMap: Map<number, string>
+  ): any[] {
+    const rows: any[] = [];
+    for (const requirement of requirements) {
+      const key = this.toRequirementKey(requirement.requirementId);
+      const linkedTestCaseIds = (requirement?.linkedTestCaseIds || []).filter(
+        (id) => Number.isFinite(id) && Number(id) > 0
+      );
+      const observedTestCaseIds = key
+        ? Array.from(observedTestCaseIdsByRequirement.get(key) || [])
+        : [];
+
+      const testCaseIds = Array.from(new Set<number>([...linkedTestCaseIds, ...observedTestCaseIds])).sort(
+        (a, b) => a - b
+      );
+
+      if (testCaseIds.length === 0) {
+        rows.push(
+          this.createMewpCoverageRow(requirement, undefined, '', {
+            passed: 0,
+            failed: 0,
+            notRun: 0,
+          })
+        );
+        continue;
+      }
+
+      for (const testCaseId of testCaseIds) {
+        const summary = key
+          ? requirementIndex.get(key)?.get(testCaseId) || { passed: 0, failed: 0, notRun: 0 }
+          : { passed: 0, failed: 0, notRun: 0 };
+        rows.push(
+          this.createMewpCoverageRow(
+            requirement,
+            testCaseId,
+            String(testCaseTitleMap.get(testCaseId) || ''),
+            summary
+          )
+        );
+      }
+    }
+
+    return rows;
+  }
+
+  private buildMewpTestCaseTitleMap(testData: any[]): Map<number, string> {
+    const map = new Map<number, string>();
+
+    const readTitleFromWorkItemFields = (workItemFields: any): string => {
+      if (!Array.isArray(workItemFields)) return '';
+      for (const field of workItemFields) {
+        const keyCandidates = [field?.key, field?.name, field?.referenceName, field?.id]
+          .map((item) => String(item || '').toLowerCase().trim());
+        const isTitleField =
+          keyCandidates.includes('system.title') || keyCandidates.includes('title');
+        if (!isTitleField) continue;
+        const value = this.toMewpComparableText(field?.value);
+        if (value) return value;
+      }
+      return '';
+    };
+
+    for (const suite of testData || []) {
+      const testPointsItems = Array.isArray(suite?.testPointsItems) ? suite.testPointsItems : [];
+      for (const point of testPointsItems) {
+        const pointTestCaseId = Number(point?.testCaseId || point?.testCase?.id);
+        if (!Number.isFinite(pointTestCaseId) || pointTestCaseId <= 0 || map.has(pointTestCaseId)) continue;
+        const pointTitle = this.toMewpComparableText(point?.testCaseName || point?.testCase?.name);
+        if (pointTitle) map.set(pointTestCaseId, pointTitle);
+      }
+
+      const testCasesItems = Array.isArray(suite?.testCasesItems) ? suite.testCasesItems : [];
+      for (const testCase of testCasesItems) {
+        const id = Number(testCase?.workItem?.id || testCase?.testCaseId || testCase?.id);
+        if (!Number.isFinite(id) || id <= 0 || map.has(id)) continue;
+        const fromDirectFields = this.toMewpComparableText(
+          testCase?.testCaseName || testCase?.name || testCase?.workItem?.name
+        );
+        if (fromDirectFields) {
+          map.set(id, fromDirectFields);
+          continue;
+        }
+        const fromWorkItemField = readTitleFromWorkItemFields(testCase?.workItem?.workItemFields);
+        if (fromWorkItemField) {
+          map.set(id, fromWorkItemField);
+        }
+      }
+    }
+
+    return map;
+  }
+
+  private extractMewpTestCaseId(runResult: any): number {
+    const testCaseId = Number(runResult?.testCaseId || runResult?.testCase?.id || 0);
+    return Number.isFinite(testCaseId) ? testCaseId : 0;
+  }
+
+  private buildTestCaseStepsXmlMap(testData: any[]): Map<number, string> {
+    const map = new Map<number, string>();
+    for (const suite of testData || []) {
+      const testCasesItems = Array.isArray(suite?.testCasesItems) ? suite.testCasesItems : [];
+      for (const testCase of testCasesItems) {
+        const id = Number(testCase?.workItem?.id);
+        if (!Number.isFinite(id)) continue;
+        if (map.has(id)) continue;
+        const fields = testCase?.workItem?.workItemFields;
+        const stepsXml = this.extractStepsXmlFromWorkItemFields(fields);
+        if (stepsXml) {
+          map.set(id, stepsXml);
+        }
+      }
+    }
+    return map;
+  }
+
+  private extractStepsXmlFromWorkItemFields(workItemFields: any): string {
+    if (!Array.isArray(workItemFields)) return '';
+    const isStepsKey = (name: string) => {
+      const normalized = String(name || '').toLowerCase().trim();
+      return normalized === 'steps' || normalized === 'microsoft.vsts.tcm.steps';
+    };
+
+    for (const field of workItemFields) {
+      const keyCandidates = [field?.key, field?.name, field?.referenceName, field?.id];
+      const hasStepsKey = keyCandidates.some((candidate) => isStepsKey(String(candidate || '')));
+      if (!hasStepsKey) continue;
+      const value = String(field?.value || '').trim();
+      if (value) return value;
+    }
+
+    return '';
+  }
+
+  private classifyRequirementStepOutcome(outcome: any): 'passed' | 'failed' | 'notRun' {
+    const normalized = String(outcome || '')
+      .trim()
+      .toLowerCase();
+    if (normalized === 'passed') return 'passed';
+    if (normalized === 'failed') return 'failed';
+    return 'notRun';
+  }
+
+  private accumulateRequirementCountsFromStepText(
+    stepText: string,
+    status: 'passed' | 'failed' | 'notRun',
+    testCaseId: number,
+    requirementKeys: Set<string>,
+    counters: Map<string, Map<number, { passed: number; failed: number; notRun: number }>>,
+    observedTestCaseIdsByRequirement: Map<string, Set<number>>
+  ) {
+    if (!Number.isFinite(testCaseId) || testCaseId <= 0) return;
+
+    const codes = this.extractRequirementCodesFromText(stepText);
+    for (const code of codes) {
+      if (requirementKeys.size > 0 && !requirementKeys.has(code)) continue;
+      if (!counters.has(code)) {
+        counters.set(code, new Map<number, { passed: number; failed: number; notRun: number }>());
+      }
+      const perTestCaseCounters = counters.get(code)!;
+      if (!perTestCaseCounters.has(testCaseId)) {
+        perTestCaseCounters.set(testCaseId, { passed: 0, failed: 0, notRun: 0 });
+      }
+
+      if (!observedTestCaseIdsByRequirement.has(code)) {
+        observedTestCaseIdsByRequirement.set(code, new Set<number>());
+      }
+      observedTestCaseIdsByRequirement.get(code)!.add(testCaseId);
+
+      const counter = perTestCaseCounters.get(testCaseId)!;
+      if (status === 'passed') counter.passed += 1;
+      else if (status === 'failed') counter.failed += 1;
+      else counter.notRun += 1;
+    }
+  }
+
+  private extractRequirementCodesFromText(text: string): Set<string> {
+    const out = new Set<string>();
+    const source = this.normalizeRequirementStepText(text);
+    // Supports SR<ID> patterns even when HTML formatting breaks the token,
+    // e.g. "S<b>R</b> 0 0 1" or "S R 0 0 1".
+    const regex = /S[\s\u00A0]*R(?:[\s\u00A0\-_]*\d){1,12}/gi;
+    let match: RegExpExecArray | null = null;
+    while ((match = regex.exec(source)) !== null) {
+      const digitsOnly = String(match[0] || '').replace(/\D/g, '');
+      const digits = Number.parseInt(digitsOnly, 10);
+      if (Number.isFinite(digits)) {
+        out.add(`SR${digits}`);
+      }
+    }
+    return out;
+  }
+
+  private normalizeRequirementStepText(text: string): string {
+    const raw = String(text || '');
+    if (!raw) return '';
+
+    return raw
+      .replace(/&nbsp;|&#160;|&#xA0;/gi, ' ')
+      .replace(/&lt;/gi, '<')
+      .replace(/&gt;/gi, '>')
+      .replace(/&amp;/gi, '&')
+      .replace(/&quot;/gi, '"')
+      .replace(/&#39;|&apos;/gi, "'")
+      .replace(/<[^>]*>/g, ' ')
+      .replace(/[\u200B-\u200D\uFEFF]/g, '')
+      .replace(/\s+/g, ' ');
+  }
+
+  private toRequirementKey(requirementId: string): string {
+    const normalized = this.normalizeMewpRequirementCode(requirementId);
+    if (!normalized) return '';
+    const digits = Number.parseInt(normalized.replace(/^SR/i, ''), 10);
+    if (!Number.isFinite(digits)) return '';
+    return `SR${digits}`;
+  }
+
+  private async fetchMewpL2Requirements(projectName: string, linkedQueryRequest?: any): Promise<
+    Array<{
+      workItemId: number;
+      requirementId: string;
+      title: string;
+      responsibility: string;
+      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 [];
+    }
+
+    const quotedTypeNames = workItemTypeNames
+      .map((name) => `'${String(name).replace(/'/g, "''")}'`)
+      .join(', ');
+    const wiql = `SELECT [System.Id]
+FROM WorkItems
+WHERE [System.TeamProject] = @project
+  AND [System.WorkItemType] IN (${quotedTypeNames})
+ORDER BY [System.Id]`;
+    const wiqlUrl = `${this.orgUrl}${projectName}/_apis/wit/wiql?api-version=7.1-preview.2`;
+    const wiqlResponse = await TFSServices.postRequest(wiqlUrl, this.token, 'Post', { query: wiql }, null);
+    const workItemRefs = Array.isArray(wiqlResponse?.data?.workItems) ? wiqlResponse.data.workItems : [];
+    const requirementIds = workItemRefs
+      .map((item: any) => Number(item?.id))
+      .filter((id: number) => Number.isFinite(id));
+
+    if (requirementIds.length === 0) {
+      return [];
+    }
+
+    const workItems = await this.fetchWorkItemsByIds(projectName, requirementIds, true);
+    const requirements = workItems.map((wi: any) => {
+      const fields = wi?.fields || {};
+      return {
+        workItemId: Number(wi?.id || 0),
+        requirementId: this.extractMewpRequirementIdentifier(fields, Number(wi?.id || 0)),
+        title: String(fields['System.Title'] || ''),
+        responsibility: this.deriveMewpResponsibility(fields),
+        linkedTestCaseIds: this.extractLinkedTestCaseIdsFromRequirement(wi?.relations || []),
+      };
+    });
+
+    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`;
+      const result = await TFSServices.getItemContent(url, this.token);
+      const values = Array.isArray(result?.value) ? result.value : [];
+      const matched = values
+        .map((item: any) => String(item?.name || ''))
+        .filter((name: string) => /requirement/i.test(name) || /^epic$/i.test(name));
+      const unique = Array.from(new Set<string>(matched));
+      if (unique.length > 0) {
+        return unique;
+      }
+    } catch (error: any) {
+      logger.debug(`Could not fetch MEWP work item types, using defaults: ${error?.message || error}`);
+    }
+
+    return ['Requirement', 'Epic'];
+  }
+
+  private async fetchWorkItemsByIds(
+    projectName: string,
+    workItemIds: number[],
+    includeRelations: boolean
+  ): Promise<any[]> {
+    const ids = [...new Set(workItemIds.filter((id) => Number.isFinite(id)))];
+    if (ids.length === 0) return [];
+
+    const CHUNK_SIZE = 200;
+    const allItems: any[] = [];
+
+    for (let i = 0; i < ids.length; i += CHUNK_SIZE) {
+      const chunk = ids.slice(i, i + CHUNK_SIZE);
+      const idsQuery = chunk.join(',');
+      const expandParam = includeRelations ? '&$expand=relations' : '';
+      const url = `${this.orgUrl}${projectName}/_apis/wit/workitems?ids=${idsQuery}${expandParam}&api-version=7.1-preview.3`;
+      const response = await TFSServices.getItemContent(url, this.token);
+      const values = Array.isArray(response?.value) ? response.value : [];
+      allItems.push(...values);
+    }
+
+    return allItems;
+  }
+
+  private extractLinkedTestCaseIdsFromRequirement(relations: any[]): number[] {
+    const out = new Set<number>();
+    for (const relation of Array.isArray(relations) ? relations : []) {
+      const rel = String(relation?.rel || '')
+        .trim()
+        .toLowerCase();
+      const isRequirementToTestLink = rel.includes('testedby') || rel.includes('.tests');
+      if (!isRequirementToTestLink) continue;
+
+      const url = String(relation?.url || '');
+      const match = /\/workItems\/(\d+)/i.exec(url);
+      if (!match) continue;
+      const id = Number(match[1]);
+      if (Number.isFinite(id)) out.add(id);
+    }
+    return [...out].sort((a, b) => a - b);
+  }
+
+  private extractMewpRequirementIdentifier(fields: Record<string, any>, fallbackWorkItemId: number): string {
+    const entries = Object.entries(fields || {});
+
+    // First pass: only trusted identifier-like fields.
+    const strictHints = [
+      'customerid',
+      'customer id',
+      'customerrequirementid',
+      'requirementid',
+      'externalid',
+      'srid',
+      'sapwbsid',
+    ];
+    for (const [key, value] of entries) {
+      const normalizedKey = String(key || '').toLowerCase();
+      if (!strictHints.some((hint) => normalizedKey.includes(hint))) continue;
+
+      const valueAsString = this.toMewpComparableText(value);
+      if (!valueAsString) continue;
+      const normalized = this.normalizeMewpRequirementCode(valueAsString);
+      if (normalized) return normalized;
+    }
+
+    // Second pass: weaker hints, but still key-based only.
+    const looseHints = ['customer', 'requirement', 'external', 'sapwbs', 'sr'];
+    for (const [key, value] of entries) {
+      const normalizedKey = String(key || '').toLowerCase();
+      if (!looseHints.some((hint) => normalizedKey.includes(hint))) continue;
+
+      const valueAsString = this.toMewpComparableText(value);
+      if (!valueAsString) continue;
+      const normalized = this.normalizeMewpRequirementCode(valueAsString);
+      if (normalized) return normalized;
+    }
+
+    // Optional fallback from title only (avoid scanning all fields and accidental SR matches).
+    const title = this.toMewpComparableText(fields?.['System.Title']);
+    const titleCode = this.normalizeMewpRequirementCode(title);
+    if (titleCode) return titleCode;
+
+    return String(fallbackWorkItemId || '');
+  }
+
+  private deriveMewpResponsibility(fields: Record<string, any>): string {
+    const areaPath = this.toMewpComparableText(fields?.['System.AreaPath']);
+    const fromAreaPath = this.resolveMewpResponsibility(areaPath);
+    if (fromAreaPath) return fromAreaPath;
+
+    const keyHints = ['sapwbs', 'responsibility', 'owner'];
+    for (const [key, value] of Object.entries(fields || {})) {
+      const normalizedKey = String(key || '').toLowerCase();
+      if (!keyHints.some((hint) => normalizedKey.includes(hint))) continue;
+      const resolved = this.resolveMewpResponsibility(this.toMewpComparableText(value));
+      if (resolved) return resolved;
+    }
+
+    return '';
+  }
+
+  private resolveMewpResponsibility(value: string): string {
+    const text = String(value || '')
+      .trim()
+      .toLowerCase();
+    if (!text) return '';
+
+    if (/(^|[^a-z0-9])esuk([^a-z0-9]|$)/i.test(text)) return 'ESUK';
+    if (/(^|[^a-z0-9])il([^a-z0-9]|$)/i.test(text)) return 'IL';
+    return '';
+  }
+
+  private normalizeMewpRequirementCode(value: string): string {
+    const text = String(value || '').trim();
+    if (!text) return '';
+    const match = /\bSR[\s\-_]*([0-9]+)\b/i.exec(text);
+    if (!match) return '';
+    return `SR${match[1]}`;
+  }
+
+  private toMewpComparableText(value: any): string {
+    if (value === null || value === undefined) return '';
+    if (typeof value === 'string' || typeof value === 'number' || typeof value === 'boolean') {
+      return String(value).trim();
+    }
+    if (typeof value === 'object') {
+      const displayName = (value as any).displayName;
+      if (displayName) return String(displayName).trim();
+      const name = (value as any).name;
+      if (name) return String(name).trim();
+      const uniqueName = (value as any).uniqueName;
+      if (uniqueName) return String(uniqueName).trim();
+    }
+    return String(value).trim();
+  }
+
   private async fetchTestPlanName(testPlanId: string, teamProject: string): Promise<string> {
     try {
       const url = `${this.orgUrl}${teamProject}/_apis/testplan/Plans/${testPlanId}?api-version=5.1`;
@@ -1880,13 +2696,22 @@ export default class ResultDataProvider {
         ...additionalArgs
       );
 
-      const iteration =
+      let iteration =
         resultData.iterationDetails?.length > 0
           ? resultData.iterationDetails[resultData.iterationDetails.length - 1]
           : undefined;
 
+      if (resultData.stepsResultXml && !iteration) {
+        iteration = { actionResults: [] };
+        if (!Array.isArray(resultData.iterationDetails)) {
+          resultData.iterationDetails = [];
+        }
+        resultData.iterationDetails.push(iteration);
+      }
+
       if (resultData.stepsResultXml && iteration) {
-        const actionResultsWithSharedModels = iteration.actionResults.filter(
+        const actionResults = Array.isArray(iteration.actionResults) ? iteration.actionResults : [];
+        const actionResultsWithSharedModels = actionResults.filter(
           (result: any) => result.sharedStepModel
         );
 
@@ -1910,7 +2735,7 @@ export default class ResultDataProvider {
           stepMap.set(step.stepId.toString(), step);
         }
 
-        for (const actionResult of iteration.actionResults) {
+        for (const actionResult of actionResults) {
           const step = stepMap.get(actionResult.stepIdentifier);
           if (step) {
             actionResult.stepPosition = step.stepPosition;
@@ -1919,10 +2744,28 @@ export default class ResultDataProvider {
             actionResult.isSharedStepTitle = step.isSharedStepTitle;
           }
         }
-        //Sort by step position
-        iteration.actionResults = iteration.actionResults
-          .filter((result: any) => result.stepPosition)
-          .sort((a: any, b: any) => this.compareActionResults(a.stepPosition, b.stepPosition));
+
+        if (actionResults.length > 0) {
+          // Sort mapped action results by logical step position.
+          iteration.actionResults = actionResults
+            .filter((result: any) => result.stepPosition)
+            .sort((a: any, b: any) => this.compareActionResults(a.stepPosition, b.stepPosition));
+        } else {
+          // Fallback for runs that have no action results: emit test definition steps as Not Run.
+          iteration.actionResults = stepsList
+            .filter((step: any) => step?.stepPosition)
+            .map((step: any) => ({
+              stepIdentifier: String(step?.stepId ?? step?.stepPosition ?? ''),
+              stepPosition: step.stepPosition,
+              action: step.action,
+              expected: step.expected,
+              isSharedStepTitle: step.isSharedStepTitle,
+              outcome: 'Unspecified',
+              errorMessage: '',
+              actionPath: String(step?.stepPosition ?? ''),
+            }))
+            .sort((a: any, b: any) => this.compareActionResults(a.stepPosition, b.stepPosition));
+        }
       }
 
       return resultData?.testCase