@microsoft/terraform-cdk-constructs 1.0.0 → 1.3.0

package/lib/testing/lib/cleanup.d.ts

@@ -0,0 +1,230 @@
+/**
+ * Cleanup and verification utilities for integration tests
+ *
+ * Provides functions for verifying resource deletion via Azure Resource Graph
+ * and finding/cleaning orphaned resources with comprehensive safety mechanisms.
+ */
+/**
+ * Metadata for an individual resource created during testing
+ */
+export interface ResourceMetadata {
+    /**
+     * Azure resource ID
+     */
+    readonly resourceId: string;
+    /**
+     * Azure resource type (e.g., 'Microsoft.Resources/resourceGroups')
+     */
+    readonly resourceType: string;
+    /**
+     * Resource name
+     */
+    readonly name: string;
+    /**
+     * Resource location (Azure region)
+     */
+    readonly location?: string;
+    /**
+     * Resource tags
+     */
+    readonly tags: Record<string, string>;
+    /**
+     * Test run ID that created this resource
+     */
+    readonly testRunId: string;
+    /**
+     * Timestamp when resource was created
+     */
+    readonly createdAt: Date;
+    /**
+     * Whether this resource was successfully destroyed
+     */
+    readonly destroyed?: boolean;
+    /**
+     * Timestamp when resource was destroyed
+     */
+    readonly destroyedAt?: Date;
+}
+/**
+ * Result of resource cleanup verification
+ */
+export interface VerificationResult {
+    /**
+     * Whether verification succeeded (all resources deleted)
+     */
+    readonly success: boolean;
+    /**
+     * Human-readable message describing the result
+     */
+    readonly message: string;
+    /**
+     * List of orphaned resource IDs (if any)
+     */
+    readonly orphanedResources: string[];
+    /**
+     * Number of resources expected to be deleted
+     */
+    readonly expectedCount?: number;
+    /**
+     * Number of resources actually found
+     */
+    readonly foundCount?: number;
+}
+/**
+ * Options for cleanup operations
+ */
+export interface CleanupOptions {
+    /**
+     * Whether to perform dry-run (no actual deletion)
+     */
+    readonly dryRun: boolean;
+    /**
+     * Minimum age in hours before resource can be cleaned up
+     * Set to 0 to force cleanup of all resources regardless of age (bypasses safety checks)
+     */
+    readonly minAgeHours: number;
+    /**
+     * Azure subscription ID to target (optional)
+     */
+    readonly subscription?: string;
+    /**
+     * Specific resource groups to target (optional)
+     */
+    readonly resourceGroups?: string[];
+    /**
+     * Maximum number of resources to clean up in one operation
+     */
+    readonly maxResources?: number;
+}
+/**
+ * Orphaned resource information
+ */
+export interface OrphanedResource {
+    /**
+     * Azure resource ID
+     */
+    readonly resourceId: string;
+    /**
+     * Azure resource type
+     */
+    readonly resourceType: string;
+    /**
+     * Resource name
+     */
+    readonly name: string;
+    /**
+     * Resource location
+     */
+    readonly location: string;
+    /**
+     * Resource group name
+     */
+    readonly resourceGroup: string;
+    /**
+     * Test run ID from tags
+     */
+    readonly testRunId: string;
+    /**
+     * Creation timestamp from tags
+     */
+    readonly createdAt: Date;
+    /**
+     * Cleanup after timestamp from tags
+     */
+    readonly cleanupAfter: Date;
+    /**
+     * Test name from tags
+     */
+    readonly testName: string;
+    /**
+     * Age in hours since creation
+     */
+    readonly ageHours: number;
+}
+/**
+ * Result of cleanup operation
+ */
+export interface CleanupResult {
+    /**
+     * Number of resources successfully deleted
+     */
+    readonly deleted: number;
+    /**
+     * Number of resources that failed to delete
+     */
+    readonly failed: number;
+    /**
+     * Number of resources skipped (e.g., too young)
+     */
+    readonly skipped: number;
+    /**
+     * Detailed error messages for failures
+     */
+    readonly errors?: string[];
+}
+/**
+ * Main cleanup service class
+ */
+export declare class ResourceCleanupService {
+    /**
+     * Checks if Azure CLI is available
+     */
+    checkAzureCliAvailable(): boolean;
+    /**
+     * Executes an Azure CLI command with error handling
+     */
+    private executeAzureCommand;
+    /**
+     * Queries Azure Resource Graph for resources by tags
+     *
+     * Returns empty array on errors for graceful degradation.
+     */
+    queryAzureResourcesByTags(tags: Record<string, string>, subscription?: string): any[];
+}
+/**
+ * Verifies that all resources with a specific test run ID are deleted
+ *
+ * Performs Azure Resource Graph query to check for remaining resources.
+ * Implements retry logic to handle Azure's eventual consistency.
+ *
+ * @param runId - Test run UUID to verify
+ * @param expectedResources - List of resources that should be deleted
+ * @param subscription - Optional subscription ID to query
+ * @returns Verification result with details
+ */
+export declare function verifyResourcesDeleted(runId: string, expectedResources: ResourceMetadata[], subscription?: string): VerificationResult;
+/**
+ * Finds orphaned test resources that are past their TTL
+ *
+ * Queries Azure for resources with test tags that are older than
+ * their cleanup-after timestamp.
+ *
+ * @param options - Cleanup options
+ * @returns List of orphaned resources
+ */
+export declare function findOrphanedResources(options: CleanupOptions): Promise<OrphanedResource[]>;
+/**
+ * Cleans up orphaned test resources
+ *
+ * Deletes resource groups containing orphaned test resources.
+ * Implements safety checks and dry-run mode.
+ *
+ * @param resources - List of orphaned resources to clean up
+ * @param options - Cleanup options
+ * @returns Cleanup result with statistics
+ */
+export declare function cleanupOrphanedResources(resources: OrphanedResource[], options: CleanupOptions): Promise<CleanupResult>;
+/**
+ * Verifies resource cleanup with retry logic for eventual consistency
+ *
+ * Wrapper around verifyResourcesDeleted that implements retry logic
+ * to handle Azure's eventual consistency delays.
+ *
+ * @param runId - Test run UUID to verify
+ * @param expectedResources - List of resources that should be deleted
+ * @param subscription - Optional subscription ID to query
+ * @param maxRetries - Maximum number of retry attempts
+ * @param retryWaitMs - Wait time between retries in milliseconds
+ * @returns Final verification result
+ */
+export declare function verifyResourcesDeletedWithRetry(runId: string, expectedResources: ResourceMetadata[], subscription?: string, maxRetries?: number, retryWaitMs?: number): Promise<VerificationResult>;

package/lib/testing/lib/cleanup.js

@@ -0,0 +1,338 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ResourceCleanupService = void 0;
+exports.verifyResourcesDeleted = verifyResourcesDeleted;
+exports.findOrphanedResources = findOrphanedResources;
+exports.cleanupOrphanedResources = cleanupOrphanedResources;
+exports.verifyResourcesDeletedWithRetry = verifyResourcesDeletedWithRetry;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+/**
+ * Cleanup and verification utilities for integration tests
+ *
+ * Provides functions for verifying resource deletion via Azure Resource Graph
+ * and finding/cleaning orphaned resources with comprehensive safety mechanisms.
+ */
+const child_process_1 = require("child_process");
+/**
+ * Minimum age threshold (hours) before cleanup is allowed
+ */
+const MINIMUM_AGE_HOURS = 2;
+/**
+ * Maximum retry attempts for eventual consistency
+ */
+const MAX_RETRIES = 5;
+/**
+ * Wait time between retries (milliseconds)
+ */
+const RETRY_WAIT_MS = 30000; // 30 seconds
+/**
+ * Main cleanup service class
+ */
+class ResourceCleanupService {
+    /**
+     * Checks if Azure CLI is available
+     */
+    checkAzureCliAvailable() {
+        try {
+            (0, child_process_1.execSync)("az --version", { stdio: "pipe" });
+            return true;
+        }
+        catch (error) {
+            return false;
+        }
+    }
+    /**
+     * Executes an Azure CLI command with error handling
+     */
+    executeAzureCommand(command) {
+        try {
+            return (0, child_process_1.execSync)(command, {
+                encoding: "utf-8",
+                stdio: "pipe",
+            });
+        }
+        catch (error) {
+            throw new Error(`Azure CLI command failed: ${error.message}\n` +
+                `Command: ${command}\n` +
+                `Stderr: ${error.stderr?.toString() || "N/A"}`);
+        }
+    }
+    /**
+     * Queries Azure Resource Graph for resources by tags
+     *
+     * Returns empty array on errors for graceful degradation.
+     */
+    queryAzureResourcesByTags(tags, subscription) {
+        // Build tag filter conditions
+        const tagConditions = Object.entries(tags)
+            .map(([key, value]) => `tags['${key}'] == '${value}'`)
+            .join(" and ");
+        const query = `
+      Resources
+      | where ${tagConditions}
+      | project id, type, name, location, resourceGroup, tags
+    `;
+        const subscriptionArg = subscription
+            ? `--subscriptions "${subscription}"`
+            : "";
+        const command = `az graph query -q "${query.replace(/\n/g, " ")}" ${subscriptionArg} --output json`;
+        try {
+            const result = this.executeAzureCommand(command);
+            const parsed = JSON.parse(result);
+            return parsed.data || [];
+        }
+        catch (error) {
+            console.error("Failed to query Azure Resource Graph:", error.message);
+            return [];
+        }
+    }
+}
+exports.ResourceCleanupService = ResourceCleanupService;
+_a = JSII_RTTI_SYMBOL_1;
+ResourceCleanupService[_a] = { fqn: "@microsoft/terraform-cdk-constructs.ResourceCleanupService", version: "1.3.0" };
+/**
+ * Verifies that all resources with a specific test run ID are deleted
+ *
+ * Performs Azure Resource Graph query to check for remaining resources.
+ * Implements retry logic to handle Azure's eventual consistency.
+ *
+ * @param runId - Test run UUID to verify
+ * @param expectedResources - List of resources that should be deleted
+ * @param subscription - Optional subscription ID to query
+ * @returns Verification result with details
+ */
+function verifyResourcesDeleted(runId, expectedResources, subscription) {
+    const service = new ResourceCleanupService();
+    // Check if Azure CLI is available before attempting verification
+    if (!service.checkAzureCliAvailable()) {
+        return {
+            success: false,
+            message: "Verification failed: Azure CLI is not available",
+            orphanedResources: [],
+            expectedCount: expectedResources.length,
+            foundCount: -1,
+        };
+    }
+    try {
+        const orphanedResources = service.queryAzureResourcesByTags({ "test-run-id": runId }, subscription);
+        if (orphanedResources.length > 0) {
+            const resourceIds = orphanedResources.map((r) => r.id);
+            return {
+                success: false,
+                message: `Found ${orphanedResources.length} orphaned resources after destroy`,
+                orphanedResources: resourceIds,
+                expectedCount: expectedResources.length,
+                foundCount: orphanedResources.length,
+            };
+        }
+        return {
+            success: true,
+            message: "All resources successfully deleted",
+            orphanedResources: [],
+            expectedCount: expectedResources.length,
+            foundCount: 0,
+        };
+    }
+    catch (error) {
+        return {
+            success: false,
+            message: `Verification failed: ${error.message}`,
+            orphanedResources: [],
+            expectedCount: expectedResources.length,
+            foundCount: -1,
+        };
+    }
+}
+/**
+ * Finds orphaned test resources that are past their TTL
+ *
+ * Queries Azure for resources with test tags that are older than
+ * their cleanup-after timestamp.
+ *
+ * @param options - Cleanup options
+ * @returns List of orphaned resources
+ */
+async function findOrphanedResources(options) {
+    const now = new Date();
+    console.log(`[Cleanup] Searching for orphaned test resources...`);
+    console.log(`[Cleanup] Minimum age: ${options.minAgeHours} hours`);
+    // Query for test resources
+    // NOTE: Tag names use hyphens instead of colons because Azure DNS zones
+    // and some other resource types don't support colons in tag names.
+    const query = `
+    Resources
+    | where tags['test-managed-by'] == 'terraform-cdk-constructs-tests'
+    | where tags['test-auto-cleanup'] == 'true'
+    | project id, type, name, location, resourceGroup,
+              testRunId = tags['test-run-id'],
+              createdAt = tags['test-created-at'],
+              cleanupAfter = tags['test-cleanup-after'],
+              testName = tags['test-name']
+    | order by tostring(createdAt) asc
+  `;
+    try {
+        const subscriptionArg = options.subscription
+            ? `--subscriptions "${options.subscription}"`
+            : "";
+        const command = `az graph query -q "${query.replace(/\n/g, " ")}" ${subscriptionArg} --output json`;
+        const result = (0, child_process_1.execSync)(command, {
+            encoding: "utf-8",
+            stdio: "pipe",
+        });
+        const parsed = JSON.parse(result);
+        const resources = parsed.data || [];
+        console.log(`[Cleanup] Found ${resources.length} test resources`);
+        // Filter by age and cleanup eligibility
+        const orphaned = [];
+        for (const resource of resources) {
+            const createdAt = new Date(resource.createdAt);
+            const cleanupAfter = new Date(resource.cleanupAfter);
+            const ageHours = (now.getTime() - createdAt.getTime()) / (60 * 60 * 1000);
+            // Apply safety checks
+            // When minAgeHours is 0 (force mode), skip the minimum age validation
+            if (options.minAgeHours > 0 && ageHours < MINIMUM_AGE_HOURS) {
+                console.log(`[Cleanup] Skipping ${resource.name}: too young (${ageHours.toFixed(1)}h < ${MINIMUM_AGE_HOURS}h)`);
+                continue;
+            }
+            // Check TTL (cleanup-after timestamp)
+            // When minAgeHours is 0 (force mode), skip the TTL check as well
+            if (options.minAgeHours > 0 && now < cleanupAfter) {
+                console.log(`[Cleanup] Skipping ${resource.name}: not yet eligible for cleanup`);
+                continue;
+            }
+            if (ageHours < options.minAgeHours) {
+                console.log(`[Cleanup] Skipping ${resource.name}: younger than min age (${ageHours.toFixed(1)}h < ${options.minAgeHours}h)`);
+                continue;
+            }
+            orphaned.push({
+                resourceId: resource.id,
+                resourceType: resource.type,
+                name: resource.name,
+                location: resource.location,
+                resourceGroup: resource.resourceGroup,
+                testRunId: resource.testRunId,
+                createdAt,
+                cleanupAfter,
+                testName: resource.testName,
+                ageHours,
+            });
+        }
+        console.log(`[Cleanup] Found ${orphaned.length} orphaned resources eligible for cleanup`);
+        // Limit resources if specified
+        if (options.maxResources && orphaned.length > options.maxResources) {
+            console.log(`[Cleanup] Limiting to ${options.maxResources} resources`);
+            return orphaned.slice(0, options.maxResources);
+        }
+        return orphaned;
+    }
+    catch (error) {
+        console.error("[Cleanup] Failed to find orphaned resources:", error.message);
+        throw error;
+    }
+}
+/**
+ * Cleans up orphaned test resources
+ *
+ * Deletes resource groups containing orphaned test resources.
+ * Implements safety checks and dry-run mode.
+ *
+ * @param resources - List of orphaned resources to clean up
+ * @param options - Cleanup options
+ * @returns Cleanup result with statistics
+ */
+async function cleanupOrphanedResources(resources, options) {
+    if (resources.length === 0) {
+        console.log("[Cleanup] No resources to clean up");
+        return { deleted: 0, failed: 0, skipped: 0 };
+    }
+    if (options.dryRun) {
+        console.log("[Cleanup] DRY RUN - Would delete the following resources:");
+        resources.forEach((r) => {
+            console.log(`  - ${r.name} (${r.resourceType}) in ${r.resourceGroup} - Age: ${r.ageHours.toFixed(1)}h`);
+        });
+        return { deleted: 0, failed: 0, skipped: resources.length };
+    }
+    // Group resources by resource group for efficient deletion
+    const byResourceGroup = new Map();
+    for (const resource of resources) {
+        const group = byResourceGroup.get(resource.resourceGroup) || [];
+        group.push(resource);
+        byResourceGroup.set(resource.resourceGroup, group);
+    }
+    console.log(`[Cleanup] Deleting ${byResourceGroup.size} resource groups containing ${resources.length} resources`);
+    let deleted = 0;
+    let failed = 0;
+    const errors = [];
+    for (const [rgName, rgResources] of byResourceGroup) {
+        try {
+            console.log(`[Cleanup] Deleting resource group: ${rgName} (${rgResources.length} resources)`);
+            // Validate that all resources in the group are test resources
+            // When minAgeHours is 0 (force mode), allow deletion of resources below minimum age
+            const allTestResources = rgResources.every((r) => r.testRunId &&
+                (options.minAgeHours === 0 || r.ageHours >= MINIMUM_AGE_HOURS));
+            if (!allTestResources) {
+                console.warn(`[Cleanup] Skipping ${rgName}: not all resources are valid test resources`);
+                failed += rgResources.length;
+                errors.push(`Resource group ${rgName} contains non-test resources`);
+                continue;
+            }
+            // Delete resource group (async, no-wait)
+            (0, child_process_1.execSync)(`az group delete --name "${rgName}" --yes --no-wait`, {
+                encoding: "utf-8",
+                stdio: "pipe",
+            });
+            deleted += rgResources.length;
+            console.log(`[Cleanup] ✓ Initiated deletion of ${rgName}`);
+        }
+        catch (error) {
+            console.error(`[Cleanup] ✗ Failed to delete ${rgName}:`, error.message);
+            failed += rgResources.length;
+            errors.push(`Failed to delete ${rgName}: ${error.message}`);
+        }
+    }
+    const result = {
+        deleted,
+        failed,
+        skipped: 0,
+        errors: errors.length > 0 ? errors : undefined,
+    };
+    console.log("[Cleanup] Summary:");
+    console.log(`  - Deleted: ${result.deleted} resources`);
+    console.log(`  - Failed: ${result.failed} resources`);
+    if (result.errors) {
+        console.log(`  - Errors: ${result.errors.length}`);
+    }
+    return result;
+}
+/**
+ * Verifies resource cleanup with retry logic for eventual consistency
+ *
+ * Wrapper around verifyResourcesDeleted that implements retry logic
+ * to handle Azure's eventual consistency delays.
+ *
+ * @param runId - Test run UUID to verify
+ * @param expectedResources - List of resources that should be deleted
+ * @param subscription - Optional subscription ID to query
+ * @param maxRetries - Maximum number of retry attempts
+ * @param retryWaitMs - Wait time between retries in milliseconds
+ * @returns Final verification result
+ */
+async function verifyResourcesDeletedWithRetry(runId, expectedResources, subscription, maxRetries = MAX_RETRIES, retryWaitMs = RETRY_WAIT_MS) {
+    let lastResult;
+    for (let attempt = 1; attempt <= maxRetries; attempt++) {
+        console.log(`[Verification] Attempt ${attempt}/${maxRetries}`);
+        lastResult = verifyResourcesDeleted(runId, expectedResources, subscription);
+        if (lastResult.success) {
+            console.log("[Verification] ✓ All resources confirmed deleted");
+            return lastResult;
+        }
+        if (attempt < maxRetries) {
+            console.log(`[Verification] Found ${lastResult.foundCount} resources, retrying in ${retryWaitMs / 1000}s...`);
+            await new Promise((resolve) => setTimeout(resolve, retryWaitMs));
+        }
+    }
+    console.error(`[Verification] ✗ Failed after ${maxRetries} attempts: ${lastResult.message}`);
+    return lastResult;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"cleanup.js","sourceRoot":"","sources":["../../../src/testing/lib/cleanup.ts"],"names":[],"mappings":";;;;AAySA,wDAmDC;AAWD,sDAyGC;AAYD,4DAwFC;AAeD,0EA+BC;;AAlmBD;;;;;GAKG;AAEH,iDAAyC;AAiMzC;;GAEG;AACH,MAAM,iBAAiB,GAAG,CAAC,CAAC;AAE5B;;GAEG;AACH,MAAM,WAAW,GAAG,CAAC,CAAC;AAEtB;;GAEG;AACH,MAAM,aAAa,GAAG,KAAK,CAAC,CAAC,aAAa;AAE1C;;GAEG;AACH,MAAa,sBAAsB;IACjC;;OAEG;IACI,sBAAsB;QAC3B,IAAI,CAAC;YACH,IAAA,wBAAQ,EAAC,cAAc,EAAE,EAAE,KAAK,EAAE,MAAM,EAAE,CAAC,CAAC;YAC5C,OAAO,IAAI,CAAC;QACd,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,OAAO,KAAK,CAAC;QACf,CAAC;IACH,CAAC;IAED;;OAEG;IACK,mBAAmB,CAAC,OAAe;QACzC,IAAI,CAAC;YACH,OAAO,IAAA,wBAAQ,EAAC,OAAO,EAAE;gBACvB,QAAQ,EAAE,OAAO;gBACjB,KAAK,EAAE,MAAM;aACd,CAAC,CAAC;QACL,CAAC;QAAC,OAAO,KAAU,EAAE,CAAC;YACpB,MAAM,IAAI,KAAK,CACb,6BAA6B,KAAK,CAAC,OAAO,IAAI;gBAC5C,YAAY,OAAO,IAAI;gBACvB,WAAW,KAAK,CAAC,MAAM,EAAE,QAAQ,EAAE,IAAI,KAAK,EAAE,CACjD,CAAC;QACJ,CAAC;IACH,CAAC;IAED;;;;OAIG;IACI,yBAAyB,CAC9B,IAA4B,EAC5B,YAAqB;QAErB,8BAA8B;QAC9B,MAAM,aAAa,GAAG,MAAM,CAAC,OAAO,CAAC,IAAI,CAAC;aACvC,GAAG,CAAC,CAAC,CAAC,GAAG,EAAE,KAAK,CAAC,EAAE,EAAE,CAAC,SAAS,GAAG,UAAU,KAAK,GAAG,CAAC;aACrD,IAAI,CAAC,OAAO,CAAC,CAAC;QAEjB,MAAM,KAAK,GAAG;;gBAEF,aAAa;;KAExB,CAAC;QAEF,MAAM,eAAe,GAAG,YAAY;YAClC,CAAC,CAAC,oBAAoB,YAAY,GAAG;YACrC,CAAC,CAAC,EAAE,CAAC;QAEP,MAAM,OAAO,GAAG,sBAAsB,KAAK,CAAC,OAAO,CAAC,KAAK,EAAE,GAAG,CAAC,KAAK,eAAe,gBAAgB,CAAC;QAEpG,IAAI,CAAC;YACH,MAAM,MAAM,GAAG,IAAI,CAAC,mBAAmB,CAAC,OAAO,CAAC,CAAC;YACjD,MAAM,MAAM,GAAG,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC;YAClC,OAAO,MAAM,CAAC,IAAI,IAAI,EAAE,CAAC;QAC3B,CAAC;QAAC,OAAO,KAAU,EAAE,CAAC;YACpB,OAAO,CAAC,KAAK,CAAC,uCAAuC,EAAE,KAAK,CAAC,OAAO,CAAC,CAAC;YACtE,OAAO,EAAE,CAAC;QACZ,CAAC;IACH,CAAC;;AAjEH,wDAkEC;;;AAED;;;;;;;;;;GAUG;AACH,SAAgB,sBAAsB,CACpC,KAAa,EACb,iBAAqC,EACrC,YAAqB;IAErB,MAAM,OAAO,GAAG,IAAI,sBAAsB,EAAE,CAAC;IAE7C,iEAAiE;IACjE,IAAI,CAAC,OAAO,CAAC,sBAAsB,EAAE,EAAE,CAAC;QACtC,OAAO;YACL,OAAO,EAAE,KAAK;YACd,OAAO,EAAE,iDAAiD;YAC1D,iBAAiB,EAAE,EAAE;YACrB,aAAa,EAAE,iBAAiB,CAAC,MAAM;YACvC,UAAU,EAAE,CAAC,CAAC;SACf,CAAC;IACJ,CAAC;IAED,IAAI,CAAC;QACH,MAAM,iBAAiB,GAAG,OAAO,CAAC,yBAAyB,CACzD,EAAE,aAAa,EAAE,KAAK,EAAE,EACxB,YAAY,CACb,CAAC;QAEF,IAAI,iBAAiB,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;YACjC,MAAM,WAAW,GAAG,iBAAiB,CAAC,GAAG,CAAC,CAAC,CAAM,EAAE,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC;YAC5D,OAAO;gBACL,OAAO,EAAE,KAAK;gBACd,OAAO,EAAE,SAAS,iBAAiB,CAAC,MAAM,mCAAmC;gBAC7E,iBAAiB,EAAE,WAAW;gBAC9B,aAAa,EAAE,iBAAiB,CAAC,MAAM;gBACvC,UAAU,EAAE,iBAAiB,CAAC,MAAM;aACrC,CAAC;QACJ,CAAC;QAED,OAAO;YACL,OAAO,EAAE,IAAI;YACb,OAAO,EAAE,oCAAoC;YAC7C,iBAAiB,EAAE,EAAE;YACrB,aAAa,EAAE,iBAAiB,CAAC,MAAM;YACvC,UAAU,EAAE,CAAC;SACd,CAAC;IACJ,CAAC;IAAC,OAAO,KAAU,EAAE,CAAC;QACpB,OAAO;YACL,OAAO,EAAE,KAAK;YACd,OAAO,EAAE,wBAAwB,KAAK,CAAC,OAAO,EAAE;YAChD,iBAAiB,EAAE,EAAE;YACrB,aAAa,EAAE,iBAAiB,CAAC,MAAM;YACvC,UAAU,EAAE,CAAC,CAAC;SACf,CAAC;IACJ,CAAC;AACH,CAAC;AAED;;;;;;;;GAQG;AACI,KAAK,UAAU,qBAAqB,CACzC,OAAuB;IAEvB,MAAM,GAAG,GAAG,IAAI,IAAI,EAAE,CAAC;IAEvB,OAAO,CAAC,GAAG,CAAC,oDAAoD,CAAC,CAAC;IAClE,OAAO,CAAC,GAAG,CAAC,0BAA0B,OAAO,CAAC,WAAW,QAAQ,CAAC,CAAC;IAEnE,2BAA2B;IAC3B,wEAAwE;IACxE,mEAAmE;IACnE,MAAM,KAAK,GAAG;;;;;;;;;;GAUb,CAAC;IAEF,IAAI,CAAC;QACH,MAAM,eAAe,GAAG,OAAO,CAAC,YAAY;YAC1C,CAAC,CAAC,oBAAoB,OAAO,CAAC,YAAY,GAAG;YAC7C,CAAC,CAAC,EAAE,CAAC;QAEP,MAAM,OAAO,GAAG,sBAAsB,KAAK,CAAC,OAAO,CAAC,KAAK,EAAE,GAAG,CAAC,KAAK,eAAe,gBAAgB,CAAC;QAEpG,MAAM,MAAM,GAAG,IAAA,wBAAQ,EAAC,OAAO,EAAE;YAC/B,QAAQ,EAAE,OAAO;YACjB,KAAK,EAAE,MAAM;SACd,CAAC,CAAC;QAEH,MAAM,MAAM,GAAG,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC;QAClC,MAAM,SAAS,GAAG,MAAM,CAAC,IAAI,IAAI,EAAE,CAAC;QAEpC,OAAO,CAAC,GAAG,CAAC,mBAAmB,SAAS,CAAC,MAAM,iBAAiB,CAAC,CAAC;QAElE,wCAAwC;QACxC,MAAM,QAAQ,GAAuB,EAAE,CAAC;QAExC,KAAK,MAAM,QAAQ,IAAI,SAAS,EAAE,CAAC;YACjC,MAAM,SAAS,GAAG,IAAI,IAAI,CAAC,QAAQ,CAAC,SAAS,CAAC,CAAC;YAC/C,MAAM,YAAY,GAAG,IAAI,IAAI,CAAC,QAAQ,CAAC,YAAY,CAAC,CAAC;YACrD,MAAM,QAAQ,GAAG,CAAC,GAAG,CAAC,OAAO,EAAE,GAAG,SAAS,CAAC,OAAO,EAAE,CAAC,GAAG,CAAC,EAAE,GAAG,EAAE,GAAG,IAAI,CAAC,CAAC;YAE1E,sBAAsB;YACtB,sEAAsE;YACtE,IAAI,OAAO,CAAC,WAAW,GAAG,CAAC,IAAI,QAAQ,GAAG,iBAAiB,EAAE,CAAC;gBAC5D,OAAO,CAAC,GAAG,CACT,sBAAsB,QAAQ,CAAC,IAAI,gBAAgB,QAAQ,CAAC,OAAO,CAAC,CAAC,CAAC,OAAO,iBAAiB,IAAI,CACnG,CAAC;gBACF,SAAS;YACX,CAAC;YAED,sCAAsC;YACtC,iEAAiE;YACjE,IAAI,OAAO,CAAC,WAAW,GAAG,CAAC,IAAI,GAAG,GAAG,YAAY,EAAE,CAAC;gBAClD,OAAO,CAAC,GAAG,CACT,sBAAsB,QAAQ,CAAC,IAAI,gCAAgC,CACpE,CAAC;gBACF,SAAS;YACX,CAAC;YAED,IAAI,QAAQ,GAAG,OAAO,CAAC,WAAW,EAAE,CAAC;gBACnC,OAAO,CAAC,GAAG,CACT,sBAAsB,QAAQ,CAAC,IAAI,2BAA2B,QAAQ,CAAC,OAAO,CAAC,CAAC,CAAC,OAAO,OAAO,CAAC,WAAW,IAAI,CAChH,CAAC;gBACF,SAAS;YACX,CAAC;YAED,QAAQ,CAAC,IAAI,CAAC;gBACZ,UAAU,EAAE,QAAQ,CAAC,EAAE;gBACvB,YAAY,EAAE,QAAQ,CAAC,IAAI;gBAC3B,IAAI,EAAE,QAAQ,CAAC,IAAI;gBACnB,QAAQ,EAAE,QAAQ,CAAC,QAAQ;gBAC3B,aAAa,EAAE,QAAQ,CAAC,aAAa;gBACrC,SAAS,EAAE,QAAQ,CAAC,SAAS;gBAC7B,SAAS;gBACT,YAAY;gBACZ,QAAQ,EAAE,QAAQ,CAAC,QAAQ;gBAC3B,QAAQ;aACT,CAAC,CAAC;QACL,CAAC;QAED,OAAO,CAAC,GAAG,CACT,mBAAmB,QAAQ,CAAC,MAAM,0CAA0C,CAC7E,CAAC;QAEF,+BAA+B;QAC/B,IAAI,OAAO,CAAC,YAAY,IAAI,QAAQ,CAAC,MAAM,GAAG,OAAO,CAAC,YAAY,EAAE,CAAC;YACnE,OAAO,CAAC,GAAG,CAAC,yBAAyB,OAAO,CAAC,YAAY,YAAY,CAAC,CAAC;YACvE,OAAO,QAAQ,CAAC,KAAK,CAAC,CAAC,EAAE,OAAO,CAAC,YAAY,CAAC,CAAC;QACjD,CAAC;QAED,OAAO,QAAQ,CAAC;IAClB,CAAC;IAAC,OAAO,KAAU,EAAE,CAAC;QACpB,OAAO,CAAC,KAAK,CACX,8CAA8C,EAC9C,KAAK,CAAC,OAAO,CACd,CAAC;QACF,MAAM,KAAK,CAAC;IACd,CAAC;AACH,CAAC;AAED;;;;;;;;;GASG;AACI,KAAK,UAAU,wBAAwB,CAC5C,SAA6B,EAC7B,OAAuB;IAEvB,IAAI,SAAS,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;QAC3B,OAAO,CAAC,GAAG,CAAC,oCAAoC,CAAC,CAAC;QAClD,OAAO,EAAE,OAAO,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,OAAO,EAAE,CAAC,EAAE,CAAC;IAC/C,CAAC;IAED,IAAI,OAAO,CAAC,MAAM,EAAE,CAAC;QACnB,OAAO,CAAC,GAAG,CAAC,2DAA2D,CAAC,CAAC;QACzE,SAAS,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE,EAAE;YACtB,OAAO,CAAC,GAAG,CACT,OAAO,CAAC,CAAC,IAAI,KAAK,CAAC,CAAC,YAAY,QAAQ,CAAC,CAAC,aAAa,WAAW,CAAC,CAAC,QAAQ,CAAC,OAAO,CAAC,CAAC,CAAC,GAAG,CAC3F,CAAC;QACJ,CAAC,CAAC,CAAC;QACH,OAAO,EAAE,OAAO,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,OAAO,EAAE,SAAS,CAAC,MAAM,EAAE,CAAC;IAC9D,CAAC;IAED,2DAA2D;IAC3D,MAAM,eAAe,GAAG,IAAI,GAAG,EAA8B,CAAC;IAC9D,KAAK,MAAM,QAAQ,IAAI,SAAS,EAAE,CAAC;QACjC,MAAM,KAAK,GAAG,eAAe,CAAC,GAAG,CAAC,QAAQ,CAAC,aAAa,CAAC,IAAI,EAAE,CAAC;QAChE,KAAK,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;QACrB,eAAe,CAAC,GAAG,CAAC,QAAQ,CAAC,aAAa,EAAE,KAAK,CAAC,CAAC;IACrD,CAAC;IAED,OAAO,CAAC,GAAG,CACT,sBAAsB,eAAe,CAAC,IAAI,+BAA+B,SAAS,CAAC,MAAM,YAAY,CACtG,CAAC;IAEF,IAAI,OAAO,GAAG,CAAC,CAAC;IAChB,IAAI,MAAM,GAAG,CAAC,CAAC;IACf,MAAM,MAAM,GAAa,EAAE,CAAC;IAE5B,KAAK,MAAM,CAAC,MAAM,EAAE,WAAW,CAAC,IAAI,eAAe,EAAE,CAAC;QACpD,IAAI,CAAC;YACH,OAAO,CAAC,GAAG,CACT,sCAAsC,MAAM,KAAK,WAAW,CAAC,MAAM,aAAa,CACjF,CAAC;YAEF,8DAA8D;YAC9D,oFAAoF;YACpF,MAAM,gBAAgB,GAAG,WAAW,CAAC,KAAK,CACxC,CAAC,CAAC,EAAE,EAAE,CACJ,CAAC,CAAC,SAAS;gBACX,CAAC,OAAO,CAAC,WAAW,KAAK,CAAC,IAAI,CAAC,CAAC,QAAQ,IAAI,iBAAiB,CAAC,CACjE,CAAC;YAEF,IAAI,CAAC,gBAAgB,EAAE,CAAC;gBACtB,OAAO,CAAC,IAAI,CACV,sBAAsB,MAAM,8CAA8C,CAC3E,CAAC;gBACF,MAAM,IAAI,WAAW,CAAC,MAAM,CAAC;gBAC7B,MAAM,CAAC,IAAI,CAAC,kBAAkB,MAAM,8BAA8B,CAAC,CAAC;gBACpE,SAAS;YACX,CAAC;YAED,yCAAyC;YACzC,IAAA,wBAAQ,EAAC,2BAA2B,MAAM,mBAAmB,EAAE;gBAC7D,QAAQ,EAAE,OAAO;gBACjB,KAAK,EAAE,MAAM;aACd,CAAC,CAAC;YAEH,OAAO,IAAI,WAAW,CAAC,MAAM,CAAC;YAC9B,OAAO,CAAC,GAAG,CAAC,qCAAqC,MAAM,EAAE,CAAC,CAAC;QAC7D,CAAC;QAAC,OAAO,KAAU,EAAE,CAAC;YACpB,OAAO,CAAC,KAAK,CAAC,gCAAgC,MAAM,GAAG,EAAE,KAAK,CAAC,OAAO,CAAC,CAAC;YACxE,MAAM,IAAI,WAAW,CAAC,MAAM,CAAC;YAC7B,MAAM,CAAC,IAAI,CAAC,oBAAoB,MAAM,KAAK,KAAK,CAAC,OAAO,EAAE,CAAC,CAAC;QAC9D,CAAC;IACH,CAAC;IAED,MAAM,MAAM,GAAkB;QAC5B,OAAO;QACP,MAAM;QACN,OAAO,EAAE,CAAC;QACV,MAAM,EAAE,MAAM,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,SAAS;KAC/C,CAAC;IAEF,OAAO,CAAC,GAAG,CAAC,oBAAoB,CAAC,CAAC;IAClC,OAAO,CAAC,GAAG,CAAC,gBAAgB,MAAM,CAAC,OAAO,YAAY,CAAC,CAAC;IACxD,OAAO,CAAC,GAAG,CAAC,eAAe,MAAM,CAAC,MAAM,YAAY,CAAC,CAAC;IACtD,IAAI,MAAM,CAAC,MAAM,EAAE,CAAC;QAClB,OAAO,CAAC,GAAG,CAAC,eAAe,MAAM,CAAC,MAAM,CAAC,MAAM,EAAE,CAAC,CAAC;IACrD,CAAC;IAED,OAAO,MAAM,CAAC;AAChB,CAAC;AAED;;;;;;;;;;;;GAYG;AACI,KAAK,UAAU,+BAA+B,CACnD,KAAa,EACb,iBAAqC,EACrC,YAAqB,EACrB,aAAqB,WAAW,EAChC,cAAsB,aAAa;IAEnC,IAAI,UAA8B,CAAC;IAEnC,KAAK,IAAI,OAAO,GAAG,CAAC,EAAE,OAAO,IAAI,UAAU,EAAE,OAAO,EAAE,EAAE,CAAC;QACvD,OAAO,CAAC,GAAG,CAAC,0BAA0B,OAAO,IAAI,UAAU,EAAE,CAAC,CAAC;QAE/D,UAAU,GAAG,sBAAsB,CAAC,KAAK,EAAE,iBAAiB,EAAE,YAAY,CAAC,CAAC;QAE5E,IAAI,UAAU,CAAC,OAAO,EAAE,CAAC;YACvB,OAAO,CAAC,GAAG,CAAC,kDAAkD,CAAC,CAAC;YAChE,OAAO,UAAU,CAAC;QACpB,CAAC;QAED,IAAI,OAAO,GAAG,UAAU,EAAE,CAAC;YACzB,OAAO,CAAC,GAAG,CACT,wBAAwB,UAAU,CAAC,UAAU,2BAA2B,WAAW,GAAG,IAAI,MAAM,CACjG,CAAC;YACF,MAAM,IAAI,OAAO,CAAC,CAAC,OAAO,EAAE,EAAE,CAAC,UAAU,CAAC,OAAO,EAAE,WAAW,CAAC,CAAC,CAAC;QACnE,CAAC;IACH,CAAC;IAED,OAAO,CAAC,KAAK,CACX,iCAAiC,UAAU,cAAc,UAAW,CAAC,OAAO,EAAE,CAC/E,CAAC;IACF,OAAO,UAAW,CAAC;AACrB,CAAC","sourcesContent":["/**\n * Cleanup and verification utilities for integration tests\n *\n * Provides functions for verifying resource deletion via Azure Resource Graph\n * and finding/cleaning orphaned resources with comprehensive safety mechanisms.\n */\n\nimport { execSync } from \"child_process\";\n\n/**\n * Metadata for an individual resource created during testing\n */\nexport interface ResourceMetadata {\n  /**\n   * Azure resource ID\n   */\n  readonly resourceId: string;\n\n  /**\n   * Azure resource type (e.g., 'Microsoft.Resources/resourceGroups')\n   */\n  readonly resourceType: string;\n\n  /**\n   * Resource name\n   */\n  readonly name: string;\n\n  /**\n   * Resource location (Azure region)\n   */\n  readonly location?: string;\n\n  /**\n   * Resource tags\n   */\n  readonly tags: Record<string, string>;\n\n  /**\n   * Test run ID that created this resource\n   */\n  readonly testRunId: string;\n\n  /**\n   * Timestamp when resource was created\n   */\n  readonly createdAt: Date;\n\n  /**\n   * Whether this resource was successfully destroyed\n   */\n  readonly destroyed?: boolean;\n\n  /**\n   * Timestamp when resource was destroyed\n   */\n  readonly destroyedAt?: Date;\n}\n\n/**\n * Result of resource cleanup verification\n */\nexport interface VerificationResult {\n  /**\n   * Whether verification succeeded (all resources deleted)\n   */\n  readonly success: boolean;\n\n  /**\n   * Human-readable message describing the result\n   */\n  readonly message: string;\n\n  /**\n   * List of orphaned resource IDs (if any)\n   */\n  readonly orphanedResources: string[];\n\n  /**\n   * Number of resources expected to be deleted\n   */\n  readonly expectedCount?: number;\n\n  /**\n   * Number of resources actually found\n   */\n  readonly foundCount?: number;\n}\n\n/**\n * Options for cleanup operations\n */\nexport interface CleanupOptions {\n  /**\n   * Whether to perform dry-run (no actual deletion)\n   */\n  readonly dryRun: boolean;\n\n  /**\n   * Minimum age in hours before resource can be cleaned up\n   * Set to 0 to force cleanup of all resources regardless of age (bypasses safety checks)\n   */\n  readonly minAgeHours: number;\n\n  /**\n   * Azure subscription ID to target (optional)\n   */\n  readonly subscription?: string;\n\n  /**\n   * Specific resource groups to target (optional)\n   */\n  readonly resourceGroups?: string[];\n\n  /**\n   * Maximum number of resources to clean up in one operation\n   */\n  readonly maxResources?: number;\n}\n\n/**\n * Orphaned resource information\n */\nexport interface OrphanedResource {\n  /**\n   * Azure resource ID\n   */\n  readonly resourceId: string;\n\n  /**\n   * Azure resource type\n   */\n  readonly resourceType: string;\n\n  /**\n   * Resource name\n   */\n  readonly name: string;\n\n  /**\n   * Resource location\n   */\n  readonly location: string;\n\n  /**\n   * Resource group name\n   */\n  readonly resourceGroup: string;\n\n  /**\n   * Test run ID from tags\n   */\n  readonly testRunId: string;\n\n  /**\n   * Creation timestamp from tags\n   */\n  readonly createdAt: Date;\n\n  /**\n   * Cleanup after timestamp from tags\n   */\n  readonly cleanupAfter: Date;\n\n  /**\n   * Test name from tags\n   */\n  readonly testName: string;\n\n  /**\n   * Age in hours since creation\n   */\n  readonly ageHours: number;\n}\n\n/**\n * Result of cleanup operation\n */\nexport interface CleanupResult {\n  /**\n   * Number of resources successfully deleted\n   */\n  readonly deleted: number;\n\n  /**\n   * Number of resources that failed to delete\n   */\n  readonly failed: number;\n\n  /**\n   * Number of resources skipped (e.g., too young)\n   */\n  readonly skipped: number;\n\n  /**\n   * Detailed error messages for failures\n   */\n  readonly errors?: string[];\n}\n\n/**\n * Minimum age threshold (hours) before cleanup is allowed\n */\nconst MINIMUM_AGE_HOURS = 2;\n\n/**\n * Maximum retry attempts for eventual consistency\n */\nconst MAX_RETRIES = 5;\n\n/**\n * Wait time between retries (milliseconds)\n */\nconst RETRY_WAIT_MS = 30000; // 30 seconds\n\n/**\n * Main cleanup service class\n */\nexport class ResourceCleanupService {\n  /**\n   * Checks if Azure CLI is available\n   */\n  public checkAzureCliAvailable(): boolean {\n    try {\n      execSync(\"az --version\", { stdio: \"pipe\" });\n      return true;\n    } catch (error) {\n      return false;\n    }\n  }\n\n  /**\n   * Executes an Azure CLI command with error handling\n   */\n  private executeAzureCommand(command: string): string {\n    try {\n      return execSync(command, {\n        encoding: \"utf-8\",\n        stdio: \"pipe\",\n      });\n    } catch (error: any) {\n      throw new Error(\n        `Azure CLI command failed: ${error.message}\\n` +\n          `Command: ${command}\\n` +\n          `Stderr: ${error.stderr?.toString() || \"N/A\"}`,\n      );\n    }\n  }\n\n  /**\n   * Queries Azure Resource Graph for resources by tags\n   *\n   * Returns empty array on errors for graceful degradation.\n   */\n  public queryAzureResourcesByTags(\n    tags: Record<string, string>,\n    subscription?: string,\n  ): any[] {\n    // Build tag filter conditions\n    const tagConditions = Object.entries(tags)\n      .map(([key, value]) => `tags['${key}'] == '${value}'`)\n      .join(\" and \");\n\n    const query = `\n      Resources\n      | where ${tagConditions}\n      | project id, type, name, location, resourceGroup, tags\n    `;\n\n    const subscriptionArg = subscription\n      ? `--subscriptions \"${subscription}\"`\n      : \"\";\n\n    const command = `az graph query -q \"${query.replace(/\\n/g, \" \")}\" ${subscriptionArg} --output json`;\n\n    try {\n      const result = this.executeAzureCommand(command);\n      const parsed = JSON.parse(result);\n      return parsed.data || [];\n    } catch (error: any) {\n      console.error(\"Failed to query Azure Resource Graph:\", error.message);\n      return [];\n    }\n  }\n}\n\n/**\n * Verifies that all resources with a specific test run ID are deleted\n *\n * Performs Azure Resource Graph query to check for remaining resources.\n * Implements retry logic to handle Azure's eventual consistency.\n *\n * @param runId - Test run UUID to verify\n * @param expectedResources - List of resources that should be deleted\n * @param subscription - Optional subscription ID to query\n * @returns Verification result with details\n */\nexport function verifyResourcesDeleted(\n  runId: string,\n  expectedResources: ResourceMetadata[],\n  subscription?: string,\n): VerificationResult {\n  const service = new ResourceCleanupService();\n\n  // Check if Azure CLI is available before attempting verification\n  if (!service.checkAzureCliAvailable()) {\n    return {\n      success: false,\n      message: \"Verification failed: Azure CLI is not available\",\n      orphanedResources: [],\n      expectedCount: expectedResources.length,\n      foundCount: -1,\n    };\n  }\n\n  try {\n    const orphanedResources = service.queryAzureResourcesByTags(\n      { \"test-run-id\": runId },\n      subscription,\n    );\n\n    if (orphanedResources.length > 0) {\n      const resourceIds = orphanedResources.map((r: any) => r.id);\n      return {\n        success: false,\n        message: `Found ${orphanedResources.length} orphaned resources after destroy`,\n        orphanedResources: resourceIds,\n        expectedCount: expectedResources.length,\n        foundCount: orphanedResources.length,\n      };\n    }\n\n    return {\n      success: true,\n      message: \"All resources successfully deleted\",\n      orphanedResources: [],\n      expectedCount: expectedResources.length,\n      foundCount: 0,\n    };\n  } catch (error: any) {\n    return {\n      success: false,\n      message: `Verification failed: ${error.message}`,\n      orphanedResources: [],\n      expectedCount: expectedResources.length,\n      foundCount: -1,\n    };\n  }\n}\n\n/**\n * Finds orphaned test resources that are past their TTL\n *\n * Queries Azure for resources with test tags that are older than\n * their cleanup-after timestamp.\n *\n * @param options - Cleanup options\n * @returns List of orphaned resources\n */\nexport async function findOrphanedResources(\n  options: CleanupOptions,\n): Promise<OrphanedResource[]> {\n  const now = new Date();\n\n  console.log(`[Cleanup] Searching for orphaned test resources...`);\n  console.log(`[Cleanup] Minimum age: ${options.minAgeHours} hours`);\n\n  // Query for test resources\n  // NOTE: Tag names use hyphens instead of colons because Azure DNS zones\n  // and some other resource types don't support colons in tag names.\n  const query = `\n    Resources\n    | where tags['test-managed-by'] == 'terraform-cdk-constructs-tests'\n    | where tags['test-auto-cleanup'] == 'true'\n    | project id, type, name, location, resourceGroup,\n              testRunId = tags['test-run-id'],\n              createdAt = tags['test-created-at'],\n              cleanupAfter = tags['test-cleanup-after'],\n              testName = tags['test-name']\n    | order by tostring(createdAt) asc\n  `;\n\n  try {\n    const subscriptionArg = options.subscription\n      ? `--subscriptions \"${options.subscription}\"`\n      : \"\";\n\n    const command = `az graph query -q \"${query.replace(/\\n/g, \" \")}\" ${subscriptionArg} --output json`;\n\n    const result = execSync(command, {\n      encoding: \"utf-8\",\n      stdio: \"pipe\",\n    });\n\n    const parsed = JSON.parse(result);\n    const resources = parsed.data || [];\n\n    console.log(`[Cleanup] Found ${resources.length} test resources`);\n\n    // Filter by age and cleanup eligibility\n    const orphaned: OrphanedResource[] = [];\n\n    for (const resource of resources) {\n      const createdAt = new Date(resource.createdAt);\n      const cleanupAfter = new Date(resource.cleanupAfter);\n      const ageHours = (now.getTime() - createdAt.getTime()) / (60 * 60 * 1000);\n\n      // Apply safety checks\n      // When minAgeHours is 0 (force mode), skip the minimum age validation\n      if (options.minAgeHours > 0 && ageHours < MINIMUM_AGE_HOURS) {\n        console.log(\n          `[Cleanup] Skipping ${resource.name}: too young (${ageHours.toFixed(1)}h < ${MINIMUM_AGE_HOURS}h)`,\n        );\n        continue;\n      }\n\n      // Check TTL (cleanup-after timestamp)\n      // When minAgeHours is 0 (force mode), skip the TTL check as well\n      if (options.minAgeHours > 0 && now < cleanupAfter) {\n        console.log(\n          `[Cleanup] Skipping ${resource.name}: not yet eligible for cleanup`,\n        );\n        continue;\n      }\n\n      if (ageHours < options.minAgeHours) {\n        console.log(\n          `[Cleanup] Skipping ${resource.name}: younger than min age (${ageHours.toFixed(1)}h < ${options.minAgeHours}h)`,\n        );\n        continue;\n      }\n\n      orphaned.push({\n        resourceId: resource.id,\n        resourceType: resource.type,\n        name: resource.name,\n        location: resource.location,\n        resourceGroup: resource.resourceGroup,\n        testRunId: resource.testRunId,\n        createdAt,\n        cleanupAfter,\n        testName: resource.testName,\n        ageHours,\n      });\n    }\n\n    console.log(\n      `[Cleanup] Found ${orphaned.length} orphaned resources eligible for cleanup`,\n    );\n\n    // Limit resources if specified\n    if (options.maxResources && orphaned.length > options.maxResources) {\n      console.log(`[Cleanup] Limiting to ${options.maxResources} resources`);\n      return orphaned.slice(0, options.maxResources);\n    }\n\n    return orphaned;\n  } catch (error: any) {\n    console.error(\n      \"[Cleanup] Failed to find orphaned resources:\",\n      error.message,\n    );\n    throw error;\n  }\n}\n\n/**\n * Cleans up orphaned test resources\n *\n * Deletes resource groups containing orphaned test resources.\n * Implements safety checks and dry-run mode.\n *\n * @param resources - List of orphaned resources to clean up\n * @param options - Cleanup options\n * @returns Cleanup result with statistics\n */\nexport async function cleanupOrphanedResources(\n  resources: OrphanedResource[],\n  options: CleanupOptions,\n): Promise<CleanupResult> {\n  if (resources.length === 0) {\n    console.log(\"[Cleanup] No resources to clean up\");\n    return { deleted: 0, failed: 0, skipped: 0 };\n  }\n\n  if (options.dryRun) {\n    console.log(\"[Cleanup] DRY RUN - Would delete the following resources:\");\n    resources.forEach((r) => {\n      console.log(\n        `  - ${r.name} (${r.resourceType}) in ${r.resourceGroup} - Age: ${r.ageHours.toFixed(1)}h`,\n      );\n    });\n    return { deleted: 0, failed: 0, skipped: resources.length };\n  }\n\n  // Group resources by resource group for efficient deletion\n  const byResourceGroup = new Map<string, OrphanedResource[]>();\n  for (const resource of resources) {\n    const group = byResourceGroup.get(resource.resourceGroup) || [];\n    group.push(resource);\n    byResourceGroup.set(resource.resourceGroup, group);\n  }\n\n  console.log(\n    `[Cleanup] Deleting ${byResourceGroup.size} resource groups containing ${resources.length} resources`,\n  );\n\n  let deleted = 0;\n  let failed = 0;\n  const errors: string[] = [];\n\n  for (const [rgName, rgResources] of byResourceGroup) {\n    try {\n      console.log(\n        `[Cleanup] Deleting resource group: ${rgName} (${rgResources.length} resources)`,\n      );\n\n      // Validate that all resources in the group are test resources\n      // When minAgeHours is 0 (force mode), allow deletion of resources below minimum age\n      const allTestResources = rgResources.every(\n        (r) =>\n          r.testRunId &&\n          (options.minAgeHours === 0 || r.ageHours >= MINIMUM_AGE_HOURS),\n      );\n\n      if (!allTestResources) {\n        console.warn(\n          `[Cleanup] Skipping ${rgName}: not all resources are valid test resources`,\n        );\n        failed += rgResources.length;\n        errors.push(`Resource group ${rgName} contains non-test resources`);\n        continue;\n      }\n\n      // Delete resource group (async, no-wait)\n      execSync(`az group delete --name \"${rgName}\" --yes --no-wait`, {\n        encoding: \"utf-8\",\n        stdio: \"pipe\",\n      });\n\n      deleted += rgResources.length;\n      console.log(`[Cleanup] ✓ Initiated deletion of ${rgName}`);\n    } catch (error: any) {\n      console.error(`[Cleanup] ✗ Failed to delete ${rgName}:`, error.message);\n      failed += rgResources.length;\n      errors.push(`Failed to delete ${rgName}: ${error.message}`);\n    }\n  }\n\n  const result: CleanupResult = {\n    deleted,\n    failed,\n    skipped: 0,\n    errors: errors.length > 0 ? errors : undefined,\n  };\n\n  console.log(\"[Cleanup] Summary:\");\n  console.log(`  - Deleted: ${result.deleted} resources`);\n  console.log(`  - Failed: ${result.failed} resources`);\n  if (result.errors) {\n    console.log(`  - Errors: ${result.errors.length}`);\n  }\n\n  return result;\n}\n\n/**\n * Verifies resource cleanup with retry logic for eventual consistency\n *\n * Wrapper around verifyResourcesDeleted that implements retry logic\n * to handle Azure's eventual consistency delays.\n *\n * @param runId - Test run UUID to verify\n * @param expectedResources - List of resources that should be deleted\n * @param subscription - Optional subscription ID to query\n * @param maxRetries - Maximum number of retry attempts\n * @param retryWaitMs - Wait time between retries in milliseconds\n * @returns Final verification result\n */\nexport async function verifyResourcesDeletedWithRetry(\n  runId: string,\n  expectedResources: ResourceMetadata[],\n  subscription?: string,\n  maxRetries: number = MAX_RETRIES,\n  retryWaitMs: number = RETRY_WAIT_MS,\n): Promise<VerificationResult> {\n  let lastResult: VerificationResult;\n\n  for (let attempt = 1; attempt <= maxRetries; attempt++) {\n    console.log(`[Verification] Attempt ${attempt}/${maxRetries}`);\n\n    lastResult = verifyResourcesDeleted(runId, expectedResources, subscription);\n\n    if (lastResult.success) {\n      console.log(\"[Verification] ✓ All resources confirmed deleted\");\n      return lastResult;\n    }\n\n    if (attempt < maxRetries) {\n      console.log(\n        `[Verification] Found ${lastResult.foundCount} resources, retrying in ${retryWaitMs / 1000}s...`,\n      );\n      await new Promise((resolve) => setTimeout(resolve, retryWaitMs));\n    }\n  }\n\n  console.error(\n    `[Verification] ✗ Failed after ${maxRetries} attempts: ${lastResult!.message}`,\n  );\n  return lastResult!;\n}\n"]}