ado-sync 0.1.64 → 0.1.67

package/dist/azure/test-cases.d.ts

@@ -22,7 +22,7 @@ import { AzureClient } from './client';
  * Process tags for push: apply tag mapping and filter ignored tags.
  * Returns the transformed tags list ready for Azure DevOps.
  */
-export declare function processTagsForPush(tags: string[], tagPrefix: string | string[], customizations?: CustomizationsConfig): string[];
+export declare function processTagsForPush(tags: string[], tagPrefix: string | string[], customizations?: CustomizationsConfig, config?: SyncConfig): string[];
 /**
  * Build the Azure-facing title and steps for comparison/update logic.
  * This mirrors the transformation used by createTestCase/updateTestCase so
@@ -32,6 +32,14 @@ export declare function buildAzureSyncContent(test: ParsedTest, formatConfig: Fo
     title: string;
     steps: AzureStep[];
 };
+export declare function shouldCleanupEmptyGeneratedSuites(config: SyncConfig): boolean;
+export declare function usesGeneratedSuiteHierarchy(config: SyncConfig): boolean;
+export declare function getGeneratedSuitePathKey(config: SyncConfig, filePath: string, configDir: string): string | undefined;
+export declare function getGeneratedSuitePathKeyForTest(config: SyncConfig, test: ParsedTest, configDir: string): string | undefined;
+export declare function resolveExistingSuiteForFile(client: AzureClient, config: SyncConfig, filePath: string, configDir: string, suiteCache: Map<string, number>): Promise<number | undefined>;
+export declare function resolveExistingSuiteForPathKey(client: AzureClient, config: SyncConfig, pathKey: string, suiteCache: Map<string, number>): Promise<number | undefined>;
+export declare function pruneEmptyGeneratedSuitesForFile(client: AzureClient, config: SyncConfig, filePath: string, configDir: string, suiteCache: Map<string, number>): Promise<void>;
+export declare function pruneEmptyGeneratedSuitesForPathKey(client: AzureClient, config: SyncConfig, pathKey: string, suiteCache: Map<string, number>): Promise<void>;
 /**
  * Get or create a named static suite directly under the plan's root suite.
  * Used by suiteRouting to resolve named route targets.
@@ -47,6 +55,7 @@ export declare function getOrCreateNamedSuite(client: AzureClient, config: SyncC
  * Uses suiteCache (Map<relPath, suiteId>) to avoid redundant API calls.
  */
 export declare function getOrCreateSuiteForFile(client: AzureClient, config: SyncConfig, filePath: string, configDir: string, suiteCache: Map<string, number>): Promise<number>;
+export declare function getOrCreateGeneratedSuiteForTest(client: AzureClient, config: SyncConfig, test: ParsedTest, configDir: string, suiteCache: Map<string, number>): Promise<number>;
 export declare function getTestCase(client: AzureClient, id: number, titleField?: string): Promise<AzureTestCase | null>;
 export declare function createTestCase(client: AzureClient, test: ParsedTest, config: SyncConfig, suiteIdOverride?: number, configDir?: string): Promise<number>;
 export declare function updateTestCase(client: AzureClient, id: number, test: ParsedTest, config: SyncConfig, configDir?: string): Promise<void>;
@@ -63,6 +72,7 @@ export declare function tagTestCaseAsRemoved(client: AzureClient, id: number, re
  */
 export declare function retireTestCase(client: AzureClient, id: number, targetState?: string): Promise<void>;
 export declare function addTestCaseToSuite(client: AzureClient, config: SyncConfig, testCaseId: number, suiteId: number): Promise<void>;
+export declare function removeTestCaseFromSuite(client: AzureClient, config: SyncConfig, testCaseId: number, suiteId: number): Promise<void>;
 export declare function addTestCaseToRootSuite(client: AzureClient, config: SyncConfig, testCaseId: number): Promise<void>;
 /**
  * Add a test case to every suite whose condition matches the given test.

package/dist/azure/test-cases.js

@@ -56,8 +56,17 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.processTagsForPush = processTagsForPush;
 exports.buildAzureSyncContent = buildAzureSyncContent;
+exports.shouldCleanupEmptyGeneratedSuites = shouldCleanupEmptyGeneratedSuites;
+exports.usesGeneratedSuiteHierarchy = usesGeneratedSuiteHierarchy;
+exports.getGeneratedSuitePathKey = getGeneratedSuitePathKey;
+exports.getGeneratedSuitePathKeyForTest = getGeneratedSuitePathKeyForTest;
+exports.resolveExistingSuiteForFile = resolveExistingSuiteForFile;
+exports.resolveExistingSuiteForPathKey = resolveExistingSuiteForPathKey;
+exports.pruneEmptyGeneratedSuitesForFile = pruneEmptyGeneratedSuitesForFile;
+exports.pruneEmptyGeneratedSuitesForPathKey = pruneEmptyGeneratedSuitesForPathKey;
 exports.getOrCreateNamedSuite = getOrCreateNamedSuite;
 exports.getOrCreateSuiteForFile = getOrCreateSuiteForFile;
+exports.getOrCreateGeneratedSuiteForTest = getOrCreateGeneratedSuiteForTest;
 exports.getTestCase = getTestCase;
 exports.createTestCase = createTestCase;
 exports.updateTestCase = updateTestCase;
@@ -65,6 +74,7 @@ exports.updateLocalFromAzure = updateLocalFromAzure;
 exports.tagTestCaseAsRemoved = tagTestCaseAsRemoved;
 exports.retireTestCase = retireTestCase;
 exports.addTestCaseToSuite = addTestCaseToSuite;
+exports.removeTestCaseFromSuite = removeTestCaseFromSuite;
 exports.addTestCaseToRootSuite = addTestCaseToRootSuite;
 exports.addTestCaseToConditionSuites = addTestCaseToConditionSuites;
 exports.getTestCasesInSuite = getTestCasesInSuite;
@@ -347,12 +357,16 @@ function isIgnoredTag(tag, ignorePatterns) {
  * Process tags for push: apply tag mapping and filter ignored tags.
  * Returns the transformed tags list ready for Azure DevOps.
  */
-function processTagsForPush(tags, tagPrefix, customizations) {
+function processTagsForPush(tags, tagPrefix, customizations, config) {
     let processed = tags.filter((t) => !(0, id_markers_1.isMarkerTag)(t, tagPrefix));
     // Apply tag text map transformation
     if (customizations?.tagTextMapTransformation?.enabled && customizations.tagTextMapTransformation.textMap) {
         processed = applyTagTextMap(processed, customizations.tagTextMapTransformation.textMap);
     }
+    const ownershipTag = config ? (0, id_markers_1.getSyncTargetOwnershipTag)(config) : undefined;
+    if (ownershipTag && !processed.includes(ownershipTag)) {
+        processed = [...processed, ownershipTag];
+    }
     return processed;
 }
 // ─── State change helpers ────────────────────────────────────────────────────
@@ -790,12 +804,65 @@ async function applyLinkRelations(client, tcId, test, config, isCreate) {
 }
 // ─── Suite hierarchy helpers ──────────────────────────────────────────────────
 async function resolveRootSuiteId(client, config) {
+    const syncTargetSuiteId = config.syncTarget?.mode === 'query' ? undefined : config.syncTarget?.suiteId;
+    if (syncTargetSuiteId)
+        return syncTargetSuiteId;
     if (config.testPlan.suiteId)
         return config.testPlan.suiteId;
     const api = await client.getTestPlanApi();
     const plan = await api.getTestPlanById(config.project, config.testPlan.id);
     return plan?.rootSuite?.id ?? 0;
 }
+function buildAzureTestCaseFromWorkItem(workItem, titleField) {
+    const fields = workItem?.fields ?? {};
+    return {
+        id: workItem.id,
+        title: fields[titleField] ?? '',
+        description: fields['System.Description'] ?? '',
+        steps: parseStepsXml(fields['Microsoft.VSTS.TCM.Steps'] ?? ''),
+        tags: tagsFromString(fields['System.Tags']),
+        changedDate: fields['System.ChangedDate'],
+        areaPath: fields['System.AreaPath'],
+        iterationPath: fields['System.IterationPath'],
+        automatedTestName: fields['Microsoft.VSTS.TCM.AutomatedTestName'] || undefined,
+    };
+}
+function getRemoteScopeSuiteId(config, suiteId) {
+    if (suiteId)
+        return suiteId;
+    if (config.syncTarget?.mode !== 'query' && config.syncTarget?.suiteId)
+        return config.syncTarget.suiteId;
+    return config.testPlan.suiteId;
+}
+function filterScopedTestCases(testCases, config) {
+    const ownershipTag = (0, id_markers_1.getSyncTargetOwnershipTag)(config);
+    if (!ownershipTag)
+        return testCases;
+    const normalizedOwnershipTag = ownershipTag.toLowerCase();
+    return testCases.filter((testCase) => testCase.tags.some((tag) => tag.toLowerCase() === normalizedOwnershipTag));
+}
+async function getTestCasesByWiql(client, config, titleField, wiql) {
+    const wit = await client.getWitApi();
+    const queryResult = await withRetry(() => wit.queryByWiql({ query: wiql }, { project: config.project }));
+    const ids = (queryResult?.workItems ?? []).map((ref) => ref.id).filter(Boolean);
+    if (!ids.length)
+        return [];
+    const fields = [
+        titleField,
+        'System.WorkItemType',
+        'System.Description',
+        'Microsoft.VSTS.TCM.Steps',
+        'System.Tags',
+        'System.ChangedDate',
+        'System.AreaPath',
+        'System.IterationPath',
+        'Microsoft.VSTS.TCM.AutomatedTestName',
+    ];
+    const workItems = await withRetry(() => wit.getWorkItems(ids, fields));
+    return (workItems ?? [])
+        .filter((workItem) => (workItem?.fields?.['System.WorkItemType'] ?? '') === 'Test Case')
+        .map((workItem) => buildAzureTestCaseFromWorkItem(workItem, titleField));
+}
 async function getOrCreateChildSuite(client, config, parentSuiteId, suiteName) {
     const api = await client.getTestPlanApi();
     const suites = await api.getTestSuitesForPlan(config.project, config.testPlan.id);
@@ -809,6 +876,192 @@ async function getOrCreateChildSuite(client, config, parentSuiteId, suiteName) {
     }, config.project, config.testPlan.id);
     return created?.id ?? parentSuiteId;
 }
+function getSuiteHierarchy(config) {
+    if (config.testPlan.hierarchy)
+        return config.testPlan.hierarchy;
+    if (config.testPlan.suiteMapping === 'byFolder' || config.testPlan.suiteMapping === 'byFile') {
+        return { mode: config.testPlan.suiteMapping };
+    }
+    return undefined;
+}
+function shouldCleanupEmptyGeneratedSuites(config) {
+    return getSuiteHierarchy(config)?.cleanupEmptySuites === true;
+}
+function getGeneratedSuiteSegments(config, filePath, configDir) {
+    const hierarchy = getSuiteHierarchy(config);
+    if (!hierarchy)
+        return undefined;
+    const relFile = path.relative(configDir, filePath);
+    const allSegments = relFile.split(path.sep);
+    const dirSegments = allSegments.slice(0, -1);
+    const fileName = path.basename(filePath, path.extname(filePath));
+    const rawSegments = hierarchy.mode === 'byFile' ? [...dirSegments, fileName] : dirSegments;
+    const cleanSegments = rawSegments.map((segment) => segment.replace(/^@/, '')).filter(Boolean);
+    return hierarchy.rootSuite ? [hierarchy.rootSuite, ...cleanSegments] : cleanSegments;
+}
+function getGeneratedSuiteSegmentsForTagHierarchy(hierarchy, test) {
+    return getTagHierarchySegments(test, hierarchy.tagPrefix, hierarchy.valueSeparator);
+}
+function getTagHierarchySegments(test, tagPrefix, valueSeparator) {
+    const normalizedPrefix = tagPrefix.trim().replace(/^@/, '').toLowerCase();
+    const separator = valueSeparator ?? '/';
+    const matchingTag = test.tags.find((tag) => {
+        const normalizedTag = tag.replace(/^@/, '');
+        return normalizedTag.toLowerCase().startsWith(`${normalizedPrefix}:`);
+    });
+    if (!matchingTag) {
+        return [];
+    }
+    const normalizedTag = matchingTag.replace(/^@/, '');
+    const rawValue = normalizedTag.slice(normalizedPrefix.length + 1);
+    return rawValue
+        .split(separator)
+        .map((segment) => segment.trim().replace(/^@/, ''))
+        .filter(Boolean);
+}
+function getGeneratedSuiteSegmentsForLevelsHierarchy(hierarchy, test, configDir) {
+    const relFile = path.relative(configDir, test.filePath);
+    const allSegments = relFile.split(path.sep);
+    const dirSegments = allSegments.slice(0, -1);
+    const fileName = path.basename(test.filePath, path.extname(test.filePath));
+    const resolvedSegments = [];
+    for (const level of hierarchy.levels ?? []) {
+        if (level.source === 'folder') {
+            const segment = dirSegments[level.index];
+            if (segment) {
+                resolvedSegments.push(segment.replace(/^@/, ''));
+            }
+            continue;
+        }
+        if (level.source === 'file') {
+            resolvedSegments.push(fileName.replace(/^@/, ''));
+            continue;
+        }
+        resolvedSegments.push(...getTagHierarchySegments(test, level.tagPrefix, level.valueSeparator));
+    }
+    const cleanSegments = resolvedSegments.filter(Boolean);
+    return hierarchy.rootSuite ? [hierarchy.rootSuite, ...cleanSegments] : cleanSegments;
+}
+function getGeneratedSuiteSegmentsForTest(config, test, configDir) {
+    const hierarchy = getSuiteHierarchy(config);
+    if (!hierarchy)
+        return undefined;
+    if (hierarchy.mode === 'byTag') {
+        const tagSegments = getGeneratedSuiteSegmentsForTagHierarchy(hierarchy, test);
+        return hierarchy.rootSuite ? [hierarchy.rootSuite, ...tagSegments] : tagSegments;
+    }
+    if (hierarchy.mode === 'byLevels') {
+        return getGeneratedSuiteSegmentsForLevelsHierarchy(hierarchy, test, configDir);
+    }
+    return getGeneratedSuiteSegments(config, test.filePath, configDir);
+}
+function usesGeneratedSuiteHierarchy(config) {
+    return getSuiteHierarchy(config) !== undefined;
+}
+function getGeneratedSuitePathKey(config, filePath, configDir) {
+    const segments = getGeneratedSuiteSegments(config, filePath, configDir);
+    return segments ? segments.join('/') : undefined;
+}
+function getGeneratedSuitePathKeyForTest(config, test, configDir) {
+    const segments = getGeneratedSuiteSegmentsForTest(config, test, configDir);
+    return segments ? segments.join('/') : undefined;
+}
+async function resolveSuiteForSegments(client, config, segments, suiteCache, createMissing) {
+    const baseRootSuiteId = await resolveRootSuiteId(client, config);
+    if (!segments.length)
+        return baseRootSuiteId;
+    const api = await client.getTestPlanApi();
+    const suites = await api.getTestSuitesForPlan(config.project, config.testPlan.id);
+    let parentId = baseRootSuiteId;
+    let cacheKey = '';
+    for (const seg of segments) {
+        cacheKey = cacheKey ? `${cacheKey}/${seg}` : seg;
+        if (suiteCache.has(cacheKey)) {
+            parentId = suiteCache.get(cacheKey);
+            continue;
+        }
+        const existing = (suites ?? []).find((suite) => suite.parentSuite?.id === parentId && suite.name === seg);
+        if (existing?.id) {
+            parentId = existing.id;
+            suiteCache.set(cacheKey, parentId);
+            continue;
+        }
+        if (!createMissing)
+            return undefined;
+        parentId = await getOrCreateChildSuite(client, config, parentId, seg);
+        suiteCache.set(cacheKey, parentId);
+    }
+    return parentId;
+}
+function dropSuiteCacheBranch(suiteCache, pathKey) {
+    for (const key of [...suiteCache.keys()]) {
+        if (key === pathKey || key.startsWith(`${pathKey}/`)) {
+            suiteCache.delete(key);
+        }
+    }
+}
+async function resolveExistingSuiteForFile(client, config, filePath, configDir, suiteCache) {
+    const segments = getGeneratedSuiteSegments(config, filePath, configDir);
+    if (!segments)
+        return undefined;
+    return resolveSuiteForSegments(client, config, segments, suiteCache, false);
+}
+async function resolveExistingSuiteForPathKey(client, config, pathKey, suiteCache) {
+    const segments = pathKey.split('/').filter(Boolean);
+    if (!segments.length)
+        return undefined;
+    return resolveSuiteForSegments(client, config, segments, suiteCache, false);
+}
+async function pruneEmptyGeneratedSuitesForFile(client, config, filePath, configDir, suiteCache) {
+    const hierarchy = getSuiteHierarchy(config);
+    const segments = getGeneratedSuiteSegments(config, filePath, configDir);
+    if (!hierarchy || !segments?.length)
+        return;
+    const api = await client.getTestPlanApi();
+    const rootSuiteId = await resolveRootSuiteId(client, config);
+    const protectedDepth = hierarchy.rootSuite ? 1 : 0;
+    for (let depth = segments.length; depth > protectedDepth; depth--) {
+        const pathSegments = segments.slice(0, depth);
+        const pathKey = pathSegments.join('/');
+        const suiteId = await resolveSuiteForSegments(client, config, pathSegments, suiteCache, false);
+        if (!suiteId || suiteId === rootSuiteId)
+            continue;
+        const suites = await api.getTestSuitesForPlan(config.project, config.testPlan.id);
+        const childSuites = (suites ?? []).filter((suite) => suite.parentSuite?.id === suiteId);
+        if (childSuites.length > 0)
+            break;
+        const testCases = await api.getTestCaseList(config.project, config.testPlan.id, suiteId);
+        if ((testCases?.length ?? 0) > 0)
+            break;
+        await api.deleteTestSuite(config.project, config.testPlan.id, suiteId);
+        dropSuiteCacheBranch(suiteCache, pathKey);
+    }
+}
+async function pruneEmptyGeneratedSuitesForPathKey(client, config, pathKey, suiteCache) {
+    const hierarchy = getSuiteHierarchy(config);
+    const segments = pathKey.split('/').filter(Boolean);
+    if (!hierarchy || !segments.length)
+        return;
+    const api = await client.getTestPlanApi();
+    const rootSuiteId = await resolveRootSuiteId(client, config);
+    const protectedDepth = hierarchy.rootSuite ? 1 : 0;
+    for (let depth = segments.length; depth > protectedDepth; depth--) {
+        const pathSegments = segments.slice(0, depth);
+        const currentPathKey = pathSegments.join('/');
+        const suiteId = await resolveSuiteForSegments(client, config, pathSegments, suiteCache, false);
+        if (!suiteId || suiteId === rootSuiteId)
+            continue;
+        const suites = await api.getTestSuitesForPlan(config.project, config.testPlan.id);
+        const childSuites = (suites ?? []).filter((suite) => suite.parentSuite?.id === suiteId);
+        if (childSuites.length > 0)
+            break;
+        const testCases = await api.getTestCaseList(config.project, config.testPlan.id, suiteId);
+        if ((testCases?.length ?? 0) > 0)
+            break;
+        await api.deleteTestSuite(config.project, config.testPlan.id, suiteId);
+        dropSuiteCacheBranch(suiteCache, currentPathKey);
+    }
+}
 /**
  * Get or create a named static suite directly under the plan's root suite.
  * Used by suiteRouting to resolve named route targets.
@@ -827,30 +1080,18 @@ async function getOrCreateNamedSuite(client, config, suiteName) {
  * Uses suiteCache (Map<relPath, suiteId>) to avoid redundant API calls.
  */
 async function getOrCreateSuiteForFile(client, config, filePath, configDir, suiteCache) {
-    const rootSuiteId = await resolveRootSuiteId(client, config);
-    const relFile = path.relative(configDir, filePath);
-    const allSegments = relFile.split(path.sep);
-    // byFile: include the filename (without extension) as the deepest suite segment
-    const byFile = config.testPlan.suiteMapping === 'byFile';
-    const dirSegments = allSegments.slice(0, -1);
-    const fileName = path.basename(filePath, path.extname(filePath));
-    const rawSegments = byFile ? [...dirSegments, fileName] : dirSegments;
-    const cleanSegments = rawSegments.map((s) => s.replace(/^@/, '')).filter(Boolean);
-    if (!cleanSegments.length)
-        return rootSuiteId;
-    let parentId = rootSuiteId;
-    let cacheKey = '';
-    for (const seg of cleanSegments) {
-        cacheKey = cacheKey ? `${cacheKey}/${seg}` : seg;
-        if (suiteCache.has(cacheKey)) {
-            parentId = suiteCache.get(cacheKey);
-        }
-        else {
-            parentId = await getOrCreateChildSuite(client, config, parentId, seg);
-            suiteCache.set(cacheKey, parentId);
-        }
+    const segments = getGeneratedSuiteSegments(config, filePath, configDir);
+    if (!segments) {
+        return resolveRootSuiteId(client, config);
     }
-    return parentId;
+    return (await resolveSuiteForSegments(client, config, segments, suiteCache, true)) ?? await resolveRootSuiteId(client, config);
+}
+async function getOrCreateGeneratedSuiteForTest(client, config, test, configDir, suiteCache) {
+    const segments = getGeneratedSuiteSegmentsForTest(config, test, configDir);
+    if (!segments) {
+        return resolveRootSuiteId(client, config);
+    }
+    return (await resolveSuiteForSegments(client, config, segments, suiteCache, true)) ?? await resolveRootSuiteId(client, config);
 }
 // ─── API layer ───────────────────────────────────────────────────────────────
 async function getTestCase(client, id, titleField = 'System.Title') {
@@ -916,7 +1157,7 @@ async function createTestCase(client, test, config, suiteIdOverride, configDir)
         }
     }
     // Process tags: apply tag text map transformation
-    const processedTags = processTagsForPush(test.tags, syncCfg.tagPrefix ?? 'tc', config.customizations);
+    const processedTags = processTagsForPush(test.tags, syncCfg.tagPrefix ?? 'tc', config.customizations, config);
     const filteredTags = processedTags.join('; ');
     if (filteredTags) {
         patchDoc.push({ op: 'add', path: '/fields/System.Tags', value: filteredTags });
@@ -941,7 +1182,7 @@ async function createTestCase(client, test, config, suiteIdOverride, configDir)
     }
     if (!wi?.id)
         throw new Error(`Failed to create test case for: ${test.title} — Azure returned no work item ID. Check that the project name, plan ID, and PAT permissions (Test Management: Write) are correct.`);
-    const resolvedSuiteId = suiteIdOverride ?? config.testPlan.suiteId;
+    const resolvedSuiteId = suiteIdOverride ?? getRemoteScopeSuiteId(config);
     if (resolvedSuiteId) {
         await addTestCaseToSuite(client, config, wi.id, resolvedSuiteId);
     }
@@ -960,7 +1201,7 @@ async function updateTestCase(client, id, test, config, configDir) {
     const titleField = syncCfg.titleField ?? 'System.Title';
     const { title, steps } = buildAzureSyncContent(test, syncCfg.format);
     // Process tags with transformations
-    const processedLocalTags = processTagsForPush(test.tags, syncCfg.tagPrefix ?? 'tc', config.customizations);
+    const processedLocalTags = processTagsForPush(test.tags, syncCfg.tagPrefix ?? 'tc', config.customizations, config);
     // Fetch existing Azure tags and parameter fields so updates can merge/clear correctly.
     const wi = await withRetry(() => wit.getWorkItem(id, [
         'System.Tags',
@@ -1081,6 +1322,18 @@ async function addTestCaseToSuite(client, config, testCaseId, suiteId) {
         throw err;
     }
 }
+async function removeTestCaseFromSuite(client, config, testCaseId, suiteId) {
+    const api = await client.getTestPlanApi();
+    try {
+        await api.removeTestCasesFromSuite(config.project, config.testPlan.id, suiteId, String(testCaseId));
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        if (/not found|does not exist|invalid/i.test(msg))
+            return;
+        throw err;
+    }
+}
 async function addTestCaseToRootSuite(client, config, testCaseId) {
     const api = await client.getTestPlanApi();
     const plan = await api.getTestPlanById(config.project, config.testPlan.id);
@@ -1130,10 +1383,13 @@ async function addTestCaseToConditionSuites(client, config, testCaseId, test, co
     }
 }
 async function getTestCasesInSuite(client, config, suiteId) {
+    const titleField = config.sync?.titleField ?? 'System.Title';
+    if (config.syncTarget?.mode === 'query') {
+        return filterScopedTestCases(await getTestCasesByWiql(client, config, titleField, config.syncTarget.wiql), config);
+    }
     const api = await client.getTestPlanApi();
     const wit = await client.getWitApi();
-    const titleField = config.sync?.titleField ?? 'System.Title';
-    let resolvedSuiteId = suiteId ?? config.testPlan.suiteId;
+    let resolvedSuiteId = getRemoteScopeSuiteId(config, suiteId);
     if (!resolvedSuiteId) {
         const plan = await api.getTestPlanById(config.project, config.testPlan.id);
         resolvedSuiteId = plan?.rootSuite?.id;
@@ -1157,19 +1413,6 @@ async function getTestCasesInSuite(client, config, suiteId) {
     if (!ids.length)
         return [];
     const workItems = await withRetry(() => wit.getWorkItems(ids, fields));
-    return (workItems ?? []).map((wi) => {
-        const f = wi.fields ?? {};
-        return {
-            id: wi.id,
-            title: f[titleField] ?? '',
-            description: f['System.Description'] ?? '',
-            steps: parseStepsXml(f['Microsoft.VSTS.TCM.Steps'] ?? ''),
-            tags: tagsFromString(f['System.Tags']),
-            changedDate: f['System.ChangedDate'],
-            areaPath: f['System.AreaPath'],
-            iterationPath: f['System.IterationPath'],
-            automatedTestName: f['Microsoft.VSTS.TCM.AutomatedTestName'] || undefined,
-        };
-    });
+    return filterScopedTestCases((workItems ?? []).map((workItem) => buildAzureTestCaseFromWorkItem(workItem, titleField)), config);
 }
 //# sourceMappingURL=test-cases.js.map