@elisra-devops/docgen-data-provider 1.63.13 → 1.68.0

package/bin/tests/modules/ticketsDataProvider.test.js

@@ -0,0 +1,1681 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tfs_1 = require("../../helpers/tfs");
+const TicketsDataProvider_1 = require("../../modules/TicketsDataProvider");
+const logger_1 = require("../../utils/logger");
+const tfs_data_1 = require("../../models/tfs-data");
+jest.mock('../../helpers/tfs');
+jest.mock('../../utils/logger');
+jest.mock('../../helpers/helper');
+describe('TicketsDataProvider', () => {
+    let ticketsDataProvider;
+    const mockOrgUrl = 'https://dev.azure.com/organization/';
+    const mockToken = 'mock-token';
+    const mockProject = 'test-project';
+    beforeEach(() => {
+        jest.clearAllMocks();
+        ticketsDataProvider = new TicketsDataProvider_1.default(mockOrgUrl, mockToken);
+    });
+    describe('isLinkSideAllowedByTypeOrId', () => {
+        it('should accept when allowedTypes is empty and field is present', async () => {
+            const wiql = "SELECT * FROM WorkItemLinks WHERE Source.[System.WorkItemType] = 'Epic'";
+            const result = await ticketsDataProvider.isLinkSideAllowedByTypeOrId({}, wiql, 'Source', [], new Map());
+            expect(result).toBe(true);
+        });
+        it('should return false when allowedTypes is empty but field is not present', async () => {
+            const wiql = 'SELECT * FROM WorkItems';
+            const result = await ticketsDataProvider.isLinkSideAllowedByTypeOrId({}, wiql, 'Source', [], new Map());
+            expect(result).toBe(false);
+        });
+        it('should support equality operator and reject disallowed types', async () => {
+            const wiql = "SELECT * FROM WorkItemLinks WHERE Source.[System.WorkItemType] = 'Bug'";
+            const result = await ticketsDataProvider.isLinkSideAllowedByTypeOrId({}, wiql, 'Source', ['Epic', 'Feature'], new Map());
+            expect(result).toBe(false);
+        });
+        it('should support IN operator when all types are allowed', async () => {
+            const wiql = "SELECT * FROM WorkItemLinks WHERE Target.[System.WorkItemType] IN ('Requirement', 'Bug')";
+            const result = await ticketsDataProvider.isLinkSideAllowedByTypeOrId({}, wiql, 'Target', ['Requirement', 'Bug'], new Map());
+            expect(result).toBe(true);
+        });
+        it('should return false when no types are found in WIQL and no ids exist', async () => {
+            const wiql = "SELECT * FROM WorkItemLinks WHERE Target.[System.AreaPath] = 'A'";
+            const result = await ticketsDataProvider.isLinkSideAllowedByTypeOrId({}, wiql, 'Target', ['Bug'], new Map());
+            expect(result).toBe(false);
+        });
+    });
+    describe('findChildFolderByPossibleNames', () => {
+        it('should return null when parent is missing or possibleNames is empty', async () => {
+            await expect(ticketsDataProvider.findChildFolderByPossibleNames(null, ['a'])).resolves.toBeNull();
+            await expect(ticketsDataProvider.findChildFolderByPossibleNames({ hasChildren: false }, [])).resolves.toBeNull();
+        });
+        it('should prefer exact match over partial match and return the enriched folder', async () => {
+            const parent = {
+                id: 'p',
+                isFolder: true,
+                name: 'Parent',
+                hasChildren: true,
+                children: [
+                    { id: 'c1', isFolder: true, name: 'Requirement - Test', hasChildren: false },
+                    { id: 'c2', isFolder: true, name: 'requirement to test case', hasChildren: false },
+                ],
+            };
+            const ensureSpy = jest
+                .spyOn(ticketsDataProvider, 'ensureQueryChildren')
+                .mockImplementation(async (node) => node);
+            const result = await ticketsDataProvider.findChildFolderByPossibleNames(parent, [
+                'requirement - test',
+                'req',
+            ]);
+            expect(result).toBe(parent.children[0]);
+            expect(ensureSpy).toHaveBeenCalled();
+        });
+        it('should return first partial match when no exact match exists', async () => {
+            const parent = {
+                id: 'p',
+                isFolder: true,
+                name: 'Parent',
+                hasChildren: true,
+                children: [
+                    { id: 'c1', isFolder: true, name: 'Some Req Folder', hasChildren: false },
+                    { id: 'c2', isFolder: true, name: 'Other', hasChildren: false },
+                ],
+            };
+            jest
+                .spyOn(ticketsDataProvider, 'ensureQueryChildren')
+                .mockImplementation(async (node) => node);
+            const result = await ticketsDataProvider.findChildFolderByPossibleNames(parent, ['req']);
+            expect(result).toBe(parent.children[0]);
+        });
+        it('should BFS into nested folders and ignore non-folder children and visited duplicates', async () => {
+            const leaf = { id: 'leaf', isFolder: true, name: 'Deep Match', hasChildren: false, children: [] };
+            const parent = {
+                id: 'p',
+                isFolder: true,
+                name: 'Parent',
+                hasChildren: true,
+                children: [
+                    { id: 'a', isFolder: true, name: 'A', hasChildren: true },
+                    { id: 'b', isFolder: true, name: 'B', hasChildren: true },
+                ],
+            };
+            jest.spyOn(ticketsDataProvider, 'ensureQueryChildren').mockImplementation(async (node) => {
+                if ((node === null || node === void 0 ? void 0 : node.id) === 'a') {
+                    return Object.assign(Object.assign({}, node), { children: [{ id: 'not-folder', isFolder: false, name: 'NF' }, leaf, leaf] });
+                }
+                if ((node === null || node === void 0 ? void 0 : node.id) === 'b') {
+                    return Object.assign(Object.assign({}, node), { children: [leaf] });
+                }
+                return node;
+            });
+            const found = await ticketsDataProvider.findChildFolderByPossibleNames(parent, ['deep match']);
+            expect(found).toEqual(leaf);
+        });
+    });
+    describe('fetchWithAncestorFallback', () => {
+        it('should short-circuit when validator passes on the first candidate', async () => {
+            const root = { id: 'root', name: 'Root', hasChildren: false, children: [] };
+            const starting = { id: 'start', name: 'Start', hasChildren: false, children: [] };
+            jest.spyOn(ticketsDataProvider, 'ensureQueryChildren').mockImplementation(async (n) => n);
+            jest.spyOn(ticketsDataProvider, 'buildFallbackChain').mockResolvedValueOnce([starting, root]);
+            const fetcher = jest.fn().mockResolvedValueOnce({ ok: true });
+            const validator = jest.fn().mockReturnValueOnce(true);
+            const res = await ticketsDataProvider.fetchWithAncestorFallback(root, starting, fetcher, 'ctx', validator);
+            expect(res.usedFolder).toBe(starting);
+            expect(fetcher).toHaveBeenCalledTimes(1);
+            expect(validator).toHaveBeenCalledWith({ ok: true });
+        });
+        it('should fall back through all candidates and return last attempt when validator never passes', async () => {
+            const root = { id: 'root', name: 'Root', hasChildren: false, children: [] };
+            const a = { id: 'a', name: 'A', hasChildren: false, children: [] };
+            const b = { id: 'b', name: 'B', hasChildren: false, children: [] };
+            jest.spyOn(ticketsDataProvider, 'ensureQueryChildren').mockImplementation(async (n) => n);
+            jest.spyOn(ticketsDataProvider, 'buildFallbackChain').mockResolvedValueOnce([a, b, root]);
+            const fetcher = jest
+                .fn()
+                .mockResolvedValueOnce(null)
+                .mockResolvedValueOnce({})
+                .mockResolvedValueOnce({ last: true });
+            const validator = jest.fn().mockReturnValue(false);
+            const res = await ticketsDataProvider.fetchWithAncestorFallback(root, a, fetcher, 'ctx', validator);
+            expect(res.usedFolder).toBe(root);
+            expect(res.result).toEqual({ last: true });
+            expect(fetcher).toHaveBeenCalledTimes(3);
+        });
+    });
+    describe('FetchImageAsBase64', () => {
+        it('should fetch image as base64', async () => {
+            // Arrange
+            const mockUrl = 'https://example.com/image.jpg';
+            const mockBase64 = 'base64-encoded-image';
+            tfs_1.TFSServices.fetchAzureDevOpsImageAsBase64.mockResolvedValueOnce(mockBase64);
+            // Act
+            const result = await ticketsDataProvider.FetchImageAsBase64(mockUrl);
+            // Assert
+            expect(tfs_1.TFSServices.fetchAzureDevOpsImageAsBase64).toHaveBeenCalledWith(mockUrl, mockToken, 'get', null);
+            expect(result).toBe(mockBase64);
+        });
+    });
+    describe('GetWorkItem', () => {
+        it('should fetch work item with correct URL', async () => {
+            // Arrange
+            const mockId = '123';
+            const mockWorkItem = { id: 123, fields: { 'System.Title': 'Test Work Item' } };
+            tfs_1.TFSServices.getItemContent.mockResolvedValueOnce(mockWorkItem);
+            // Act
+            const result = await ticketsDataProvider.GetWorkItem(mockProject, mockId);
+            // Assert
+            expect(tfs_1.TFSServices.getItemContent).toHaveBeenCalledWith(`${mockOrgUrl}${mockProject}/_apis/wit/workitems/${mockId}?$expand=All`, mockToken);
+            expect(result).toEqual(mockWorkItem);
+        });
+    });
+    describe('GetLinksByIds', () => {
+        it('should retrieve links by ids', async () => {
+            // Arrange
+            const mockIds = [1, 2];
+            const mockWorkItems = [
+                { id: 1, fields: { 'System.Title': 'Item 1' } },
+                { id: 2, fields: { 'System.Title': 'Item 2' } },
+            ];
+            const mockLinksMap = new Map();
+            mockLinksMap.set('1', { id: '1', rels: ['3'] });
+            mockLinksMap.set('2', { id: '2', rels: [] });
+            const mockRelatedItems = [{ id: 3, fields: { 'System.Title': 'Related Item' } }];
+            const mockTraceItem = { id: '1', title: 'Item 1', url: 'url', customerId: 'customer', links: [] };
+            jest.spyOn(ticketsDataProvider, 'PopulateWorkItemsByIds').mockResolvedValueOnce(mockWorkItems);
+            jest.spyOn(ticketsDataProvider, 'GetRelationsIds').mockResolvedValueOnce(mockLinksMap);
+            jest
+                .spyOn(ticketsDataProvider, 'GetParentLink')
+                .mockResolvedValueOnce(mockTraceItem)
+                .mockResolvedValueOnce({ id: '2', title: 'Item 2', url: 'url', customerId: 'customer', links: [] });
+            jest.spyOn(ticketsDataProvider, 'PopulateWorkItemsByIds').mockResolvedValueOnce(mockRelatedItems);
+            jest.spyOn(ticketsDataProvider, 'GetLinks').mockResolvedValueOnce([]);
+            // Act
+            const result = await ticketsDataProvider.GetLinksByIds(mockProject, mockIds);
+            // Assert
+            expect(result.length).toBe(2);
+            expect(ticketsDataProvider.PopulateWorkItemsByIds).toHaveBeenCalledWith(mockIds, mockProject);
+            expect(ticketsDataProvider.GetRelationsIds).toHaveBeenCalledWith(mockWorkItems);
+        });
+    });
+    describe('GetSharedQueries', () => {
+        it('should fetch STD shared queries with correct URL', async () => {
+            // Arrange
+            const mockPath = '';
+            const mockDocType = 'STD';
+            const mockQueries = { name: 'Query 1' };
+            const mockBranchesResponse = {
+                reqToTest: { result: { reqTestTree: {} }, usedFolder: {} },
+                testToReq: { result: { testReqTree: {} }, usedFolder: {} },
+                mom: { result: { linkedMomTree: {} }, usedFolder: {} },
+            };
+            tfs_1.TFSServices.getItemContent.mockResolvedValueOnce(mockQueries);
+            jest.spyOn(ticketsDataProvider, 'ensureQueryChildren').mockResolvedValueOnce(mockQueries);
+            jest
+                .spyOn(ticketsDataProvider, 'getDocTypeRoot')
+                .mockResolvedValueOnce({ root: mockQueries, found: true });
+            jest
+                .spyOn(ticketsDataProvider, 'fetchDocTypeBranches')
+                .mockResolvedValueOnce(mockBranchesResponse);
+            // Act
+            const result = await ticketsDataProvider.GetSharedQueries(mockProject, mockPath, mockDocType);
+            // Assert
+            expect(tfs_1.TFSServices.getItemContent).toHaveBeenCalledWith(`${mockOrgUrl}${mockProject}/_apis/wit/queries/Shared%20Queries?$depth=2&$expand=all`, mockToken);
+            expect(result).toEqual({
+                reqTestQueries: { reqTestTree: {}, testReqTree: {} },
+                linkedMomQueries: { linkedMomTree: {} },
+            });
+        });
+        it('should fetch SVD shared queries and call fetchAnyQueries', async () => {
+            // Arrange
+            const mockPath = 'Custom Path';
+            const mockDocType = 'SVD';
+            const mockQueries = { name: 'Query 1' };
+            const mockBranchesResponse = {
+                systemOverview: { result: {}, usedFolder: {} },
+                knownBugs: { result: {}, usedFolder: {} },
+            };
+            tfs_1.TFSServices.getItemContent.mockResolvedValueOnce(mockQueries);
+            jest.spyOn(ticketsDataProvider, 'ensureQueryChildren').mockResolvedValueOnce(mockQueries);
+            jest
+                .spyOn(ticketsDataProvider, 'getDocTypeRoot')
+                .mockResolvedValueOnce({ root: mockQueries, found: true });
+            jest
+                .spyOn(ticketsDataProvider, 'fetchDocTypeBranches')
+                .mockResolvedValueOnce(mockBranchesResponse);
+            // Act
+            const result = await ticketsDataProvider.GetSharedQueries(mockProject, mockPath, mockDocType);
+            // Assert
+            expect(tfs_1.TFSServices.getItemContent).toHaveBeenCalledWith(`${mockOrgUrl}${mockProject}/_apis/wit/queries/${mockPath}?$depth=2&$expand=all`, mockToken);
+            expect(result).toEqual({
+                systemOverviewQueryTree: {},
+                knownBugsQueryTree: {},
+            });
+        });
+        it('should handle errors', async () => {
+            // Arrange
+            const mockPath = '';
+            const mockError = new Error('API error');
+            tfs_1.TFSServices.getItemContent.mockImplementationOnce(() => {
+                return Promise.reject(mockError);
+            });
+            // Act & Assert
+            await expect(ticketsDataProvider.GetSharedQueries(mockProject, mockPath)).rejects.toThrow('API error');
+            expect(logger_1.default.error).toHaveBeenCalled();
+        });
+        it('should fall back to reqToTestResult.testReqTree when testToReqResult is missing (std)', async () => {
+            const mockQueries = { name: 'QueriesRoot' };
+            tfs_1.TFSServices.getItemContent.mockResolvedValueOnce(mockQueries);
+            jest.spyOn(ticketsDataProvider, 'ensureQueryChildren').mockResolvedValueOnce(mockQueries);
+            jest
+                .spyOn(ticketsDataProvider, 'getDocTypeRoot')
+                .mockResolvedValueOnce({ root: mockQueries, found: true });
+            jest.spyOn(ticketsDataProvider, 'fetchDocTypeBranches').mockResolvedValueOnce({
+                reqToTest: {
+                    result: {
+                        reqTestTree: { a: 1 },
+                        testReqTree: { fallback: true },
+                    },
+                    usedFolder: { name: 'req-to-test' },
+                },
+                // missing testToReq
+                mom: { result: { linkedMomTree: null }, usedFolder: { name: 'mom' } },
+            });
+            const res = await ticketsDataProvider.GetSharedQueries(mockProject, '', 'std');
+            expect(res).toEqual({
+                reqTestQueries: { reqTestTree: { a: 1 }, testReqTree: { fallback: true } },
+                linkedMomQueries: { linkedMomTree: null },
+            });
+        });
+        it('should fall back to openPcrToTest.TestToOpenPcrTree when testToOpenPcr branch is missing (str)', async () => {
+            const mockQueries = { name: 'QueriesRoot' };
+            tfs_1.TFSServices.getItemContent.mockResolvedValueOnce(mockQueries);
+            jest.spyOn(ticketsDataProvider, 'ensureQueryChildren').mockResolvedValueOnce(mockQueries);
+            jest
+                .spyOn(ticketsDataProvider, 'getDocTypeRoot')
+                .mockResolvedValueOnce({ root: mockQueries, found: true });
+            jest.spyOn(ticketsDataProvider, 'fetchDocTypeBranches').mockResolvedValueOnce({
+                reqToTest: { result: { reqTestTree: null }, usedFolder: { name: 'req-to-test' } },
+                testToReq: { result: { testReqTree: null }, usedFolder: { name: 'test-to-req' } },
+                openPcrToTest: {
+                    result: {
+                        OpenPcrToTestTree: { ok: true },
+                        TestToOpenPcrTree: { fromOpenPcr: true },
+                    },
+                    usedFolder: { name: 'open-pcr-to-test' },
+                },
+                // missing testToOpenPcr
+            });
+            const res = await ticketsDataProvider.GetSharedQueries(mockProject, '', 'str');
+            expect(res).toEqual({
+                reqTestTrees: { reqTestTree: null, testReqTree: null },
+                openPcrTestTrees: {
+                    OpenPcrToTestTree: { ok: true },
+                    TestToOpenPcrTree: { fromOpenPcr: true },
+                },
+            });
+        });
+        it('should execute std validators via fetchDocTypeBranches and accept fallback when first folder yields no results', async () => {
+            const queries = {
+                id: 'root',
+                name: 'Root',
+                isFolder: true,
+                hasChildren: true,
+                children: [
+                    { id: 'req', name: 'Requirement - Test', isFolder: true, hasChildren: false },
+                    { id: 'test', name: 'Test - Requirement', isFolder: true, hasChildren: false },
+                    { id: 'mom', name: 'MOM', isFolder: true, hasChildren: false },
+                ],
+            };
+            tfs_1.TFSServices.getItemContent.mockResolvedValueOnce(queries);
+            jest.spyOn(ticketsDataProvider, 'ensureQueryChildren').mockImplementation(async (x) => x);
+            jest
+                .spyOn(ticketsDataProvider, 'getDocTypeRoot')
+                .mockResolvedValueOnce({ root: queries, found: true });
+            // Force two candidates so validators run with null and then with data
+            jest
+                .spyOn(ticketsDataProvider, 'buildFallbackChain')
+                .mockResolvedValueOnce([queries.children[0], queries])
+                .mockResolvedValueOnce([queries.children[1], queries])
+                .mockResolvedValueOnce([queries.children[2], queries]);
+            const fetchReqTestSpy = jest
+                .spyOn(ticketsDataProvider, 'fetchLinkedReqTestQueries')
+                .mockResolvedValueOnce(null)
+                .mockResolvedValueOnce({ reqTestTree: { isValidQuery: true } })
+                .mockResolvedValueOnce(null)
+                .mockResolvedValueOnce({ testReqTree: { isValidQuery: true } });
+            const fetchMomSpy = jest
+                .spyOn(ticketsDataProvider, 'fetchLinkedMomQueries')
+                .mockResolvedValueOnce(null)
+                .mockResolvedValueOnce({ linkedMomTree: { isValidQuery: true } });
+            const res = await ticketsDataProvider.GetSharedQueries(mockProject, '', 'std');
+            expect(fetchReqTestSpy).toHaveBeenCalled();
+            expect(fetchMomSpy).toHaveBeenCalled();
+            expect(res.reqTestQueries.reqTestTree).toEqual({ isValidQuery: true });
+            expect(res.reqTestQueries.testReqTree).toEqual({ isValidQuery: true });
+            expect(res.linkedMomQueries.linkedMomTree).toEqual({ isValidQuery: true });
+        });
+    });
+    describe('hasAnyQueryTree', () => {
+        it('should return true for objects with isValidQuery/wiql/queryType', () => {
+            expect(ticketsDataProvider.hasAnyQueryTree({ isValidQuery: true })).toBe(true);
+            expect(ticketsDataProvider.hasAnyQueryTree({ wiql: 'x' })).toBe(true);
+            expect(ticketsDataProvider.hasAnyQueryTree({ queryType: 'Flat' })).toBe(true);
+        });
+        it('should return true for roots/children containers and nested objects, otherwise false', () => {
+            expect(ticketsDataProvider.hasAnyQueryTree({ roots: [{}] })).toBe(true);
+            expect(ticketsDataProvider.hasAnyQueryTree({ children: [{}] })).toBe(true);
+            expect(ticketsDataProvider.hasAnyQueryTree({ a: { b: [{ wiql: 'y' }] } })).toBe(true);
+            expect(ticketsDataProvider.hasAnyQueryTree({ a: { b: [] } })).toBe(false);
+        });
+    });
+    describe('matchesAreaPathCondition', () => {
+        it('should require both source+target leaf matches when filters are provided', () => {
+            const wiql = "SELECT * FROM WorkItemLinks WHERE Source.[System.AreaPath] = 'Test CMMI\\System' AND Target.[System.AreaPath] = 'Test CMMI\\Software'";
+            const ok = ticketsDataProvider.matchesAreaPathCondition(wiql, 'system', 'software');
+            expect(ok).toBe(true);
+            const badTarget = ticketsDataProvider.matchesAreaPathCondition(wiql, 'system', 'nope');
+            expect(badTarget).toBe(false);
+        });
+        it('should return false when filter is provided but area paths are not present for that owner', () => {
+            const wiql = "SELECT * FROM WorkItemLinks WHERE Target.[System.AreaPath] = 'A\\B\\Leaf'";
+            const ok = ticketsDataProvider.matchesAreaPathCondition(wiql, 'leaf', 'leaf');
+            expect(ok).toBe(false);
+        });
+    });
+    describe('GetQueryResultsFromWiql', () => {
+        it('should handle OneHop query with table format', async () => {
+            // Arrange
+            const mockWiqlHref = 'https://example.com/wiql';
+            const mockTestCaseMap = new Map();
+            const mockQueryResult = {
+                queryType: tfs_data_1.QueryType.OneHop,
+                columns: [],
+                workItemRelations: [{ source: null, target: { id: 1, url: 'url' } }],
+            };
+            const mockTableResult = {
+                sourceTargetsMap: new Map(),
+                sortingSourceColumnsMap: new Map(),
+                sortingTargetsColumnsMap: new Map(),
+            };
+            tfs_1.TFSServices.getItemContent.mockResolvedValueOnce(mockQueryResult);
+            jest
+                .spyOn(ticketsDataProvider, 'parseDirectLinkedQueryResultForTableFormat')
+                .mockResolvedValueOnce(mockTableResult);
+            // Act
+            const result = await ticketsDataProvider.GetQueryResultsFromWiql(mockWiqlHref, true, mockTestCaseMap);
+            // Assert
+            expect(tfs_1.TFSServices.getItemContent).toHaveBeenCalledWith(mockWiqlHref, mockToken);
+            expect(result).toEqual(mockTableResult);
+        });
+        it('should throw error when wiqlHref is empty', async () => {
+            // Arrange
+            const mockTestCaseMap = new Map();
+            // Act & Assert
+            const result = await ticketsDataProvider.GetQueryResultsFromWiql('', false, mockTestCaseMap);
+            expect(logger_1.default.error).toHaveBeenCalled();
+            expect(result).toBeUndefined();
+        });
+    });
+    describe('parseDirectLinkedQueryResultForTableFormat', () => {
+        it('should throw when workItemRelations is an empty array', async () => {
+            await expect(ticketsDataProvider.parseDirectLinkedQueryResultForTableFormat({ columns: [], workItemRelations: [], queryType: tfs_data_1.QueryType.OneHop }, new Map())).rejects.toThrow('No related work items were found');
+        });
+        it('should build sourceTargetsMap, include root links, and dedupe testCase->related items', async () => {
+            const testCaseToRelatedWiMap = new Map();
+            const workItemRelations = [
+                { source: null, target: { id: 1 } },
+                { source: { id: 1 }, target: { id: 2 } },
+                { source: { id: 1 }, target: { id: 2 } },
+            ];
+            const fetchSpy = jest
+                .spyOn(ticketsDataProvider, 'fetchWIForQueryResult')
+                .mockImplementation(async (...args) => {
+                var _a, _b, _c;
+                const _rel = args[0];
+                const columnsToShowMap = args[1];
+                // Validate CustomerRequirementId -> Customer ID mapping is prepared
+                expect(columnsToShowMap.get('CustomerRequirementId')).toBe('Customer ID');
+                const id = (_b = (_a = _rel === null || _rel === void 0 ? void 0 : _rel.target) === null || _a === void 0 ? void 0 : _a.id) !== null && _b !== void 0 ? _b : (_c = _rel === null || _rel === void 0 ? void 0 : _rel.source) === null || _c === void 0 ? void 0 : _c.id;
+                if (id === 1) {
+                    return { id: 1, fields: { 'System.WorkItemType': 'Test Case' } };
+                }
+                if (id === 2) {
+                    return { id: 2, fields: { 'System.WorkItemType': 'Bug' } };
+                }
+                return { id, fields: { 'System.WorkItemType': 'Task' } };
+            });
+            const res = await ticketsDataProvider.parseDirectLinkedQueryResultForTableFormat({
+                queryType: tfs_data_1.QueryType.OneHop,
+                columns: [{ referenceName: 'CustomerRequirementId', name: 'CustomerRequirementId' }],
+                workItemRelations,
+            }, testCaseToRelatedWiMap);
+            expect(fetchSpy).toHaveBeenCalled();
+            expect(res.sourceTargetsMap).toBeInstanceOf(Map);
+            const keys = Array.from(res.sourceTargetsMap.keys());
+            expect(keys.some((k) => k.id === 1)).toBe(true);
+            const relatedSet = testCaseToRelatedWiMap.get(1);
+            expect(relatedSet).toBeDefined();
+            expect(Array.from(relatedSet || [])).toHaveLength(1);
+            expect(Array.from(relatedSet || [])[0]).toEqual(expect.objectContaining({ id: 2 }));
+        });
+        it('should throw when relation.target is missing', async () => {
+            jest
+                .spyOn(ticketsDataProvider, 'fetchWIForQueryResult')
+                .mockResolvedValueOnce({ id: 1, fields: { 'System.WorkItemType': 'Test Case' } });
+            await expect(ticketsDataProvider.parseDirectLinkedQueryResultForTableFormat({
+                queryType: tfs_data_1.QueryType.OneHop,
+                columns: [],
+                workItemRelations: [{ source: { id: 1 }, target: null }],
+            }, new Map())).rejects.toThrow('Target relation is missing');
+        });
+    });
+    describe('isFlatQueryAllowedByTypeOrId', () => {
+        it('should accept when allowedTypes is empty and WIQL references [System.WorkItemType]', async () => {
+            const wiql = "SELECT * FROM WorkItems WHERE [System.WorkItemType] = 'Bug'";
+            const res = await ticketsDataProvider.isFlatQueryAllowedByTypeOrId({}, wiql, [], new Map());
+            expect(res).toBe(true);
+        });
+        it('should return false when allowedTypes is provided but no types are found and no ids exist', async () => {
+            const wiql = "SELECT * FROM WorkItems WHERE [System.Title] <> ''";
+            const res = await ticketsDataProvider.isFlatQueryAllowedByTypeOrId({}, wiql, ['Bug'], new Map());
+            expect(res).toBe(false);
+        });
+        it('should reject when WIQL contains a type outside allowedTypes', async () => {
+            const wiql = "SELECT * FROM WorkItems WHERE [System.WorkItemType] IN ('Bug','Task')";
+            const res = await ticketsDataProvider.isFlatQueryAllowedByTypeOrId({}, wiql, ['Bug'], new Map());
+            expect(res).toBe(false);
+        });
+    });
+    describe('matchesFlatAreaCondition', () => {
+        it('should return true when filter is empty', () => {
+            const wiql = 'SELECT * FROM WorkItems';
+            const res = ticketsDataProvider.matchesFlatAreaCondition(wiql, '');
+            expect(res).toBe(true);
+        });
+        it('should return false when no [System.AreaPath] is present in WIQL', () => {
+            const wiql = "SELECT * FROM WorkItems WHERE [System.Title] <> ''";
+            const res = ticketsDataProvider.matchesFlatAreaCondition(wiql, 'X');
+            expect(res).toBe(false);
+        });
+        it('should match by leaf segment of area path (case-insensitive)', () => {
+            const wiql = "SELECT * FROM WorkItems WHERE [System.AreaPath] = 'A\\B\\Leaf'";
+            const res = ticketsDataProvider.matchesFlatAreaCondition(wiql, 'leaf');
+            expect(res).toBe(true);
+        });
+    });
+    describe('filterFieldsByColumns', () => {
+        it('should keep fields included by columns map and always include System.WorkItemType and System.Title', () => {
+            const item = {
+                fields: {
+                    'System.Title': 'T',
+                    'System.WorkItemType': 'Bug',
+                    'Custom.Keep': 1,
+                    'Custom.Drop': 2,
+                },
+            };
+            const columnsToFilterMap = new Map([['Custom.Keep', 'Keep']]);
+            const resultedRefNameMap = new Map();
+            ticketsDataProvider.filterFieldsByColumns(item, columnsToFilterMap, resultedRefNameMap);
+            expect(Object.keys(item.fields).sort()).toEqual(['Custom.Keep', 'System.Title', 'System.WorkItemType']);
+            expect(resultedRefNameMap.get('Custom.Keep')).toBe('Keep');
+            expect(resultedRefNameMap.get('System.Title')).toBe('System.Title');
+            expect(resultedRefNameMap.get('System.WorkItemType')).toBe('System.WorkItemType');
+        });
+        it('should log and throw when item.fields is invalid', () => {
+            const item = { fields: undefined };
+            const columnsToFilterMap = new Map();
+            const resultedRefNameMap = new Map();
+            expect(() => ticketsDataProvider.filterFieldsByColumns(item, columnsToFilterMap, resultedRefNameMap)).toThrow();
+            expect(logger_1.default.error).toHaveBeenCalledWith(expect.stringContaining('Cannot filter columns'));
+        });
+    });
+    describe('GetWorkItemTypeList', () => {
+        it('should fetch work item types and attempt icon download with fallback accepts', async () => {
+            tfs_1.TFSServices.getItemContent.mockReset();
+            if (!tfs_1.TFSServices.fetchAzureDevOpsImageAsBase64) {
+                tfs_1.TFSServices.fetchAzureDevOpsImageAsBase64 = jest.fn();
+            }
+            tfs_1.TFSServices.fetchAzureDevOpsImageAsBase64.mockReset();
+            tfs_1.TFSServices.getItemContent.mockResolvedValueOnce({
+                value: [
+                    {
+                        name: 'Bug',
+                        referenceName: 'Microsoft.VSTS.WorkItemTypes.Bug',
+                        color: 'ff0000',
+                        icon: { id: 'i', url: 'http://example.com/icon' },
+                        states: [],
+                    },
+                ],
+            });
+            // First accept fails, second succeeds
+            tfs_1.TFSServices.fetchAzureDevOpsImageAsBase64
+                .mockRejectedValueOnce(new Error('svg fail'))
+                .mockResolvedValueOnce('data:image/png;base64,xxx');
+            const res = await ticketsDataProvider.GetWorkItemTypeList(mockProject);
+            expect(res).toHaveLength(1);
+            expect(res[0]).toEqual(expect.objectContaining({
+                name: 'Bug',
+                icon: expect.objectContaining({ dataUrl: 'data:image/png;base64,xxx' }),
+            }));
+            expect(logger_1.default.warn).toHaveBeenCalledWith(expect.stringContaining('Failed to download icon'));
+        });
+    });
+    describe('GetModeledQuery', () => {
+        it('should structure query list correctly', () => {
+            // Arrange
+            const mockQueryList = [
+                {
+                    name: 'Query 1',
+                    _links: { wiql: 'http://example.com/wiql1' },
+                    id: 'q1',
+                },
+                {
+                    name: 'Query 2',
+                    _links: { wiql: null },
+                    id: 'q2',
+                },
+            ];
+            // Act
+            const result = ticketsDataProvider.GetModeledQuery(mockQueryList);
+            // Assert
+            expect(result).toEqual([
+                { queryName: 'Query 1', wiql: 'http://example.com/wiql1', id: 'q1' },
+                { queryName: 'Query 2', wiql: null, id: 'q2' },
+            ]);
+        });
+    });
+    describe('PopulateWorkItemsByIds', () => {
+        it('should fetch work items in batches of 200', async () => {
+            // Arrange
+            const mockIds = Array.from({ length: 250 }, (_, i) => i + 1);
+            const mockResponse1 = { value: mockIds.slice(0, 200).map((id) => ({ id })) };
+            const mockResponse2 = { value: mockIds.slice(200).map((id) => ({ id })) };
+            tfs_1.TFSServices.getItemContent
+                .mockResolvedValueOnce(mockResponse1)
+                .mockResolvedValueOnce(mockResponse2);
+            // Act
+            const result = await ticketsDataProvider.PopulateWorkItemsByIds(mockIds, mockProject);
+            // Assert
+            expect(tfs_1.TFSServices.getItemContent).toHaveBeenCalledTimes(2);
+            expect(result.length).toBe(250);
+        });
+        it('should handle errors and return empty array', async () => {
+            // Arrange
+            const mockIds = [1, 2, 3];
+            const mockError = new Error('API error');
+            tfs_1.TFSServices.getItemContent.mockRejectedValueOnce(mockError);
+            // Act
+            const result = await ticketsDataProvider.PopulateWorkItemsByIds(mockIds, mockProject);
+            // Assert
+            expect(result).toEqual([]);
+            expect(logger_1.default.error).toHaveBeenCalled();
+        });
+    });
+    describe('GetIterationsByTeamName', () => {
+        it('should fetch iterations with team name specified', async () => {
+            // Arrange
+            const mockTeamName = 'test-team';
+            const mockIterations = ['iteration1', 'iteration2'];
+            tfs_1.TFSServices.getItemContent.mockResolvedValueOnce(mockIterations);
+            // Act
+            const result = await ticketsDataProvider.GetIterationsByTeamName(mockProject, mockTeamName);
+            // Assert
+            expect(tfs_1.TFSServices.getItemContent).toHaveBeenCalledWith(`${mockOrgUrl}${mockProject}/${mockTeamName}/_apis/work/teamsettings/iterations`, mockToken, 'get');
+            expect(result).toEqual(mockIterations);
+        });
+        it('should fetch iterations without team name', async () => {
+            // Arrange
+            const mockTeamName = '';
+            const mockIterations = ['iteration1', 'iteration2'];
+            tfs_1.TFSServices.getItemContent.mockResolvedValueOnce(mockIterations);
+            // Act
+            const result = await ticketsDataProvider.GetIterationsByTeamName(mockProject, mockTeamName);
+            // Assert
+            expect(tfs_1.TFSServices.getItemContent).toHaveBeenCalledWith(`${mockOrgUrl}${mockProject}/_apis/work/teamsettings/iterations`, mockToken, 'get');
+            expect(result).toEqual(mockIterations);
+        });
+    });
+    describe('CreateNewWorkItem', () => {
+        it('should create work item with correct parameters', async () => {
+            // Arrange
+            const mockWiBody = [{ op: 'add', path: '/fields/System.Title', value: 'New Item' }];
+            const mockWiType = 'Bug';
+            const mockByPass = true;
+            const mockResponse = { id: 123, fields: { 'System.Title': 'New Item' } };
+            tfs_1.TFSServices.getItemContent.mockResolvedValueOnce(mockResponse);
+            // Act
+            const result = await ticketsDataProvider.CreateNewWorkItem(mockProject, mockWiBody, mockWiType, mockByPass);
+            // Assert
+            expect(tfs_1.TFSServices.getItemContent).toHaveBeenCalledWith(`${mockOrgUrl}${mockProject}/_apis/wit/workitems/$${mockWiType}?bypassRules=true`, mockToken, 'POST', mockWiBody, {
+                'Content-Type': 'application/json-patch+json',
+            });
+            expect(result).toEqual(mockResponse);
+        });
+    });
+    describe('UpdateWorkItem', () => {
+        it('should update work item with correct parameters', async () => {
+            // Arrange
+            const mockWiBody = [{ op: 'add', path: '/fields/System.Title', value: 'Updated Item' }];
+            const mockWorkItemId = 123;
+            const mockByPass = true;
+            const mockResponse = { id: 123, fields: { 'System.Title': 'Updated Item' } };
+            tfs_1.TFSServices.getItemContent.mockResolvedValueOnce(mockResponse);
+            // Act
+            const result = await ticketsDataProvider.UpdateWorkItem(mockProject, mockWiBody, mockWorkItemId, mockByPass);
+            // Assert
+            expect(tfs_1.TFSServices.getItemContent).toHaveBeenCalledWith(`${mockOrgUrl}${mockProject}/_apis/wit/workitems/${mockWorkItemId}?bypassRules=true`, mockToken, 'patch', mockWiBody, {
+                'Content-Type': 'application/json-patch+json',
+            });
+            expect(result).toEqual(mockResponse);
+        });
+    });
+    describe('GetWorkitemAttachments', () => {
+        it('should return attachments for work item', async () => {
+            // Arrange
+            const mockId = '123';
+            const mockWorkItem = {
+                relations: [
+                    {
+                        rel: 'AttachedFile',
+                        url: 'https://example.com/attachment/1',
+                        attributes: { name: 'file.txt' },
+                    },
+                ],
+            };
+            // Mock the TFSServices.getItemContent directly to return our mock data
+            // This is what will be called by the new TicketsDataProvider instance
+            tfs_1.TFSServices.getItemContent.mockResolvedValueOnce(mockWorkItem);
+            // Act
+            const result = await ticketsDataProvider.GetWorkitemAttachments(mockProject, mockId);
+            // Assert
+            expect(tfs_1.TFSServices.getItemContent).toHaveBeenCalledWith(`${mockOrgUrl}${mockProject}/_apis/wit/workitems/${mockId}?$expand=All`, mockToken);
+            expect(result.length).toBe(1);
+            // Check that the downloadUrl was added correctly
+            expect(result[0]).toHaveProperty('downloadUrl', 'https://example.com/attachment/1/file.txt');
+            expect(result[0].rel).toBe('AttachedFile');
+        });
+        it('should return [] when relations are missing', async () => {
+            jest
+                .spyOn(ticketsDataProvider, 'GetWorkItem')
+                .mockResolvedValueOnce({ id: 1, relations: undefined });
+            const res = await ticketsDataProvider.GetWorkitemAttachments(mockProject, '1');
+            expect(res).toEqual([]);
+        });
+        it('should handle work item with no relations', async () => {
+            // Arrange
+            const mockId = '123';
+            const mockWorkItem = { relations: null };
+            jest.spyOn(ticketsDataProvider, 'GetWorkItem').mockResolvedValueOnce(mockWorkItem);
+            // Act
+            const result = await ticketsDataProvider.GetWorkitemAttachments(mockProject, mockId);
+            // Assert
+            expect(result).toEqual([]);
+        });
+        it('should log and return [] when GetWorkItem throws', async () => {
+            jest.spyOn(TicketsDataProvider_1.default.prototype, 'GetWorkItem').mockRejectedValueOnce(new Error('boom'));
+            const res = await ticketsDataProvider.GetWorkitemAttachments(mockProject, '1');
+            expect(res).toEqual([]);
+            expect(logger_1.default.error).toHaveBeenCalled();
+        });
+        it('should filter out non-attachment relations', async () => {
+            // Arrange
+            const mockId = '123';
+            const mockWorkItem = {
+                relations: [
+                    {
+                        rel: 'Parent',
+                        url: 'https://example.com/parent/1',
+                        attributes: { name: 'parent' },
+                    },
+                    {
+                        rel: 'AttachedFile',
+                        url: 'https://example.com/attachment/1',
+                        attributes: { name: 'file.txt' },
+                    },
+                ],
+            };
+            // Mock TFSServices.getItemContent directly instead of GetWorkItem
+            tfs_1.TFSServices.getItemContent.mockResolvedValueOnce(mockWorkItem);
+            // Act
+            const result = await ticketsDataProvider.GetWorkitemAttachments(mockProject, mockId);
+            // Assert
+            expect(tfs_1.TFSServices.getItemContent).toHaveBeenCalledWith(`${mockOrgUrl}${mockProject}/_apis/wit/workitems/${mockId}?$expand=All`, mockToken);
+            expect(result.length).toBe(1);
+            expect(result[0].rel).toBe('AttachedFile');
+            // Only the AttachedFile relation should be in the result
+            expect(result.some((item) => item.rel === 'Parent')).toBe(false);
+        });
+    });
+    describe('GetWorkItemByUrl', () => {
+        it('should fetch work item by URL', async () => {
+            // Arrange
+            const mockUrl = 'https://dev.azure.com/org/project/_apis/wit/workitems/123';
+            const mockWorkItem = { id: 123, fields: { 'System.Title': 'Test' } };
+            tfs_1.TFSServices.getItemContent.mockResolvedValueOnce(mockWorkItem);
+            // Act
+            const result = await ticketsDataProvider.GetWorkItemByUrl(mockUrl);
+            // Assert
+            expect(tfs_1.TFSServices.getItemContent).toHaveBeenCalledWith(mockUrl, mockToken);
+            expect(result).toEqual(mockWorkItem);
+        });
+    });
+    describe('GetParentLink', () => {
+        it('should return trace with work item info', async () => {
+            // Arrange
+            const mockWi = {
+                id: '123',
+                fields: {
+                    'System.Title': 'Test Work Item',
+                    'System.CustomerId': 'CUST-001',
+                },
+            };
+            // Act
+            const result = await ticketsDataProvider.GetParentLink(mockProject, mockWi);
+            // Assert
+            expect(result.id).toBe('123');
+            expect(result.title).toBe('Test Work Item');
+            expect(result.customerId).toBe('CUST-001');
+            expect(result.url).toContain(mockProject);
+        });
+        it('should handle work item without customerId', async () => {
+            // Arrange
+            const mockWi = {
+                id: '123',
+                fields: {
+                    'System.Title': 'Test Work Item',
+                },
+            };
+            // Act
+            const result = await ticketsDataProvider.GetParentLink(mockProject, mockWi);
+            // Assert
+            expect(result.id).toBe('123');
+            expect(result.customerId).toBeUndefined();
+        });
+        it('should handle null work item', async () => {
+            // Act
+            const result = await ticketsDataProvider.GetParentLink(mockProject, null);
+            // Assert
+            expect(result.id).toBeUndefined();
+        });
+    });
+    describe('GetRelationsIds', () => {
+        it('should return a map from work items', async () => {
+            // Arrange
+            const mockIds = [
+                {
+                    id: 1,
+                    relations: [{ rel: 'Parent', url: 'https://example.com/workitems/2' }],
+                },
+            ];
+            // Act
+            const result = await ticketsDataProvider.GetRelationsIds(mockIds);
+            // Assert - result is a Map
+            expect(result).toBeInstanceOf(Map);
+        });
+        it('should handle empty array', async () => {
+            // Arrange
+            const mockIds = [];
+            // Act
+            const result = await ticketsDataProvider.GetRelationsIds(mockIds);
+            // Assert
+            expect(result.size).toBe(0);
+        });
+    });
+    describe('GetLinks', () => {
+        it('should get links from work item relations', async () => {
+            // Arrange
+            const mockWi = {
+                relations: [{ rel: 'Parent', url: 'https://example.com/workitems/2' }],
+            };
+            const mockLinks = [
+                {
+                    id: '2',
+                    fields: {
+                        'System.Title': 'Parent Item',
+                        'System.Description': 'Parent Description',
+                    },
+                },
+            ];
+            // Act
+            const result = await ticketsDataProvider.GetLinks(mockProject, mockWi, mockLinks);
+            // Assert
+            expect(result).toHaveLength(1);
+            expect(result[0].id).toBe('2');
+            expect(result[0].title).toBe('Parent Item');
+            expect(result[0].type).toBe('Parent');
+        });
+    });
+    describe('GetFieldsByType', () => {
+        it('should fetch fields for a work item type', async () => {
+            // Arrange
+            const mockItemType = 'Bug';
+            const mockResponse = {
+                value: [
+                    { name: 'Priority', referenceName: 'Microsoft.VSTS.Common.Priority' },
+                    { name: 'Severity', referenceName: 'Microsoft.VSTS.Common.Severity' },
+                    { name: 'ID', referenceName: 'System.Id' },
+                    { name: 'Title', referenceName: 'System.Title' },
+                ],
+            };
+            tfs_1.TFSServices.getItemContent.mockResolvedValueOnce(mockResponse);
+            // Act
+            const result = await ticketsDataProvider.GetFieldsByType(mockProject, mockItemType);
+            // Assert
+            expect(tfs_1.TFSServices.getItemContent).toHaveBeenCalledWith(`${mockOrgUrl}${mockProject}/_apis/wit/workitemtypes/${mockItemType}/fields`, mockToken);
+            // Should filter out ID and Title
+            expect(result).toHaveLength(2);
+            expect(result[0].text).toBe('Priority (Bug)');
+            expect(result[0].key).toBe('Microsoft.VSTS.Common.Priority');
+        });
+        it('should throw error when API fails', async () => {
+            // Arrange
+            const mockError = new Error('API Error');
+            tfs_1.TFSServices.getItemContent.mockRejectedValueOnce(mockError);
+            // Act & Assert
+            await expect(ticketsDataProvider.GetFieldsByType(mockProject, 'Bug')).rejects.toThrow();
+            expect(logger_1.default.error).toHaveBeenCalled();
+        });
+    });
+    describe('GetQueryResultsFromWiql - additional cases', () => {
+        it('should handle Tree query type', async () => {
+            // Arrange
+            const mockWiqlHref = 'https://example.com/wiql';
+            const mockTestCaseMap = new Map();
+            const mockQueryResult = {
+                queryType: 'tree',
+                workItemRelations: [{ source: null, target: { id: 1, url: 'https://example.com/wi/1' }, rel: null }],
+            };
+            const mockWiResponse = {
+                fields: { 'System.Title': 'Test', 'System.Description': 'Desc' },
+                _links: { html: { href: 'https://example.com' } },
+            };
+            tfs_1.TFSServices.getItemContent
+                .mockResolvedValueOnce(mockQueryResult)
+                .mockResolvedValueOnce(mockWiResponse);
+            // Act
+            const result = await ticketsDataProvider.GetQueryResultsFromWiql(mockWiqlHref, false, mockTestCaseMap);
+            // Assert
+            expect(result).toBeDefined();
+        });
+        it('should handle Flat query type with table format', async () => {
+            // Arrange
+            const mockWiqlHref = 'https://example.com/wiql';
+            const mockTestCaseMap = new Map();
+            const mockQueryResult = {
+                queryType: 'flat',
+                columns: [{ referenceName: 'System.Title', name: 'Title' }],
+                workItems: [{ id: 1, url: 'https://example.com/wi/1' }],
+            };
+            const mockWiResponse = {
+                id: 1,
+                fields: { 'System.Title': 'Test Item' },
+            };
+            tfs_1.TFSServices.getItemContent
+                .mockResolvedValueOnce(mockQueryResult)
+                .mockResolvedValueOnce(mockWiResponse);
+            // Act
+            const result = await ticketsDataProvider.GetQueryResultsFromWiql(mockWiqlHref, true, mockTestCaseMap);
+            // Assert
+            expect(result).toBeDefined();
+        });
+        it('should handle Flat query type without table format', async () => {
+            // Arrange
+            const mockWiqlHref = 'https://example.com/wiql';
+            const mockTestCaseMap = new Map();
+            const mockQueryResult = {
+                queryType: 'flat',
+                workItems: [{ id: 1, url: 'https://example.com/wi/1' }],
+            };
+            const mockWiResponse = {
+                fields: { 'System.Title': 'Test', 'System.Description': 'Desc' },
+                _links: { html: { href: 'https://example.com' } },
+            };
+            tfs_1.TFSServices.getItemContent
+                .mockResolvedValueOnce(mockQueryResult)
+                .mockResolvedValueOnce(mockWiResponse);
+            // Act
+            const result = await ticketsDataProvider.GetQueryResultsFromWiql(mockWiqlHref, false, mockTestCaseMap);
+            // Assert
+            expect(result).toBeDefined();
+        });
+        it('should return undefined when queryType is not supported', async () => {
+            tfs_1.TFSServices.getItemContent.mockResolvedValueOnce({ queryType: 'Unknown' });
+            const res = await ticketsDataProvider.GetQueryResultsFromWiql('https://example.com/wiql', false, new Map());
+            expect(res).toBeUndefined();
+        });
+    });
+    describe('getRequirementTypeFieldRefs', () => {
+        it('should prioritize known ref and dedupe candidates', async () => {
+            tfs_1.TFSServices.getItemContent.mockResolvedValueOnce({
+                value: [
+                    { name: 'Requirement Type', referenceName: 'Microsoft.VSTS.CMMI.RequirementType' },
+                    { name: 'Requirement_Type', referenceName: 'Custom.RequirementType' },
+                    { name: 'Requirement Type', referenceName: 'Microsoft.VSTS.CMMI.RequirementType' },
+                    { name: 'Other', referenceName: 'Custom.Other' },
+                ],
+            });
+            const res = await ticketsDataProvider.getRequirementTypeFieldRefs('project1');
+            expect(res[0]).toBe('Microsoft.VSTS.CMMI.RequirementType');
+            expect(res).toContain('Custom.RequirementType');
+            expect(res.filter((x) => x === 'Microsoft.VSTS.CMMI.RequirementType')).toHaveLength(1);
+        });
+        it('should fall back to known ref when API call throws', async () => {
+            tfs_1.TFSServices.getItemContent.mockRejectedValueOnce(new Error('boom'));
+            const res = await ticketsDataProvider.getRequirementTypeFieldRefs('project1');
+            expect(res).toEqual(['Microsoft.VSTS.CMMI.RequirementType']);
+        });
+    });
+    describe('findQueryFolderByName', () => {
+        it('should return null when input is invalid', async () => {
+            await expect(ticketsDataProvider.findQueryFolderByName(null, 'x')).resolves.toBeNull();
+            await expect(ticketsDataProvider.findQueryFolderByName({ id: 'r' }, '')).resolves.toBeNull();
+        });
+        it('should BFS and return a folder by name; using ensureQueryChildren when node hasChildren', async () => {
+            const root = {
+                id: 'root',
+                name: 'Root',
+                isFolder: true,
+                hasChildren: true,
+                children: [
+                    { id: 'a', name: 'A', isFolder: true, hasChildren: true },
+                    { id: 'b', name: 'B', isFolder: true, hasChildren: false, children: [] },
+                ],
+            };
+            jest.spyOn(ticketsDataProvider, 'ensureQueryChildren').mockImplementation(async (node) => {
+                if (node.id === 'a') {
+                    node.children = [{ id: 'target', name: 'TargetFolder', isFolder: true, hasChildren: false }];
+                }
+                return node;
+            });
+            const found = await ticketsDataProvider.findQueryFolderByName(root, 'targetfolder');
+            expect(found).toEqual(expect.objectContaining({ id: 'target' }));
+        });
+        it('should return null when folder is not found', async () => {
+            const root = { id: 'root', name: 'Root', isFolder: true, hasChildren: false, children: [] };
+            const found = await ticketsDataProvider.findQueryFolderByName(root, 'missing');
+            expect(found).toBeNull();
+        });
+    });
+    describe('findChildFolderByName', () => {
+        it('should return null when parent or childName is invalid', async () => {
+            await expect(ticketsDataProvider.findChildFolderByName(null, 'x')).resolves.toBeNull();
+            await expect(ticketsDataProvider.findChildFolderByName({ id: 1 }, '')).resolves.toBeNull();
+        });
+        it('should return null when parent has no children after enrichment', async () => {
+            jest
+                .spyOn(ticketsDataProvider, 'ensureQueryChildren')
+                .mockResolvedValueOnce({ id: 'p', hasChildren: true, children: [] });
+            const res = await ticketsDataProvider.findChildFolderByName({ id: 'p' }, 'child');
+            expect(res).toBeNull();
+        });
+        it('should return matching child folder by case-insensitive exact name', async () => {
+            const parentWithChildren = {
+                id: 'p',
+                hasChildren: true,
+                children: [
+                    { id: 'c1', isFolder: true, name: 'Match', hasChildren: false },
+                    { id: 'c2', isFolder: true, name: 'Other', hasChildren: false },
+                ],
+            };
+            jest.spyOn(ticketsDataProvider, 'ensureQueryChildren').mockResolvedValueOnce(parentWithChildren);
+            const res = await ticketsDataProvider.findChildFolderByName({ id: 'p' }, 'match');
+            expect(res).toEqual(parentWithChildren.children[0]);
+        });
+    });
+    describe('buildFallbackChain + findPathToNode', () => {
+        it('should use findPathToNode when startingFolder has id', async () => {
+            const root = { id: 'root', name: 'Root', hasChildren: true, children: [] };
+            const mid = { id: 'mid', name: 'Mid', hasChildren: true, children: [] };
+            const start = { id: 'start', name: 'Start', hasChildren: false, children: [] };
+            root.children = [mid];
+            mid.children = [start];
+            jest.spyOn(ticketsDataProvider, 'ensureQueryChildren').mockImplementation(async (n) => n);
+            const path = await ticketsDataProvider.findPathToNode(root, 'start');
+            expect(path === null || path === void 0 ? void 0 : path.map((n) => n.id)).toEqual(['root', 'mid', 'start']);
+            const chain = await ticketsDataProvider.buildFallbackChain(root, start);
+            expect(chain.map((n) => n.id)).toEqual(['start', 'mid', 'root']);
+        });
+        it('should fall back to startingFolder when findPathToNode returns null', async () => {
+            const root = { id: 'root', name: 'Root', hasChildren: false, children: [] };
+            const start = { id: 'start', name: 'Start', hasChildren: false, children: [] };
+            jest.spyOn(ticketsDataProvider, 'findPathToNode').mockResolvedValueOnce(null);
+            const chain = await ticketsDataProvider.buildFallbackChain(root, start);
+            expect(chain.map((n) => n.id)).toEqual(['start', 'root']);
+        });
+        it('should handle startingFolder without id and always include rootQueries', async () => {
+            const root = { id: 'root', name: 'Root', hasChildren: false, children: [] };
+            const start = { name: 'StartNoId', hasChildren: false, children: [] };
+            const chain = await ticketsDataProvider.buildFallbackChain(root, start);
+            expect(chain).toHaveLength(2);
+            expect(chain[0]).toBe(start);
+            expect(chain[1]).toBe(root);
+        });
+        it('should return null from findPathToNode when a cycle is detected', async () => {
+            const node = { id: 'x', name: 'X', hasChildren: true, children: [] };
+            node.children = [node];
+            jest.spyOn(ticketsDataProvider, 'ensureQueryChildren').mockImplementation(async (n) => n);
+            const path = await ticketsDataProvider.findPathToNode(node, 'missing');
+            expect(path).toBeNull();
+        });
+    });
+    describe('structureFetchedQueries', () => {
+        it('should skip excluded folders', async () => {
+            const res = await ticketsDataProvider.structureFetchedQueries({ isFolder: true, name: 'SkipMe', hasChildren: true }, false, null, ['Epic'], ['Feature'], undefined, undefined, false, ['skipme'], false);
+            expect(res).toEqual({ tree1: null, tree2: null });
+        });
+        it('should fetch children when hasChildren=true but children are missing', async () => {
+            jest
+                .spyOn(ticketsDataProvider, 'matchesSourceTargetConditionAsync')
+                .mockResolvedValueOnce(true)
+                .mockResolvedValueOnce(false);
+            jest
+                .spyOn(ticketsDataProvider, 'buildQueryNode')
+                .mockImplementation((rq, parentId) => ({
+                id: rq.id,
+                pId: parentId,
+            }));
+            tfs_1.TFSServices.getItemContent.mockResolvedValueOnce({
+                id: 'root',
+                name: 'Root',
+                hasChildren: false,
+                isFolder: false,
+                queryType: 'oneHop',
+                wiql: "SELECT * FROM WorkItemLinks WHERE Source.[System.WorkItemType] = 'Epic' AND Target.[System.WorkItemType] = 'Feature'",
+            });
+            const res = await ticketsDataProvider.structureFetchedQueries({ id: 'root', url: 'https://example.com/q', hasChildren: true, children: undefined }, false, null, ['Epic'], ['Feature']);
+            expect(tfs_1.TFSServices.getItemContent).toHaveBeenCalledWith('https://example.com/q?$depth=2&$expand=all', mockToken);
+            expect(res.tree1).toEqual({ id: 'root', pId: 'root' });
+            expect(res.tree2).toBeNull();
+        });
+        it('should build tree nodes for flat queries when includeFlatQueries is enabled (tree1 only)', async () => {
+            jest
+                .spyOn(ticketsDataProvider, 'buildQueryNode')
+                .mockImplementation((rq, parentId) => ({ id: rq.id, pId: parentId }));
+            const wiql = "SELECT * FROM WorkItems WHERE [System.WorkItemType] = 'Bug' AND [System.AreaPath] = 'A\\Leaf'";
+            const res = await ticketsDataProvider.structureFetchedQueries({ id: 'q', isFolder: false, hasChildren: false, queryType: 'flat', wiql }, false, null, ['Bug'], ['Task'], 'leaf', 'missing', false, [], true);
+            expect(res.tree1).toEqual({ id: 'q', pId: null });
+            expect(res.tree2).toBeNull();
+        });
+        it('should build tree2 for reverse source/target in oneHop queries', async () => {
+            jest
+                .spyOn(ticketsDataProvider, 'matchesSourceTargetConditionAsync')
+                .mockResolvedValueOnce(false)
+                .mockResolvedValueOnce(true);
+            jest
+                .spyOn(ticketsDataProvider, 'buildQueryNode')
+                .mockImplementation((rq, parentId) => ({ id: rq.id, pId: parentId }));
+            const wiql = "SELECT * FROM WorkItemLinks WHERE Source.[System.WorkItemType] = 'Feature' AND Target.[System.WorkItemType] = 'Epic'";
+            const res = await ticketsDataProvider.structureFetchedQueries({ id: 'q2', isFolder: false, hasChildren: false, queryType: 'oneHop', wiql }, false, null, ['Epic'], ['Feature']);
+            expect(res.tree1).toBeNull();
+            expect(res.tree2).toEqual({ id: 'q2', pId: null });
+        });
+        describe('ID-only work item type fallback', () => {
+            const projectHref = `${mockOrgUrl}MyProject/_apis/wit/wiql/123`;
+            const allowedTypes = ['epic', 'feature', 'requirement'];
+            const makeLeafQuery = (overrides = {}) => (Object.assign({ id: 'q1', name: 'Query 1', isFolder: false, hasChildren: false, queryType: 'oneHop', wiql: '', _links: { wiql: { href: projectHref } } }, overrides));
+            it('should include a tree query when Source has [System.Id] and no Source type filter, and the fetched work item type is allowed', async () => {
+                tfs_1.TFSServices.getItemContent.mockResolvedValueOnce({
+                    fields: { 'System.WorkItemType': 'Epic' },
+                });
+                const queryNode = makeLeafQuery({
+                    queryType: 'tree',
+                    wiql: `
+            SELECT * FROM WorkItemLinks
+            WHERE
+              ([Source].[System.Id] = 123)
+              AND ([Target].[System.WorkItemType] IN ('Requirement','Epic','Feature'))
+          `,
+                });
+                const res = await ticketsDataProvider.structureFetchedQueries(queryNode, false, null, allowedTypes, [], undefined, undefined, true);
+                expect(res.tree1).not.toBeNull();
+                expect(tfs_1.TFSServices.getItemContent).toHaveBeenCalledTimes(1);
+            });
+            it('should exclude a tree query when Source has [System.Id] and no Source type filter, but the fetched work item type is not allowed', async () => {
+                tfs_1.TFSServices.getItemContent.mockResolvedValueOnce({
+                    fields: { 'System.WorkItemType': 'Bug' },
+                });
+                const queryNode = makeLeafQuery({
+                    queryType: 'tree',
+                    wiql: `
+            SELECT * FROM WorkItemLinks
+            WHERE
+              ([Source].[System.Id] = 123)
+              AND ([Target].[System.WorkItemType] IN ('Requirement','Epic','Feature'))
+          `,
+                });
+                const res = await ticketsDataProvider.structureFetchedQueries(queryNode, false, null, allowedTypes, [], undefined, undefined, true);
+                expect(res.tree1).toBeNull();
+                expect(tfs_1.TFSServices.getItemContent).toHaveBeenCalledTimes(1);
+            });
+            it('should include a oneHop query when Source has [System.Id] and no Source type filter, and the fetched work item type is allowed', async () => {
+                tfs_1.TFSServices.getItemContent.mockResolvedValueOnce({
+                    fields: { 'System.WorkItemType': 'Requirement' },
+                });
+                const queryNode = makeLeafQuery({
+                    queryType: 'oneHop',
+                    wiql: `
+            SELECT * FROM WorkItemLinks
+            WHERE
+              ([Source].[System.Id] = 123)
+              AND ([Target].[System.WorkItemType] = 'Feature')
+          `,
+                });
+                const res = await ticketsDataProvider.structureFetchedQueries(queryNode, false, null, allowedTypes, allowedTypes);
+                expect(res.tree1).not.toBeNull();
+                // reverse evaluation should reuse the cached lookup
+                expect(tfs_1.TFSServices.getItemContent).toHaveBeenCalledTimes(1);
+            });
+            it('should include a flat query when [System.Id] exists and no [System.WorkItemType] filter exists, and the fetched work item type is allowed', async () => {
+                tfs_1.TFSServices.getItemContent.mockResolvedValueOnce({
+                    fields: { 'System.WorkItemType': 'Feature' },
+                });
+                const queryNode = makeLeafQuery({
+                    queryType: 'flat',
+                    wiql: `
+            SELECT * FROM WorkItems
+            WHERE [System.Id] = 123
+          `,
+                });
+                const res = await ticketsDataProvider.structureFetchedQueries(queryNode, false, null, allowedTypes, [], undefined, undefined, false, [], true);
+                expect(res.tree1).not.toBeNull();
+                expect(tfs_1.TFSServices.getItemContent).toHaveBeenCalledTimes(1);
+            });
+            it('should not trigger the ID fallback when no [System.Id] filter exists', async () => {
+                const queryNode = makeLeafQuery({
+                    queryType: 'tree',
+                    wiql: `
+            SELECT * FROM WorkItemLinks
+            WHERE
+              ([Target].[System.WorkItemType] IN ('Requirement','Epic','Feature'))
+          `,
+                });
+                const res = await ticketsDataProvider.structureFetchedQueries(queryNode, false, null, allowedTypes, [], undefined, undefined, true);
+                expect(res.tree1).toBeNull();
+                expect(tfs_1.TFSServices.getItemContent).not.toHaveBeenCalled();
+            });
+        });
+    });
+    describe('structureAllQueryPath', () => {
+        it('should return sysOverview+knownBugs nodes for a flat Bug leaf query', async () => {
+            const leaf = {
+                id: 'q1',
+                name: 'BugQuery',
+                hasChildren: false,
+                isFolder: false,
+                queryType: 'flat',
+                columns: [],
+                wiql: "SELECT * FROM WorkItems WHERE [System.WorkItemType] = 'Bug'",
+                _links: { wiql: { href: 'http://example.com/wiql' } },
+            };
+            const res = await ticketsDataProvider.structureAllQueryPath(leaf, 'p');
+            expect(res.tree1).toEqual(expect.objectContaining({ id: 'q1', pId: 'p', isValidQuery: true }));
+            expect(res.tree2).toEqual(expect.objectContaining({ id: 'q1', pId: 'p', isValidQuery: true }));
+        });
+        it('should return sysOverview only for a flat non-bug leaf query', async () => {
+            const leaf = {
+                id: 'q2',
+                name: 'OtherQuery',
+                hasChildren: false,
+                isFolder: false,
+                queryType: 'flat',
+                columns: [],
+                wiql: "SELECT * FROM WorkItems WHERE [System.WorkItemType] = 'Task'",
+                _links: { wiql: { href: 'http://example.com/wiql' } },
+            };
+            const res = await ticketsDataProvider.structureAllQueryPath(leaf, 'p');
+            expect(res.tree1).toEqual(expect.objectContaining({ id: 'q2', pId: 'p', isValidQuery: true }));
+            expect(res.tree2).toBeNull();
+        });
+        it('should return null trees for a folder leaf', async () => {
+            const leafFolder = { id: 'f', name: 'Folder', hasChildren: false, isFolder: true };
+            const res = await ticketsDataProvider.structureAllQueryPath(leafFolder, 'p');
+            expect(res).toEqual({ tree1: null, tree2: null });
+        });
+        it('should fetch query children from url when children are missing', async () => {
+            tfs_1.TFSServices.getItemContent.mockResolvedValueOnce({
+                id: 'q3',
+                name: 'Fetched',
+                hasChildren: false,
+                isFolder: false,
+                queryType: 'flat',
+                columns: [],
+                wiql: "SELECT * FROM WorkItems WHERE [System.WorkItemType] = 'Bug'",
+                _links: { wiql: { href: 'http://example.com/wiql' } },
+            });
+            const res = await ticketsDataProvider.structureAllQueryPath({
+                id: 'q3',
+                url: 'https://example.com/q3',
+                name: 'NeedFetch',
+                hasChildren: true,
+                children: undefined,
+            });
+            expect(tfs_1.TFSServices.getItemContent).toHaveBeenCalledWith('https://example.com/q3?$depth=2&$expand=all', mockToken);
+            expect(res.tree1).toEqual(expect.objectContaining({ id: 'q3', pId: 'q3' }));
+        });
+    });
+    describe('parseTreeQueryResult', () => {
+        it('should build roots, skip non-hierarchy links, and dedupe children', async () => {
+            const initSpy = jest
+                .spyOn(ticketsDataProvider, 'initTreeQueryResultItem')
+                .mockImplementation(async (item, allItems) => {
+                allItems[item.id] = {
+                    id: item.id,
+                    title: `T${item.id}`,
+                    description: '',
+                    htmlUrl: `h${item.id}`,
+                    children: [],
+                };
+            });
+            const workItemRelations = [
+                { source: null, target: { id: 1, url: 'u1' }, rel: null },
+                { source: null, target: { id: 1, url: 'u1' }, rel: null },
+                {
+                    source: { id: 1, url: 'u1' },
+                    target: { id: 2, url: 'u2' },
+                    rel: 'System.LinkTypes.Hierarchy-Forward',
+                },
+                {
+                    source: { id: 1, url: 'u1' },
+                    target: { id: 2, url: 'u2' },
+                    rel: 'System.LinkTypes.Hierarchy-Forward',
+                },
+                {
+                    source: { id: 1, url: 'u1' },
+                    target: { id: 3, url: 'u3' },
+                    rel: 'System.LinkTypes.Related',
+                },
+            ];
+            const res = await ticketsDataProvider.parseTreeQueryResult({ workItemRelations });
+            expect(initSpy).toHaveBeenCalled();
+            expect(res.roots).toHaveLength(1);
+            expect(res.roots[0].id).toBe(1);
+            expect(res.roots[0].children).toHaveLength(1);
+            expect(res.roots[0].children[0].id).toBe(2);
+            expect(Object.keys(res.allItems)).toEqual(expect.arrayContaining(['1', '2', '3']));
+        });
+        it('should warn and initialize missing parent/child during hierarchy link processing when init no-ops first pass', async () => {
+            const warnSpy = jest.spyOn(logger_1.default, 'warn');
+            const callCountById = new Map();
+            jest
+                .spyOn(ticketsDataProvider, 'initTreeQueryResultItem')
+                .mockImplementation(async (item, allItems) => {
+                const count = (callCountById.get(item.id) || 0) + 1;
+                callCountById.set(item.id, count);
+                // First time: do nothing (simulate unexpected missing init)
+                if (count === 1)
+                    return;
+                // Second time: actually initialize
+                allItems[item.id] = {
+                    id: item.id,
+                    title: `T${item.id}`,
+                    description: '',
+                    htmlUrl: `h${item.id}`,
+                    children: [],
+                };
+            });
+            const workItemRelations = [
+                {
+                    source: { id: 10, url: 'u10' },
+                    target: { id: 11, url: 'u11' },
+                    rel: 'System.LinkTypes.Hierarchy-Forward',
+                },
+            ];
+            const res = await ticketsDataProvider.parseTreeQueryResult({ workItemRelations });
+            expect(warnSpy).toHaveBeenCalled();
+            expect(res.roots).toHaveLength(0);
+            expect(res.allItems[10]).toBeDefined();
+            expect(res.allItems[11]).toBeDefined();
+            expect(res.allItems[10].children).toHaveLength(1);
+            expect(res.allItems[10].children[0].id).toBe(11);
+        });
+    });
+    describe('flattenTreeToWorkItems', () => {
+        it('should flatten a roots tree into a list of work items', () => {
+            const roots = [
+                {
+                    id: 1,
+                    title: 'R1',
+                    description: 'D1',
+                    htmlUrl: 'h1',
+                    children: [{ id: 2, title: 'R2', description: 'D2', htmlUrl: 'h2', children: [] }],
+                },
+            ];
+            const res = ticketsDataProvider.flattenTreeToWorkItems(roots);
+            expect(res).toHaveLength(2);
+            expect(res[0]).toEqual(expect.objectContaining({ id: 1, url: 'h1' }));
+            expect(res[1]).toEqual(expect.objectContaining({ id: 2, url: 'h2' }));
+        });
+    });
+    describe('GetQueryResultsByWiqlHref', () => {
+        it('should fetch and model query results', async () => {
+            // Arrange
+            const mockWiqlHref = 'https://example.com/wiql';
+            const mockResults = {
+                workItems: [{ id: 1, url: 'https://example.com/wi/1' }],
+            };
+            const mockWiResponse = {
+                id: 1,
+                fields: { 'System.Title': 'Test' },
+                _links: { html: { href: 'https://example.com' } },
+            };
+            tfs_1.TFSServices.getItemContent
+                .mockResolvedValueOnce(mockResults)
+                .mockResolvedValueOnce(mockWiResponse);
+            // Act
+            const result = await ticketsDataProvider.GetQueryResultsByWiqlHref(mockWiqlHref, mockProject);
+            // Assert
+            expect(tfs_1.TFSServices.getItemContent).toHaveBeenCalledWith(mockWiqlHref, mockToken);
+        });
+    });
+    describe('GetWorkItemByUrl', () => {
+        it('should fetch work item by URL', async () => {
+            // Arrange
+            const mockUrl = 'https://dev.azure.com/org/project/_apis/wit/workitems/123';
+            // Act
+            const result = await ticketsDataProvider.GetWorkItemByUrl(mockUrl);
+            // Assert
+            expect(tfs_1.TFSServices.getItemContent).toHaveBeenCalled();
+        });
+    });
+    describe('GetSharedQueries - docType branches', () => {
+        it('should handle STR docType', async () => {
+            // Arrange
+            const mockQueries = {
+                children: [{ name: 'STR', isFolder: true, children: [] }],
+            };
+            tfs_1.TFSServices.getItemContent.mockResolvedValue(mockQueries);
+            // Act
+            const result = await ticketsDataProvider.GetSharedQueries(mockProject, '', 'str');
+            // Assert
+            expect(result).toBeDefined();
+        });
+        it('should handle test-reporter docType', async () => {
+            // Arrange
+            const mockQueries = {
+                children: [{ name: 'Test Reporter', isFolder: true, children: [] }],
+            };
+            tfs_1.TFSServices.getItemContent.mockResolvedValue(mockQueries);
+            // Act
+            const result = await ticketsDataProvider.GetSharedQueries(mockProject, '', 'test-reporter');
+            // Assert
+            expect(result).toBeDefined();
+        });
+        it('should handle SRS docType', async () => {
+            // Arrange
+            const mockQueries = {
+                children: [{ name: 'SRS', isFolder: true, children: [] }],
+            };
+            tfs_1.TFSServices.getItemContent.mockResolvedValue(mockQueries);
+            // Act
+            const result = await ticketsDataProvider.GetSharedQueries(mockProject, '', 'srs');
+            // Assert
+            expect(result).toBeDefined();
+        });
+        it('should handle unknown docType', async () => {
+            // Arrange
+            const mockQueries = { children: [] };
+            tfs_1.TFSServices.getItemContent.mockResolvedValue(mockQueries);
+            // Act
+            const result = await ticketsDataProvider.GetSharedQueries(mockProject, '', 'unknown');
+            // Assert
+            expect(result).toBeUndefined();
+        });
+        it('should handle error in GetSharedQueries', async () => {
+            // Arrange
+            tfs_1.TFSServices.getItemContent.mockRejectedValueOnce(new Error('API Error'));
+            // Act & Assert
+            await expect(ticketsDataProvider.GetSharedQueries(mockProject, '', 'std')).rejects.toThrow('API Error');
+            expect(logger_1.default.error).toHaveBeenCalled();
+        });
+    });
+    describe('PopulateWorkItemsByIds', () => {
+        it('should populate work items by IDs', async () => {
+            // Arrange
+            const mockIds = [1, 2, 3];
+            const mockResponse = {
+                value: [
+                    { id: 1, fields: { 'System.Title': 'Item 1' } },
+                    { id: 2, fields: { 'System.Title': 'Item 2' } },
+                    { id: 3, fields: { 'System.Title': 'Item 3' } },
+                ],
+            };
+            tfs_1.TFSServices.getItemContent.mockResolvedValueOnce(mockResponse);
+            // Act
+            const result = await ticketsDataProvider.PopulateWorkItemsByIds(mockIds, mockProject);
+            // Assert
+            expect(result).toEqual(mockResponse.value);
+        });
+        it('should handle empty IDs array', async () => {
+            // Arrange
+            const mockIds = [];
+            // Act
+            const result = await ticketsDataProvider.PopulateWorkItemsByIds(mockIds, mockProject);
+            // Assert
+            expect(result).toEqual([]);
+        });
+    });
+    describe('GetRelationsIds - edge cases', () => {
+        it('should return a Map from work items with relations', async () => {
+            // Arrange
+            const mockIds = [
+                {
+                    id: 1,
+                    relations: [{ rel: 'Parent', url: 'https://example.com/workitems/2' }],
+                },
+            ];
+            // Act
+            const result = await ticketsDataProvider.GetRelationsIds(mockIds);
+            // Assert
+            expect(result).toBeInstanceOf(Map);
+        });
+    });
+    describe('GetLinks - edge cases', () => {
+        it('should handle empty relations', async () => {
+            // Arrange
+            const mockWi = { relations: [] };
+            const mockLinks = [];
+            // Act
+            const result = await ticketsDataProvider.GetLinks(mockProject, mockWi, mockLinks);
+            // Assert
+            expect(result).toHaveLength(0);
+        });
+    });
+    describe('GetSharedQueries - path variations', () => {
+        it('should use path in URL when provided', async () => {
+            // Arrange
+            const mockPath = 'My Queries/Test';
+            const mockQueries = { children: [] };
+            tfs_1.TFSServices.getItemContent.mockResolvedValue(mockQueries);
+            // Act
+            await ticketsDataProvider.GetSharedQueries(mockProject, mockPath, '');
+            // Assert
+            expect(tfs_1.TFSServices.getItemContent).toHaveBeenCalledWith(expect.stringContaining(mockPath), mockToken);
+        });
+    });
+    describe('GetQueryResultById', () => {
+        it('should fetch query result by ID', async () => {
+            // Arrange
+            const mockQueryId = 'query-123';
+            const mockQuery = {
+                _links: { wiql: { href: 'https://example.com/wiql' } },
+            };
+            const mockWiqlResult = { workItems: [{ id: 1 }] };
+            const mockWiResponse = {
+                fields: { 'System.Title': 'Test' },
+                _links: { html: { href: 'https://example.com' } },
+            };
+            tfs_1.TFSServices.getItemContent
+                .mockResolvedValueOnce(mockQuery)
+                .mockResolvedValueOnce(mockWiqlResult)
+                .mockResolvedValueOnce(mockWiResponse);
+            // Act
+            const result = await ticketsDataProvider.GetQueryResultById(mockProject, mockQueryId);
+            // Assert
+            expect(tfs_1.TFSServices.getItemContent).toHaveBeenCalled();
+        });
+    });
+    describe('GetModeledQueryResults', () => {
+        it('should model Flat query results including System.Id and System.AssignedTo displayName', async () => {
+            const results = {
+                asOf: 'now',
+                queryResultType: 'workItem',
+                queryType: tfs_data_1.QueryType.Flat,
+                workItems: [{ id: '1', url: 'https://example.com/wi/1' }],
+                columns: [
+                    { name: 'ID', referenceName: 'System.Id', url: 'u1' },
+                    { name: 'Assigned To', referenceName: 'System.AssignedTo', url: 'u2' },
+                    { name: 'Custom', referenceName: 'Custom.Field', url: 'u3' },
+                ],
+            };
+            jest.spyOn(TicketsDataProvider_1.default.prototype, 'GetWorkItem').mockResolvedValueOnce({
+                id: 1,
+                url: 'https://example.com/wi/1',
+                fields: {
+                    'System.AssignedTo': { displayName: 'Bob' },
+                    'Custom.Field': 'X',
+                    'System.Id': 1,
+                },
+                relations: [{ rel: 'AttachedFile', url: 'https://example.com/a', attributes: { name: 'a.txt' } }],
+            });
+            const modeled = await ticketsDataProvider.GetModeledQueryResults(results, mockProject);
+            expect(modeled.queryType).toBe(tfs_data_1.QueryType.Flat);
+            expect(modeled.workItems).toHaveLength(1);
+            expect(modeled.workItems[0].attachments).toBeDefined();
+            // System.Id branch
+            expect(modeled.workItems[0].fields[0]).toEqual(expect.objectContaining({ name: 'ID', value: '1' }));
+            // System.AssignedTo branch
+            // Note: implementation does not set fields[i].name for AssignedTo branch
+            expect(modeled.workItems[0].fields[1]).toEqual(expect.objectContaining({ value: 'Bob' }));
+            // default field branch
+            expect(modeled.workItems[0].fields[2]).toEqual(expect.objectContaining({ name: 'Custom', value: 'X' }));
+        });
+        it('should model non-Flat query results using workItemRelations and set Source when present', async () => {
+            const results = {
+                asOf: 'now',
+                queryResultType: 'workItemLink',
+                queryType: tfs_data_1.QueryType.OneHop,
+                workItemRelations: [
+                    {
+                        source: { id: 10 },
+                        target: { id: 20 },
+                    },
+                ],
+                columns: [
+                    { name: 'Assigned To', referenceName: 'System.AssignedTo', url: 'u2' },
+                    { name: 'Title', referenceName: 'System.Title', url: 'u3' },
+                ],
+            };
+            jest.spyOn(TicketsDataProvider_1.default.prototype, 'GetWorkItem').mockResolvedValueOnce({
+                id: 20,
+                url: 'https://example.com/wi/20',
+                fields: {
+                    // Ensure AssignedTo branch falls through to the default path
+                    'System.AssignedTo': null,
+                    'System.Title': 'T20',
+                },
+                relations: null,
+            });
+            const modeled = await ticketsDataProvider.GetModeledQueryResults(results, mockProject);
+            expect(modeled.queryType).toBe(tfs_data_1.QueryType.OneHop);
+            expect(modeled.workItems).toHaveLength(1);
+            expect(modeled.workItems[0].Source).toBe(10);
+            expect(modeled.workItems[0].url).toBe('https://example.com/wi/20');
+        });
+    });
+    describe('GetCategorizedRequirementsByType', () => {
+        it('should categorize requirement items from queryResult.workItems and include priority=1 in precedence category', async () => {
+            const wiqlHref = `${mockOrgUrl}project1/_apis/wit/wiql/123`;
+            // Other tests in this file may set a persistent mockResolvedValue on getItemContent.
+            // clearAllMocks() does not reset implementations, so ensure a clean slate.
+            tfs_1.TFSServices.getItemContent.mockReset();
+            tfs_1.TFSServices.getItemContent
+                // query result
+                .mockResolvedValueOnce({ workItems: [{ id: 10 }, { id: 11 }, { id: 12 }, { id: 13 }] })
+                // getRequirementTypeFieldRefs(project)
+                .mockResolvedValueOnce({
+                value: [
+                    { name: 'Requirement Type', referenceName: 'Microsoft.VSTS.CMMI.RequirementType' },
+                    { name: 'Requirement_Type', referenceName: 'Custom.RequirementType' },
+                ],
+            })
+                // WI 10 requirement security, priority=1
+                .mockResolvedValueOnce({
+                id: 10,
+                fields: {
+                    'System.WorkItemType': 'Requirement',
+                    'System.Title': 'R10',
+                    'System.Description': 'D10',
+                    'Microsoft.VSTS.CMMI.RequirementType': 'Security',
+                    'Microsoft.VSTS.Common.Priority': 1,
+                },
+                _links: { html: { href: 'h10' } },
+            })
+                // WI 11 requirement unknown type -> Other Requirements
+                .mockResolvedValueOnce({
+                id: 11,
+                fields: {
+                    'System.WorkItemType': 'Requirement',
+                    'System.Title': 'R11',
+                    'System.Description': 'D11',
+                    'Microsoft.VSTS.CMMI.RequirementType': 'UnknownType',
+                },
+                _links: { html: { href: 'h11' } },
+            })
+                // WI 12 not a requirement -> skipped
+                .mockResolvedValueOnce({
+                id: 12,
+                fields: {
+                    'System.WorkItemType': 'Bug',
+                    'System.Title': 'B12',
+                },
+                _links: { html: { href: 'h12' } },
+            })
+                // WI 13 throws -> warn branch
+                .mockRejectedValueOnce(new Error('boom'));
+            const res = await ticketsDataProvider.GetCategorizedRequirementsByType(wiqlHref);
+            expect(res.totalCount).toBe(4);
+            expect(res.categories['Security and Privacy Requirements']).toHaveLength(1);
+            expect(res.categories['Precedence and Criticality of Requirements']).toHaveLength(1);
+            expect(res.categories['Other Requirements']).toHaveLength(1);
+            expect(logger_1.default.warn).toHaveBeenCalledWith(expect.stringContaining('Could not fetch work item 13'));
+        });
+        it('should extract IDs from workItemRelations for OneHop queries', async () => {
+            const wiqlHref = `${mockOrgUrl}project1/_apis/wit/wiql/rel`;
+            tfs_1.TFSServices.getItemContent.mockReset();
+            tfs_1.TFSServices.getItemContent
+                .mockResolvedValueOnce({
+                workItemRelations: [
+                    { source: { id: 10 }, target: { id: 20 } },
+                    { source: { id: 10 }, target: { id: 21 } },
+                ],
+            })
+                .mockResolvedValueOnce({ value: [] })
+                .mockResolvedValueOnce({
+                id: 10,
+                fields: { 'System.WorkItemType': 'Requirement', 'System.Title': 'R10' },
+                _links: { html: { href: 'h10' } },
+            })
+                .mockResolvedValueOnce({
+                id: 20,
+                fields: { 'System.WorkItemType': 'Bug', 'System.Title': 'B20' },
+                _links: { html: { href: 'h20' } },
+            })
+                .mockResolvedValueOnce({
+                id: 21,
+                fields: { 'System.WorkItemType': 'Requirement', 'System.Title': 'R21' },
+                _links: { html: { href: 'h21' } },
+            });
+            const res = await ticketsDataProvider.GetCategorizedRequirementsByType(wiqlHref);
+            expect(res.totalCount).toBe(3);
+        });
+        it('should return empty when query result has no workItems and no workItemRelations', async () => {
+            const wiqlHref = `${mockOrgUrl}project1/_apis/wit/wiql/empty`;
+            tfs_1.TFSServices.getItemContent.mockReset();
+            tfs_1.TFSServices.getItemContent.mockResolvedValueOnce({});
+            const res = await ticketsDataProvider.GetCategorizedRequirementsByType(wiqlHref);
+            expect(res).toEqual({ categories: {}, totalCount: 0 });
+            expect(logger_1.default.warn).toHaveBeenCalledWith(expect.stringContaining('No work items found in query result'));
+        });
+    });
+});
+//# sourceMappingURL=ticketsDataProvider.test.js.map