@elisra-devops/docgen-data-provider 1.109.0 → 1.110.0

package/src/modules/TicketsDataProvider.ts

@@ -78,7 +78,7 @@ const HISTORICAL_WORK_ITEM_FIELDS = [
 
 /** Default fields fetched per work item in tree/flat query parsing. */
 const WI_DEFAULT_FIELDS =
-  'System.Description,System.Title,Microsoft.VSTS.TCM.ReproSteps,Microsoft.VSTS.CMMI.Symptom';
+  'System.Description,System.Title,System.WorkItemType,Microsoft.VSTS.TCM.ReproSteps,Microsoft.VSTS.CMMI.Symptom';
 
 export default class TicketsDataProvider {
   orgUrl: string = '';
@@ -666,6 +666,83 @@ export default class TicketsDataProvider {
     return { systemRequirementsQueryTree };
   }
 
+  /**
+   * Fetches flat Customer/System requirement queries for SysRS traceability.
+   * OneHop/tree queries are intentionally excluded for this picker.
+   */
+  private async fetchFlatUpstreamQueries(
+    queries: any,
+    excludedFolderNames: string[] = [],
+    allowedTypes: string[] = ['requirement'],
+  ) {
+    const { tree1: systemRequirementsQueryTree } = await this.structureFetchedQueries(
+      queries,
+      false,
+      null,
+      allowedTypes,
+      [],
+      undefined,
+      undefined,
+      false,
+      excludedFolderNames,
+      true,
+      false,
+    );
+    return { systemRequirementsQueryTree };
+  }
+
+  private async fetchCustomerRequirementQueries(queries: any) {
+    const systemRequirementsQueryTree = await this.structureCustomerRequirementQueries(queries);
+    return { systemRequirementsQueryTree };
+  }
+
+  private async structureCustomerRequirementQueries(
+    rootQuery: any,
+    parentId: any = null,
+  ): Promise<any> {
+    try {
+      if (!rootQuery?.hasChildren) {
+        const isExecutableQuery =
+          !rootQuery?.isFolder && ['flat', 'tree', 'oneHop'].includes(rootQuery?.queryType);
+        return isExecutableQuery ? this.buildQueryNode(rootQuery, parentId) : null;
+      }
+
+      if (!rootQuery.children) {
+        const queryUrl = `${rootQuery.url}?$depth=2&$expand=all`;
+        const currentQuery = await TFSServices.getItemContent(queryUrl, this.token);
+        if (!currentQuery) {
+          return null;
+        }
+        return await this.structureCustomerRequirementQueries(currentQuery, currentQuery.id);
+      }
+
+      const childResults = await Promise.all(
+        rootQuery.children.map((child: any) =>
+          this.structureCustomerRequirementQueries(child, rootQuery.id),
+        ),
+      );
+      const children = childResults.filter((child: any) => child !== null);
+
+      return children.length > 0
+        ? {
+            id: rootQuery.id,
+            pId: parentId,
+            value: rootQuery.name,
+            title: rootQuery.name,
+            children,
+          }
+        : null;
+    } catch (err: any) {
+      logger.error(
+        `Error occurred while constructing the customer query list ${err.message} with query ${JSON.stringify(
+          rootQuery,
+        )}`,
+      );
+      logger.error(`Error stack ${err.message}`);
+      return null;
+    }
+  }
+
   private async fetchSrsQueries(rootQueries: any) {
     const srsFolder = await this.findQueryFolderByName(rootQueries, 'srs');
     if (!srsFolder) {
@@ -710,32 +787,42 @@ export default class TicketsDataProvider {
     const { root: sysRsRoot, found: sysRsRootFound } = await this.getDocTypeRoot(rootQueries, 'sysrs');
     logger.debug(`[GetSharedQueries][sysrs] using ${sysRsRootFound ? 'dedicated folder' : 'root queries'}`);
 
-    const systemRequirementsQueries = await this.fetchSystemRequirementQueries(sysRsRoot, [
-      'System To Customer',
-      'System To Subsystem',
-    ]);
+    const systemToSubsystemFolderNames = ['system to subsystem', 'system-to-subsystem', 'system subsystem'];
 
-    const systemToCustomerFolder = await this.findChildFolderByPossibleNames(sysRsRoot, [
-      'system to customer',
-      'system-to-customer',
-      'system customer',
-      'subsystem to system',
-      'customer to system',
-    ]);
-    const systemToSubsystemFolder = await this.findChildFolderByPossibleNames(sysRsRoot, [
-      'system to subsystem',
-      'system-to-subsystem',
-      'system subsystem',
-    ]);
+    const systemRequirementsQueries = await this.fetchSystemRequirementQueries(
+      sysRsRoot,
+      systemToSubsystemFolderNames,
+    );
 
-    const subsystemToSystemRequirementsQueries =
-      await this.fetchRequirementsTraceQueriesForFolder(systemToCustomerFolder);
+    const systemToSubsystemFolder = await this.findChildFolderByPossibleNames(
+      sysRsRoot,
+      systemToSubsystemFolderNames,
+    );
     const systemToSubsystemRequirementsQueries =
       await this.fetchRequirementsTraceQueriesForFolder(systemToSubsystemFolder);
 
+    // Customer/System requirements (traceability table) picker: scan the entire
+    // dedicated SysRS folder for executable query nodes. The selected query
+    // defines the customer-side candidate set, so discovery does not infer
+    // "customer" semantics from WIQL. Scope is intentionally limited to the
+    // dedicated `sysrs` folder so unrelated queries from the Shared Queries root
+    // do not leak into the picker.
+    let customerRequirementsQueries: any = null;
+    if (sysRsRootFound) {
+      customerRequirementsQueries = await this.fetchCustomerRequirementQueries(sysRsRoot);
+    } else {
+      logger.debug(
+        '[GetSharedQueries][sysrs] dedicated sysrs folder not found; skipping customer-requirements picker',
+      );
+    }
+
     return {
       systemRequirementsQueries,
-      subsystemToSystemRequirementsQueries,
+      customerRequirementsQueries,
+      // Legacy field retained for backward compatibility with callers/tests.
+      // The sub-system -> system trace table is out of scope for v0 and no
+      // longer sourced from a hardcoded "System to Customer" folder.
+      subsystemToSystemRequirementsQueries: null,
       systemToSubsystemRequirementsQueries,
     };
   }
@@ -2208,42 +2295,46 @@ export default class TicketsDataProvider {
   }
 
   async PopulateWorkItemsByIds(workItemsArray: any[] = [], projectName: string = ''): Promise<any[]> {
-    let url = `${this.orgUrl}${projectName}/_apis/wit/workitemsbatch`;
-    let res: any[] = [];
-    let divByMax = Math.floor(workItemsArray.length / 200);
-    let modulusByMax = workItemsArray.length % 200;
-    //iterating
-    for (let i = 0; i < divByMax; i++) {
-      let from = i * 200;
-      let to = (i + 1) * 200;
-      let currentIds = workItemsArray.slice(from, to);
-      try {
-        let subRes = await TFSServices.getItemContent(url, this.token, 'post', {
+    const baseUrl = `${this.orgUrl}${projectName}/_apis/wit/workitemsbatch`;
+    // On-prem Azure DevOps Server rejects this POST with HTTP 400 unless an
+    // api-version is explicitly set on the URL. Use the same fallback chain
+    // (7.1 -> 5.1 -> no version) the historical batch hydration already uses,
+    // so the helper stays compatible with ADO cloud and older on-prem tenants.
+    const postBatch = (currentIds: any[]) =>
+      this.withHistoricalApiVersionFallback('populate-workitems-batch', (apiVersion) =>
+        TFSServices.getItemContent(this.appendApiVersion(baseUrl, apiVersion), this.token, 'post', {
           $expand: 'Relations',
           ids: currentIds,
-        });
-        res = [...res, ...subRes.value];
+        }),
+      ).then(({ result }) => result);
+
+    const res: any[] = [];
+    const divByMax = Math.floor(workItemsArray.length / 200);
+    const modulusByMax = workItemsArray.length % 200;
+    for (let i = 0; i < divByMax; i++) {
+      const from = i * 200;
+      const to = (i + 1) * 200;
+      const currentIds = workItemsArray.slice(from, to);
+      try {
+        const subRes = await postBatch(currentIds);
+        res.push(...subRes.value);
       } catch (error) {
         logger.error(`error populating workitems array`);
         logger.error(JSON.stringify(error));
         return [];
       }
     }
-    //compliting the rimainder
     if (modulusByMax !== 0) {
       try {
-        let currentIds = workItemsArray.slice(workItemsArray.length - modulusByMax, workItemsArray.length);
-        let subRes = await TFSServices.getItemContent(url, this.token, 'post', {
-          $expand: 'Relations',
-          ids: currentIds,
-        });
-        res = [...res, ...subRes.value];
+        const currentIds = workItemsArray.slice(workItemsArray.length - modulusByMax, workItemsArray.length);
+        const subRes = await postBatch(currentIds);
+        res.push(...subRes.value);
       } catch (error) {
         logger.error(`error populating workitems array`);
         logger.error(JSON.stringify(error));
         return [];
       }
-    } //if
+    }
 
     return res;
   }
@@ -2494,7 +2585,7 @@ export default class TicketsDataProvider {
    * Recursively structures fetched queries into two hierarchical trees (tree1 and tree2)
    * by matching WIQL against allowed Source/Target types and optional area filters.
    * Supports leaf queries of type:
-   * - oneHop (always)
+   * - oneHop (when includeOneHopQueries === true)
    * - tree (when includeTreeQueries === true)
    * - flat (when includeFlatQueries === true)
    *
@@ -2508,6 +2599,7 @@ export default class TicketsDataProvider {
    * @param includeTreeQueries - Include 'tree' queries in addition to 'oneHop'. Defaults to `false`.
    * @param excludedFolderNames - Optional list of folder names to skip entirely (case-insensitive exact match).
    * @param includeFlatQueries - Include 'flat' queries (matched by [System.WorkItemType] and [System.AreaPath]). Defaults to `false`.
+   * @param includeOneHopQueries - Include 'oneHop' queries. Defaults to `true` for legacy callers.
    * @returns A promise resolving to an object with `tree1` and `tree2` nodes, or `null` for each when none match.
    * @throws Logs an error if an exception occurs during processing.
    */
@@ -2522,6 +2614,7 @@ export default class TicketsDataProvider {
     includeTreeQueries: boolean = false,
     excludedFolderNames: string[] = [],
     includeFlatQueries: boolean = false,
+    includeOneHopQueries: boolean = true,
     workItemTypeCache?: Map<string, string | null>,
   ): Promise<any> {
     try {
@@ -2540,7 +2633,7 @@ export default class TicketsDataProvider {
       if (!rootQuery.hasChildren) {
         const isLeafCandidate =
           !rootQuery.isFolder &&
-          (rootQuery.queryType === 'oneHop' ||
+          ((includeOneHopQueries && rootQuery.queryType === 'oneHop') ||
             (includeTreeQueries && rootQuery.queryType === 'tree') ||
             (includeFlatQueries && rootQuery.queryType === 'flat'));
         if (isLeafCandidate) {
@@ -2636,6 +2729,7 @@ export default class TicketsDataProvider {
           includeTreeQueries,
           excludedFolderNames,
           includeFlatQueries,
+          includeOneHopQueries,
           typeCache,
         );
       }
@@ -2654,6 +2748,7 @@ export default class TicketsDataProvider {
             includeTreeQueries,
             excludedFolderNames,
             includeFlatQueries,
+            includeOneHopQueries,
             typeCache,
           ),
         ),

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

@@ -93,11 +93,179 @@ describe('TicketsDataProvider', () => {
     });
   });
 
+  describe('fetchFlatUpstreamQueries', () => {
+    it('should allow only Requirement flat queries and exclude oneHop/tree query types', async () => {
+      const structureSpy = jest
+        .spyOn(ticketsDataProvider as any, 'structureFetchedQueries')
+        .mockResolvedValue({ tree1: { id: 't1' }, tree2: null });
+
+      await (ticketsDataProvider as any).fetchFlatUpstreamQueries({ hasChildren: false }, []);
+
+      expect(structureSpy.mock.calls[0][3]).toEqual(['requirement']);
+      expect(structureSpy.mock.calls[0][7]).toBe(false);
+      expect(structureSpy.mock.calls[0][9]).toBe(true);
+      expect(structureSpy.mock.calls[0][10]).toBe(false);
+    });
+
+    it('should allow Requirement flat queries for fallback discovery', async () => {
+      const structureSpy = jest
+        .spyOn(ticketsDataProvider as any, 'structureFetchedQueries')
+        .mockResolvedValue({ tree1: { id: 't1' }, tree2: null });
+
+      await (ticketsDataProvider as any).fetchFlatUpstreamQueries(
+        { hasChildren: false },
+        ['system to subsystem', 'system-to-subsystem', 'system subsystem'],
+        ['requirement'],
+      );
+
+      expect(structureSpy.mock.calls[0][3]).toEqual(['requirement']);
+      expect(structureSpy.mock.calls[0][8]).toEqual([
+        'system to subsystem',
+        'system-to-subsystem',
+        'system subsystem',
+      ]);
+      expect(structureSpy.mock.calls[0][9]).toBe(true);
+      expect(structureSpy.mock.calls[0][10]).toBe(false);
+    });
+
+    it('should let structureFetchedQueries exclude oneHop leaves only for flat-only callers', async () => {
+      const result = await (ticketsDataProvider as any).structureFetchedQueries(
+        {
+          id: 'one-hop',
+          hasChildren: false,
+          isFolder: false,
+          queryType: 'oneHop',
+          wiql: "[Source].[System.WorkItemType] = 'Requirement'",
+        },
+        false,
+        null,
+        ['requirement'],
+        [],
+        undefined,
+        undefined,
+        false,
+        [],
+        true,
+        false,
+      );
+
+      expect(result).toEqual({ tree1: null, tree2: null });
+    });
+  });
+
+  describe('fetchCustomerRequirementQueries', () => {
+    it('should return flat, tree, and oneHop query nodes without WIQL type filtering', async () => {
+      const root = {
+        id: 'root',
+        name: 'SYSRS',
+        isFolder: true,
+        hasChildren: true,
+        children: [
+          {
+            id: 'flat-query',
+            name: 'Flat Customer Pull',
+            isFolder: false,
+            hasChildren: false,
+            queryType: 'flat',
+            wiql: "SELECT * FROM WorkItems WHERE [System.WorkItemType] = 'Task'",
+            columns: [],
+            _links: { wiql: { href: 'flat-url' } },
+          },
+          {
+            id: 'tree-query',
+            name: 'Tree Customer Pull',
+            isFolder: false,
+            hasChildren: false,
+            queryType: 'tree',
+            wiql: "SELECT * FROM WorkItemLinks WHERE [System.Links.LinkType] = 'System.LinkTypes.Hierarchy-Forward'",
+            columns: [],
+            _links: { wiql: { href: 'tree-url' } },
+          },
+          {
+            id: 'onehop-query',
+            name: 'OneHop Customer Pull',
+            isFolder: false,
+            hasChildren: false,
+            queryType: 'oneHop',
+            wiql: "SELECT * FROM WorkItemLinks WHERE [System.Links.LinkType] = 'System.LinkTypes.Related'",
+            columns: [],
+            _links: { wiql: { href: 'onehop-url' } },
+          },
+          {
+            id: 'unsupported-query',
+            name: 'Unsupported',
+            isFolder: false,
+            hasChildren: false,
+            queryType: 'invalid',
+            _links: { wiql: { href: 'unsupported-url' } },
+          },
+        ],
+      };
+
+      const result = await (ticketsDataProvider as any).fetchCustomerRequirementQueries(root, []);
+
+      expect(result.systemRequirementsQueryTree.children.map((child: any) => child.queryType)).toEqual([
+        'flat',
+        'tree',
+        'oneHop',
+      ]);
+      expect(result.systemRequirementsQueryTree.children.map((child: any) => child.wiql.href)).toEqual([
+        'flat-url',
+        'tree-url',
+        'onehop-url',
+      ]);
+    });
+
+    it('should include system-to-subsystem queries because customer discovery has no folder exclusions', async () => {
+      const root = {
+        id: 'root',
+        name: 'SYSRS',
+        isFolder: true,
+        hasChildren: true,
+        children: [
+          {
+            id: 'excluded-folder',
+            name: 'System To Subsystem',
+            isFolder: true,
+            hasChildren: true,
+            children: [
+              {
+                id: 'system-to-subsystem-query',
+                name: 'System To Subsystem Query',
+                isFolder: false,
+                hasChildren: false,
+                queryType: 'tree',
+                _links: { wiql: { href: 'system-to-subsystem-url' } },
+              },
+            ],
+          },
+          {
+            id: 'included-query',
+            name: 'Included Query',
+            isFolder: false,
+            hasChildren: false,
+            queryType: 'oneHop',
+            _links: { wiql: { href: 'included-url' } },
+          },
+        ],
+      };
+
+      const result = await (ticketsDataProvider as any).fetchCustomerRequirementQueries(root);
+
+      expect(result.systemRequirementsQueryTree.children).toHaveLength(2);
+      expect(result.systemRequirementsQueryTree.children[0].children[0]).toEqual(
+        expect.objectContaining({ id: 'system-to-subsystem-query', queryType: 'tree' }),
+      );
+      expect(result.systemRequirementsQueryTree.children[1]).toEqual(
+        expect.objectContaining({ id: 'included-query', queryType: 'oneHop' }),
+      );
+    });
+  });
+
   describe('fetchSysRsQueries', () => {
-    it('should use sysrs root, exclude trace folders from system requirements and resolve both trace directions', async () => {
+    it('should scan the dedicated sysrs folder for customer queries regardless of query type', async () => {
       const rootQueries = { id: 'root' };
       const sysRsRoot = { id: 'sysrs-root', name: 'SYSRS' };
-      const subsystemToSystemFolder = { id: 'fwd-folder', name: 'System To Customer' };
       const systemToSubsystemFolder = { id: 'rev-folder', name: 'System To Subsystem' };
 
       const getDocTypeRootSpy = jest
@@ -106,45 +274,49 @@ describe('TicketsDataProvider', () => {
       const fetchSystemRequirementQueriesSpy = jest
         .spyOn(ticketsDataProvider as any, 'fetchSystemRequirementQueries')
         .mockResolvedValue({ systemRequirementsQueryTree: { id: 'system-tree' } });
+      const fetchCustomerRequirementQueriesSpy = jest
+        .spyOn(ticketsDataProvider as any, 'fetchCustomerRequirementQueries')
+        .mockResolvedValue({ systemRequirementsQueryTree: { id: 'customer-tree' } });
       const findChildFolderByPossibleNamesSpy = jest
         .spyOn(ticketsDataProvider as any, 'findChildFolderByPossibleNames')
-        .mockResolvedValueOnce(subsystemToSystemFolder)
         .mockResolvedValueOnce(systemToSubsystemFolder);
       const fetchRequirementsTraceQueriesForFolderSpy = jest
         .spyOn(ticketsDataProvider as any, 'fetchRequirementsTraceQueriesForFolder')
-        .mockResolvedValueOnce({ id: 'fwd-trace-tree' })
         .mockResolvedValueOnce({ id: 'rev-trace-tree' });
 
       const result = await (ticketsDataProvider as any).fetchSysRsQueries(rootQueries);
 
       expect(getDocTypeRootSpy).toHaveBeenCalledWith(rootQueries, 'sysrs');
+      // fetchSystemRequirementQueries only excludes the sub-system trace folder;
+      // the legacy System-to-Customer exclusion list is gone.
       expect(fetchSystemRequirementQueriesSpy).toHaveBeenCalledWith(sysRsRoot, [
-        'System To Customer',
-        'System To Subsystem',
+        'system to subsystem',
+        'system-to-subsystem',
+        'system subsystem',
       ]);
 
-      expect(findChildFolderByPossibleNamesSpy).toHaveBeenNthCalledWith(
-        1,
-        sysRsRoot,
-        expect.arrayContaining(['system to customer', 'subsystem to system', 'customer to system']),
-      );
-      expect(findChildFolderByPossibleNamesSpy).toHaveBeenNthCalledWith(
-        2,
+      // Only one folder lookup remains (sub-system trace); no System-to-Customer lookup.
+      expect(findChildFolderByPossibleNamesSpy).toHaveBeenCalledTimes(1);
+      expect(findChildFolderByPossibleNamesSpy).toHaveBeenCalledWith(
         sysRsRoot,
         expect.arrayContaining(['system to subsystem', 'system-to-subsystem']),
       );
 
-      expect(fetchRequirementsTraceQueriesForFolderSpy).toHaveBeenNthCalledWith(1, subsystemToSystemFolder);
-      expect(fetchRequirementsTraceQueriesForFolderSpy).toHaveBeenNthCalledWith(2, systemToSubsystemFolder);
+      expect(fetchRequirementsTraceQueriesForFolderSpy).toHaveBeenCalledTimes(1);
+      expect(fetchRequirementsTraceQueriesForFolderSpy).toHaveBeenCalledWith(systemToSubsystemFolder);
+
+      // Customer picker scans the whole sysRsRoot with no query/folder exclusions.
+      expect(fetchCustomerRequirementQueriesSpy).toHaveBeenCalledWith(sysRsRoot);
 
       expect(result).toEqual({
         systemRequirementsQueries: { systemRequirementsQueryTree: { id: 'system-tree' } },
-        subsystemToSystemRequirementsQueries: { id: 'fwd-trace-tree' },
+        customerRequirementsQueries: { systemRequirementsQueryTree: { id: 'customer-tree' } },
+        subsystemToSystemRequirementsQueries: null,
         systemToSubsystemRequirementsQueries: { id: 'rev-trace-tree' },
       });
     });
 
-    it('should fall back to root queries and return null trace trees when trace folders are missing', async () => {
+    it('should return null customer/trace trees when the dedicated sysrs folder is missing (no fallback scan)', async () => {
       const rootQueries = { id: 'root' };
 
       jest
@@ -153,25 +325,29 @@ describe('TicketsDataProvider', () => {
       const fetchSystemRequirementQueriesSpy = jest
         .spyOn(ticketsDataProvider as any, 'fetchSystemRequirementQueries')
         .mockResolvedValue({ systemRequirementsQueryTree: { id: 'system-tree' } });
-      jest
-        .spyOn(ticketsDataProvider as any, 'findChildFolderByPossibleNames')
-        .mockResolvedValueOnce(null)
-        .mockResolvedValueOnce(null);
+      const fetchCustomerRequirementQueriesSpy = jest
+        .spyOn(ticketsDataProvider as any, 'fetchCustomerRequirementQueries')
+        .mockResolvedValue({ systemRequirementsQueryTree: { id: 'should-not-be-used' } });
+      jest.spyOn(ticketsDataProvider as any, 'findChildFolderByPossibleNames').mockResolvedValueOnce(null);
       const fetchRequirementsTraceQueriesForFolderSpy = jest
         .spyOn(ticketsDataProvider as any, 'fetchRequirementsTraceQueriesForFolder')
-        .mockResolvedValueOnce(null)
         .mockResolvedValueOnce(null);
 
       const result = await (ticketsDataProvider as any).fetchSysRsQueries(rootQueries);
 
       expect(fetchSystemRequirementQueriesSpy).toHaveBeenCalledWith(rootQueries, [
-        'System To Customer',
-        'System To Subsystem',
+        'system to subsystem',
+        'system-to-subsystem',
+        'system subsystem',
       ]);
-      expect(fetchRequirementsTraceQueriesForFolderSpy).toHaveBeenNthCalledWith(1, null);
-      expect(fetchRequirementsTraceQueriesForFolderSpy).toHaveBeenNthCalledWith(2, null);
+      expect(fetchRequirementsTraceQueriesForFolderSpy).toHaveBeenCalledTimes(1);
+      expect(fetchRequirementsTraceQueriesForFolderSpy).toHaveBeenCalledWith(null);
+      // No fallback scan when the dedicated sysrs folder is absent — otherwise
+      // unrelated flat queries from the Shared Queries root would leak in.
+      expect(fetchCustomerRequirementQueriesSpy).not.toHaveBeenCalled();
       expect(result).toEqual({
         systemRequirementsQueries: { systemRequirementsQueryTree: { id: 'system-tree' } },
+        customerRequirementsQueries: null,
         subsystemToSystemRequirementsQueries: null,
         systemToSubsystemRequirementsQueries: null,
       });
@@ -1353,6 +1529,46 @@ describe('TicketsDataProvider', () => {
       expect(result).toBeDefined();
     });
 
+    // Regression: WI_DEFAULT_FIELDS must include System.WorkItemType so that
+    // downstream Requirement-type filters (e.g. the customer-coverage table)
+    // do not drop every row because workItemType resolves to empty string.
+    it('should request System.WorkItemType in default fields for flat queries and expose workItemType on parsed items', async () => {
+      const mockWiqlHref = 'https://example.com/wiql';
+      const mockQueryResult = {
+        queryType: 'flat',
+        workItems: [{ id: 42, url: 'https://example.com/wi/42' }],
+      };
+      const mockWiResponse = {
+        fields: {
+          'System.Title': 'Customer Requirement',
+          'System.WorkItemType': 'Requirement',
+          'System.Description': 'Desc',
+        },
+        _links: { html: { href: 'https://example.com/wi/42' } },
+      };
+
+      (TFSServices.getItemContent as jest.Mock)
+        .mockResolvedValueOnce(mockQueryResult)
+        .mockResolvedValueOnce(mockWiResponse);
+
+      const result: any = await ticketsDataProvider.GetQueryResultsFromWiql(
+        mockWiqlHref,
+        false,
+        new Map<number, Set<any>>(),
+      );
+
+      // The per-item fetch URL must request System.WorkItemType.
+      const perItemCall = (TFSServices.getItemContent as jest.Mock).mock.calls.find(
+        (call: any[]) => typeof call[0] === 'string' && call[0].startsWith('https://example.com/wi/42'),
+      );
+      expect(perItemCall).toBeDefined();
+      expect(perItemCall[0]).toContain('System.WorkItemType');
+
+      // The parsed item must expose workItemType so downstream filters work.
+      expect(Array.isArray(result)).toBe(true);
+      expect(result[0]).toMatchObject({ id: 42, workItemType: 'Requirement' });
+    });
+
     it('should return undefined when queryType is not supported', async () => {
       (TFSServices.getItemContent as jest.Mock).mockResolvedValueOnce({ queryType: 'Unknown' });
       const res = await ticketsDataProvider.GetQueryResultsFromWiql(