@microsoft/terraform-cdk-constructs 0.0.3-pre.7 → 1.2.0

package/lib/testing/index.js

@@ -1,18 +1,494 @@
 "use strict";
+var _a, _b;
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.BaseTestStack = void 0;
+exports.cleanupOrphanedResources = exports.findOrphanedResources = exports.verifyResourcesDeletedWithRetry = exports.verifyResourcesDeleted = exports.ResourceCleanupService = exports.AssertionReturn = exports.BaseTestStack = exports.TestRunMetadata = void 0;
+exports.execTerraformCommand = execTerraformCommand;
+exports.TerraformApply = TerraformApply;
+exports.TerraformPlanExitCode = TerraformPlanExitCode;
+exports.TerraformIdempotentCheck = TerraformIdempotentCheck;
+exports.TerraformDestroy = TerraformDestroy;
+exports.TerraformApplyAndCheckIdempotency = TerraformApplyAndCheckIdempotency;
+exports.TerraformApplyCheckAndDestroy = TerraformApplyCheckAndDestroy;
+exports.TerraformDestroyWithVerification = TerraformDestroyWithVerification;
+exports.TerraformPlan = TerraformPlan;
+exports.cleanupCdkTfOutDirs = cleanupCdkTfOutDirs;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+const child_process_1 = require("child_process");
+const fs = require("fs");
+const path = require("path");
 const cdktf = require("cdktf");
 const cdktf_1 = require("cdktf");
+const cleanup_1 = require("./lib/cleanup");
+const metadata_1 = require("./lib/metadata");
+const naming_1 = require("./lib/naming");
+// Re-export types used in public APIs for jsii compliance
+var metadata_2 = require("./lib/metadata");
+Object.defineProperty(exports, "TestRunMetadata", { enumerable: true, get: function () { return metadata_2.TestRunMetadata; } });
+/**
+ * Base stack for integration tests with optional metadata support
+ *
+ * When metadata is enabled, automatically generates unique test run IDs,
+ * injects system tags, and provides utilities for resource naming.
+ */
 class BaseTestStack extends cdktf_1.TerraformStack {
-    constructor(scope, id) {
+    constructor(scope, id, options) {
         super(scope, id);
+        /**
+         * Registry of resources created in this stack for tracking and cleanup verification
+         */
+        this.resourceRegistry = new Map();
+        // Generate metadata if options are provided
+        if (options?.testRunOptions) {
+            this.metadata = new metadata_1.TestRunMetadata(id, options.testRunOptions);
+            // Log test run information
+            console.log(`[Test Run] ID: ${this.metadata.runId}`);
+            console.log(`[Test Run] Name: ${this.metadata.testName}`);
+            console.log(`[Test Run] Created: ${this.metadata.createdAt.toISOString()}`);
+            console.log(`[Test Run] Cleanup After: ${this.metadata.cleanupAfter.toISOString()}`);
+            if (this.metadata.ciContext) {
+                console.log(`[Test Run] CI Platform: ${this.metadata.ciContext.platform}`);
+            }
+        }
         const name = new cdktf.TerraformVariable(this, "name", {
             type: "string",
-            default: "test",
+            default: this.metadata?.testName || "test",
             description: "System name used to randomize the resources",
         });
         this.name = name.value;
     }
+    /**
+     * Registers a resource for tracking and cleanup verification
+     *
+     * @param resourceId - Azure resource ID
+     * @param resourceType - Azure resource type
+     * @param name - Resource name
+     * @param location - Optional resource location
+     * @param tags - Optional resource tags
+     */
+    registerResource(resourceId, resourceType, name, location, tags) {
+        if (!this.metadata) {
+            console.warn("[BaseTestStack] Resource registration requires metadata. " +
+                "Initialize with testRunOptions to enable resource tracking.");
+            return;
+        }
+        const metadata = {
+            resourceId,
+            resourceType,
+            name,
+            location,
+            tags: tags || {},
+            testRunId: this.metadata.runId,
+            createdAt: this.metadata.createdAt,
+        };
+        this.resourceRegistry.set(resourceId, metadata);
+        console.log(`[BaseTestStack] Registered resource: ${name} (${resourceType})`);
+    }
+    /**
+     * Retrieves all registered resources
+     *
+     * @returns Array of registered resource metadata
+     */
+    registeredResources() {
+        return Array.from(this.resourceRegistry.values());
+    }
+    /**
+     * Generates system tags for resources (only available when metadata is present)
+     *
+     * @returns Integration test system tags
+     * @throws Error if metadata is not initialized
+     */
+    systemTags() {
+        if (!this.metadata) {
+            throw new Error("System tags are only available when BaseTestStack is initialized with testRunOptions. " +
+                "Pass { testRunOptions: {} } to the constructor to enable metadata.");
+        }
+        return this.metadata.generateSystemTags();
+    }
+    /**
+     * Generates a unique resource name with proper Azure compliance
+     *
+     * @param resourceType - Azure resource type (e.g., 'Microsoft.Resources/resourceGroups')
+     * @param customIdentifier - Optional custom identifier (defaults to test name)
+     * @returns Unique, Azure-compliant resource name
+     * @throws Error if metadata is not initialized
+     *
+     * @example
+     * const stack = new BaseTestStack(app, 'test-storage', { testRunOptions: {} });
+     * const rgName = stack.generateResourceName('Microsoft.Resources/resourceGroups');
+     * // Returns: 'rg-test-storage-a1b2c3'
+     */
+    generateResourceName(resourceType, customIdentifier) {
+        if (!this.metadata) {
+            throw new Error("Resource name generation is only available when BaseTestStack is initialized with testRunOptions. " +
+                "Pass { testRunOptions: {} } to the constructor to enable metadata.");
+        }
+        return (0, naming_1.generateResourceName)({
+            resourceType,
+            testName: this.metadata.testName,
+            runId: this.metadata.runId,
+            customIdentifier,
+        });
+    }
 }
 exports.BaseTestStack = BaseTestStack;
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvdGVzdGluZy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7QUFBQSwrQkFBK0I7QUFDL0IsaUNBQXVDO0FBR3ZDLE1BQWEsYUFBYyxTQUFRLHNCQUFjO0lBRy9DLFlBQVksS0FBZ0IsRUFBRSxFQUFVO1FBQ3RDLEtBQUssQ0FBQyxLQUFLLEVBQUUsRUFBRSxDQUFDLENBQUM7UUFFakIsTUFBTSxJQUFJLEdBQUcsSUFBSSxLQUFLLENBQUMsaUJBQWlCLENBQUMsSUFBSSxFQUFFLE1BQU0sRUFBRTtZQUNyRCxJQUFJLEVBQUUsUUFBUTtZQUNkLE9BQU8sRUFBRSxNQUFNO1lBQ2YsV0FBVyxFQUFFLDZDQUE2QztTQUMzRCxDQUFDLENBQUM7UUFFSCxJQUFJLENBQUMsSUFBSSxHQUFHLElBQUksQ0FBQyxLQUFLLENBQUM7SUFDekIsQ0FBQztDQUNGO0FBZEQsc0NBY0MiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgKiBhcyBjZGt0ZiBmcm9tIFwiY2RrdGZcIjtcbmltcG9ydCB7IFRlcnJhZm9ybVN0YWNrIH0gZnJvbSBcImNka3RmXCI7XG5pbXBvcnQgeyBDb25zdHJ1Y3QgfSBmcm9tIFwiY29uc3RydWN0c1wiO1xuXG5leHBvcnQgY2xhc3MgQmFzZVRlc3RTdGFjayBleHRlbmRzIFRlcnJhZm9ybVN0YWNrIHtcbiAgcHVibGljIHJlYWRvbmx5IG5hbWU6IHN0cmluZztcblxuICBjb25zdHJ1Y3RvcihzY29wZTogQ29uc3RydWN0LCBpZDogc3RyaW5nKSB7XG4gICAgc3VwZXIoc2NvcGUsIGlkKTtcblxuICAgIGNvbnN0IG5hbWUgPSBuZXcgY2RrdGYuVGVycmFmb3JtVmFyaWFibGUodGhpcywgXCJuYW1lXCIsIHtcbiAgICAgIHR5cGU6IFwic3RyaW5nXCIsXG4gICAgICBkZWZhdWx0OiBcInRlc3RcIixcbiAgICAgIGRlc2NyaXB0aW9uOiBcIlN5c3RlbSBuYW1lIHVzZWQgdG8gcmFuZG9taXplIHRoZSByZXNvdXJjZXNcIixcbiAgICB9KTtcblxuICAgIHRoaXMubmFtZSA9IG5hbWUudmFsdWU7XG4gIH1cbn1cbiJdfQ==
+_a = JSII_RTTI_SYMBOL_1;
+BaseTestStack[_a] = { fqn: "@microsoft/terraform-cdk-constructs.BaseTestStack", version: "1.2.0" };
+function execTerraformCommand(command, opts, streamOutput) {
+    try {
+        if (streamOutput) {
+            (0, child_process_1.execSync)(command, { ...opts, stdio: "inherit" });
+            return { stdout: "", stderr: "", exitCode: 0 };
+        }
+        else {
+            const stdout = (0, child_process_1.execSync)(command, { ...opts, stdio: "pipe" }).toString();
+            return { stdout, stderr: "", exitCode: 0 };
+        }
+    }
+    catch (error) {
+        const stdout = error.stdout ? error.stdout.toString() : "";
+        const stderr = error.stderr ? error.stderr.toString() : "";
+        return { stdout, stderr, exitCode: error.status || 1 };
+    }
+}
+function TerraformApply(stack, streamOutput = false) {
+    try {
+        const manifestPath = path.resolve(stack, "manifest.json");
+        // Safety check: verify manifest exists before reading
+        if (!fs.existsSync(manifestPath)) {
+            throw new Error(`Manifest file not found at ${manifestPath}. ` +
+                `Ensure Testing.fullSynth() completed successfully and the output directory still exists.`);
+        }
+        const manifest = JSON.parse(fs.readFileSync(manifestPath, "utf8"));
+        const stacks = Object.entries(manifest.stacks);
+        for (const [, stackDetails] of stacks) {
+            const opts = {
+                cwd: path.resolve(stack, stackDetails.workingDirectory),
+                env: process.env,
+                encoding: "utf-8",
+            };
+            const initResult = execTerraformCommand(`terraform init`, opts, streamOutput);
+            if (initResult.exitCode !== 0)
+                throw new Error(`Terraform init failed: ${initResult.stdout} ${initResult.stderr}`);
+            const applyResult = execTerraformCommand(`terraform apply -auto-approve`, opts, streamOutput);
+            if (applyResult.exitCode !== 0) {
+                return {
+                    stdout: applyResult.stdout,
+                    stderr: applyResult.stderr,
+                    error: new Error(`Terraform apply failed: ${applyResult.stdout} ${applyResult.stderr}`),
+                };
+            }
+        }
+        return { stdout: "Terraform apply succeeded", stderr: "", error: null };
+    }
+    catch (error) {
+        console.error("Error during Terraform init or apply:", error);
+        return { stdout: "", stderr: "", error };
+    }
+}
+function TerraformPlanExitCode(stack, streamOutput = false) {
+    try {
+        const manifestPath = path.resolve(stack, "manifest.json");
+        // Safety check: verify manifest exists before reading
+        if (!fs.existsSync(manifestPath)) {
+            throw new Error(`Manifest file not found at ${manifestPath}. ` +
+                `Ensure Testing.fullSynth() completed successfully and the output directory still exists.`);
+        }
+        const manifest = JSON.parse(fs.readFileSync(manifestPath, "utf8"));
+        const stacks = Object.entries(manifest.stacks);
+        for (const [, stackDetails] of stacks) {
+            const opts = {
+                cwd: path.resolve(stack, stackDetails.workingDirectory),
+                env: process.env,
+                encoding: "utf-8",
+            };
+            const initResult = execTerraformCommand(`terraform init`, opts, streamOutput);
+            if (initResult.exitCode !== 0)
+                throw new Error(`Terraform init failed: ${initResult.stdout} ${initResult.stderr}`);
+            const planResult = execTerraformCommand(`terraform plan -input=false -lock=false -detailed-exitcode`, opts, streamOutput);
+            return {
+                stdout: planResult.stdout,
+                stderr: planResult.stderr,
+                exitCode: planResult.exitCode,
+                error: null,
+            };
+        }
+        return {
+            stdout: "Terraform plan succeeded",
+            stderr: "",
+            exitCode: 0,
+            error: null,
+        };
+    }
+    catch (error) {
+        console.error("Error during Terraform init or plan:", error);
+        return { stdout: "", stderr: "", exitCode: 1, error };
+    }
+}
+function TerraformIdempotentCheck(stack) {
+    try {
+        const manifestPath = path.resolve(stack, "manifest.json");
+        // Safety check: verify manifest exists before reading
+        if (!fs.existsSync(manifestPath)) {
+            throw new Error(`Manifest file not found at ${manifestPath}. ` +
+                `Ensure Testing.fullSynth() completed successfully and the output directory still exists.`);
+        }
+        const manifest = JSON.parse(fs.readFileSync(manifestPath, "utf8"));
+        const stacks = Object.entries(manifest.stacks);
+        for (const [, stackDetails] of stacks) {
+            const opts = {
+                cwd: path.resolve(stack, stackDetails.workingDirectory),
+                env: process.env,
+                stdio: "pipe",
+            };
+            (0, child_process_1.execSync)(`terraform init`, opts);
+            let planOutput;
+            try {
+                planOutput = (0, child_process_1.execSync)(`terraform plan -input=false -detailed-exitcode`, opts).toString();
+            }
+            catch (error) {
+                planOutput = error.stdout ? error.stdout.toString() : "";
+            }
+            if (planOutput.includes("No changes. Your infrastructure matches the configuration.")) {
+                return new AssertionReturn(`Expected subject to be idempotent with no changes`, true);
+            }
+            else {
+                throw new Error(`Plan resulted in changes:\n${planOutput}`);
+            }
+        }
+        return new AssertionReturn(`Expected subject to be idempotent with no changes`, true);
+    }
+    catch (error) {
+        console.error("Error during Terraform init or plan:", error);
+        throw error;
+    }
+}
+function TerraformDestroy(stack, streamOutput = false) {
+    try {
+        const manifestPath = path.resolve(stack, "manifest.json");
+        // Safety check: verify manifest exists before reading
+        if (!fs.existsSync(manifestPath)) {
+            throw new Error(`Manifest file not found at ${manifestPath}. ` +
+                `Ensure Testing.fullSynth() completed successfully and the output directory still exists.`);
+        }
+        const manifest = JSON.parse(fs.readFileSync(manifestPath, "utf8"));
+        const stacks = Object.entries(manifest.stacks);
+        for (const [, stackDetails] of stacks) {
+            const opts = {
+                cwd: path.resolve(stack, stackDetails.workingDirectory),
+                env: process.env,
+                encoding: "utf-8",
+            };
+            const initResult = execTerraformCommand(`terraform init`, opts, streamOutput);
+            if (initResult.exitCode !== 0)
+                throw new Error(`Terraform init failed: ${initResult.stdout} ${initResult.stderr}`);
+            const destroyResult = execTerraformCommand(`terraform destroy -auto-approve`, opts, streamOutput);
+            if (destroyResult.exitCode !== 0)
+                throw new Error(`Terraform destroy failed: ${destroyResult.stdout} ${destroyResult.stderr}`);
+        }
+        return new AssertionReturn(`Expected subject to destroy successfully`, true);
+    }
+    catch (error) {
+        console.error("Error during Terraform init or destroy:", error);
+        return new AssertionReturn(`Expected subject to destroy successfully`, false);
+    }
+}
+function TerraformApplyAndCheckIdempotency(stack, streamOutput = false) {
+    const applyResult = TerraformApply(stack, streamOutput);
+    if (applyResult.error) {
+        return new AssertionReturn(applyResult.error.message, false);
+    }
+    const planResult = TerraformPlanExitCode(stack, streamOutput);
+    if (planResult.error) {
+        return new AssertionReturn(planResult.error.message, false);
+    }
+    if (planResult.exitCode !== 0) {
+        return new AssertionReturn(`Terraform configuration not idempotent:\n${planResult.stdout}`, false);
+    }
+    return new AssertionReturn(`Terraform apply and idempotency check completed successfully`, true);
+}
+function TerraformApplyCheckAndDestroy(stack, options) {
+    const streamOutput = process.env.STREAM_OUTPUT === "true";
+    const verifyCleanup = options?.verifyCleanup ?? false;
+    // Extract metadata and resources if available
+    const metadata = stack.metadata;
+    const hasVerification = verifyCleanup && metadata;
+    try {
+        const applyAndCheckResult = TerraformApplyAndCheckIdempotency(stack, streamOutput);
+        if (!applyAndCheckResult.success) {
+            throw new Error(applyAndCheckResult.message);
+        }
+    }
+    catch (error) {
+        console.error("Error during Terraform apply and idempotency check:", error);
+        throw error; // Re-throw the error to ensure the test fails
+    }
+    finally {
+        try {
+            if (hasVerification) {
+                // Use enhanced destroy with verification
+                const resources = typeof stack.registeredResources === "function"
+                    ? stack.registeredResources()
+                    : [];
+                const destroyResult = TerraformDestroyWithVerification(stack, metadata, resources, streamOutput);
+                if (!destroyResult.success) {
+                    throw new Error(`Destroy verification failed: ${destroyResult.message}`);
+                }
+            }
+            else {
+                // Use standard destroy (backward compatible)
+                const destroyResult = TerraformDestroy(stack, streamOutput);
+                if (!destroyResult.success) {
+                    console.error("Error during Terraform destroy:", destroyResult.message);
+                }
+            }
+        }
+        catch (destroyError) {
+            console.error("Error during Terraform destroy:", destroyError);
+            throw destroyError; // Re-throw to fail the test
+        }
+        finally {
+            // Clean up this specific test's output directory
+            try {
+                if (fs.existsSync(stack)) {
+                    (0, child_process_1.execSync)(`rm -rf "${stack}"`);
+                }
+            }
+            catch (cleanupError) {
+                // Ignore cleanup errors - directory may already be gone
+            }
+        }
+    }
+}
+/**
+ * Enhanced terraform destroy with cleanup verification
+ *
+ * Performs terraform destroy and verifies resource cleanup via
+ * Azure Resource Graph queries. Implements retry logic for
+ * eventual consistency.
+ *
+ * @param stack - Terraform stack directory path
+ * @param metadata - Test run metadata
+ * @param resources - List of resources to verify deletion
+ * @param streamOutput - Whether to stream command output
+ * @returns Assertion result
+ */
+function TerraformDestroyWithVerification(stack, metadata, resources, streamOutput = false) {
+    try {
+        console.log("[Destroy] Starting terraform destroy...");
+        // Step 1: Run terraform destroy
+        const destroyResult = TerraformDestroy(stack, streamOutput);
+        if (!destroyResult.success) {
+            throw new Error(`Terraform destroy failed: ${destroyResult.message}`);
+        }
+        console.log("[Destroy] Terraform destroy completed successfully");
+        // Step 2: If no resources to verify, skip verification
+        if (resources.length === 0) {
+            console.log("[Destroy] No resources to verify (none registered)");
+            return new AssertionReturn("Terraform destroy completed (no verification needed)", true);
+        }
+        console.log(`[Destroy] Verifying cleanup of ${resources.length} resources...`);
+        console.log("[Destroy] Waiting 30s for Azure eventual consistency...");
+        // Step 3: Wait for eventual consistency
+        const sleep = (ms) => {
+            (0, child_process_1.execSync)(`sleep ${ms / 1000}`, { stdio: "ignore" });
+        };
+        sleep(30000);
+        // Step 4: Verify resources are deleted with retry logic
+        console.log("[Destroy] Starting verification...");
+        const verificationResult = (0, cleanup_1.verifyResourcesDeleted)(metadata.runId, resources);
+        if (!verificationResult.success) {
+            // Step 5: Retry verification after additional wait
+            console.warn("[Destroy] Initial verification failed, retrying...");
+            sleep(30000);
+            const retryResult = (0, cleanup_1.verifyResourcesDeleted)(metadata.runId, resources);
+            if (!retryResult.success) {
+                const errorMessage = `Resource cleanup verification failed:\n` +
+                    `  Expected: ${retryResult.expectedCount} resources\n` +
+                    `  Found: ${retryResult.foundCount} orphaned resources\n` +
+                    `  Orphaned IDs:\n` +
+                    retryResult.orphanedResources.map((id) => `    - ${id}`).join("\n");
+                console.error("[Destroy] ✗ Verification failed:", errorMessage);
+                throw new Error(errorMessage);
+            }
+            console.log("[Destroy] ✓ Verification succeeded on retry");
+        }
+        else {
+            console.log("[Destroy] ✓ All resources verified deleted");
+        }
+        return new AssertionReturn("Terraform destroy and verification completed successfully", true);
+    }
+    catch (error) {
+        console.error("[Destroy] Error during Terraform destroy and verification:", error);
+        return new AssertionReturn(`Terraform destroy and verification failed: ${error.message}`, false);
+    }
+}
+function TerraformPlan(stack) {
+    try {
+        const manifestPath = path.resolve(stack, "manifest.json");
+        // Safety check: verify manifest exists before reading
+        if (!fs.existsSync(manifestPath)) {
+            throw new Error(`Manifest file not found at ${manifestPath}. ` +
+                `Ensure Testing.fullSynth() completed successfully and the output directory still exists.`);
+        }
+        const manifest = JSON.parse(fs.readFileSync(manifestPath, "utf8"));
+        const stacks = Object.entries(manifest.stacks);
+        stacks.forEach(([, stackDetails]) => {
+            const opts = {
+                cwd: path.resolve(stack, stackDetails.workingDirectory),
+                env: process.env,
+                stdio: "pipe",
+            };
+            (0, child_process_1.execSync)(`terraform init`, opts);
+            (0, child_process_1.execSync)(`terraform plan -input=false -lock=false`, opts);
+        });
+        return new AssertionReturn(`Expected subject not to plan successfully`, true);
+    }
+    catch (error) {
+        console.error("Error during Terraform init or plan:", error);
+        throw error;
+        return new AssertionReturn("Expected subject to plan successfully, false", false);
+    }
+}
+class AssertionReturn {
+    /**
+     * Create an AssertionReturn
+     * @param message - String message containing information about the result of the assertion
+     * @param success - Boolean success denoting the success of the assertion
+     */
+    constructor(message, success) {
+        this.message = message;
+        this.success = success;
+        if (!success) {
+            throw new Error(message);
+        }
+    }
+}
+exports.AssertionReturn = AssertionReturn;
+_b = JSII_RTTI_SYMBOL_1;
+AssertionReturn[_b] = { fqn: "@microsoft/terraform-cdk-constructs.AssertionReturn", version: "1.2.0" };
+/**
+ * Cleanup function for removing all CDKTF output directories in /tmp.
+ *
+ * WARNING: This function should NOT be used in afterAll() hooks when running
+ * tests in parallel, as it will delete directories that other running tests
+ * may still be using. Instead, TerraformApplyCheckAndDestroy now cleans up
+ * its own directory automatically.
+ *
+ * This function is kept for manual cleanup or single-threaded test scenarios.
+ */
+function cleanupCdkTfOutDirs() {
+    try {
+        (0, child_process_1.execSync)('find /tmp -name "cdktf.outdir.*" -type d -exec rm -rf {} +');
+    }
+    catch (error) {
+        console.error("Error during cleanup:", error);
+    }
+}
+// Export cleanup utilities
+var cleanup_2 = require("./lib/cleanup");
+Object.defineProperty(exports, "ResourceCleanupService", { enumerable: true, get: function () { return cleanup_2.ResourceCleanupService; } });
+Object.defineProperty(exports, "verifyResourcesDeleted", { enumerable: true, get: function () { return cleanup_2.verifyResourcesDeleted; } });
+Object.defineProperty(exports, "verifyResourcesDeletedWithRetry", { enumerable: true, get: function () { return cleanup_2.verifyResourcesDeletedWithRetry; } });
+Object.defineProperty(exports, "findOrphanedResources", { enumerable: true, get: function () { return cleanup_2.findOrphanedResources; } });
+Object.defineProperty(exports, "cleanupOrphanedResources", { enumerable: true, get: function () { return cleanup_2.cleanupOrphanedResources; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/testing/index.ts"],"names":[],"mappings":";;;;AA4KA,oDAkBC;AAED,wCAwDC;AAED,sDA0DC;AACD,4DAwDC;AAED,4CAyDC;AAED,8EAyBC;AAED,sEAmEC;AAeD,4EAmFC;AAED,sCAoCC;AA4BD,kDAMC;;AAlrBD,iDAA4E;AAC5E,yBAAyB;AACzB,6BAA6B;AAC7B,+BAA+B;AAC/B,iCAAuC;AAEvC,2CAAyE;AACzE,6CAAiE;AACjE,yCAAoD;AAEpD,0DAA0D;AAC1D,2CAA4E;AAAnD,2GAAA,eAAe,OAAA;AAYxC;;;;;GAKG;AACH,MAAa,aAAc,SAAQ,sBAAc;IAa/C,YAAY,KAAgB,EAAE,EAAU,EAAE,OAA8B;QACtE,KAAK,CAAC,KAAK,EAAE,EAAE,CAAC,CAAC;QANnB;;WAEG;QACc,qBAAgB,GAAkC,IAAI,GAAG,EAAE,CAAC;QAK3E,4CAA4C;QAC5C,IAAI,OAAO,EAAE,cAAc,EAAE,CAAC;YAC5B,IAAI,CAAC,QAAQ,GAAG,IAAI,0BAAe,CAAC,EAAE,EAAE,OAAO,CAAC,cAAc,CAAC,CAAC;YAEhE,2BAA2B;YAC3B,OAAO,CAAC,GAAG,CAAC,kBAAkB,IAAI,CAAC,QAAQ,CAAC,KAAK,EAAE,CAAC,CAAC;YACrD,OAAO,CAAC,GAAG,CAAC,oBAAoB,IAAI,CAAC,QAAQ,CAAC,QAAQ,EAAE,CAAC,CAAC;YAC1D,OAAO,CAAC,GAAG,CACT,uBAAuB,IAAI,CAAC,QAAQ,CAAC,SAAS,CAAC,WAAW,EAAE,EAAE,CAC/D,CAAC;YACF,OAAO,CAAC,GAAG,CACT,6BAA6B,IAAI,CAAC,QAAQ,CAAC,YAAY,CAAC,WAAW,EAAE,EAAE,CACxE,CAAC;YACF,IAAI,IAAI,CAAC,QAAQ,CAAC,SAAS,EAAE,CAAC;gBAC5B,OAAO,CAAC,GAAG,CACT,2BAA2B,IAAI,CAAC,QAAQ,CAAC,SAAS,CAAC,QAAQ,EAAE,CAC9D,CAAC;YACJ,CAAC;QACH,CAAC;QAED,MAAM,IAAI,GAAG,IAAI,KAAK,CAAC,iBAAiB,CAAC,IAAI,EAAE,MAAM,EAAE;YACrD,IAAI,EAAE,QAAQ;YACd,OAAO,EAAE,IAAI,CAAC,QAAQ,EAAE,QAAQ,IAAI,MAAM;YAC1C,WAAW,EAAE,6CAA6C;SAC3D,CAAC,CAAC;QAEH,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC,KAAK,CAAC;IACzB,CAAC;IAED;;;;;;;;OAQG;IACI,gBAAgB,CACrB,UAAkB,EAClB,YAAoB,EACpB,IAAY,EACZ,QAAiB,EACjB,IAA6B;QAE7B,IAAI,CAAC,IAAI,CAAC,QAAQ,EAAE,CAAC;YACnB,OAAO,CAAC,IAAI,CACV,2DAA2D;gBACzD,6DAA6D,CAChE,CAAC;YACF,OAAO;QACT,CAAC;QAED,MAAM,QAAQ,GAAqB;YACjC,UAAU;YACV,YAAY;YACZ,IAAI;YACJ,QAAQ;YACR,IAAI,EAAE,IAAI,IAAI,EAAE;YAChB,SAAS,EAAE,IAAI,CAAC,QAAQ,CAAC,KAAK;YAC9B,SAAS,EAAE,IAAI,CAAC,QAAQ,CAAC,SAAS;SACnC,CAAC;QAEF,IAAI,CAAC,gBAAgB,CAAC,GAAG,CAAC,UAAU,EAAE,QAAQ,CAAC,CAAC;QAChD,OAAO,CAAC,GAAG,CACT,wCAAwC,IAAI,KAAK,YAAY,GAAG,CACjE,CAAC;IACJ,CAAC;IAED;;;;OAIG;IACI,mBAAmB;QACxB,OAAO,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,gBAAgB,CAAC,MAAM,EAAE,CAAC,CAAC;IACpD,CAAC;IAED;;;;;OAKG;IACI,UAAU;QACf,IAAI,CAAC,IAAI,CAAC,QAAQ,EAAE,CAAC;YACnB,MAAM,IAAI,KAAK,CACb,wFAAwF;gBACtF,oEAAoE,CACvE,CAAC;QACJ,CAAC;QACD,OAAO,IAAI,CAAC,QAAQ,CAAC,kBAAkB,EAAE,CAAC;IAC5C,CAAC;IAED;;;;;;;;;;;;OAYG;IACI,oBAAoB,CACzB,YAAoB,EACpB,gBAAyB;QAEzB,IAAI,CAAC,IAAI,CAAC,QAAQ,EAAE,CAAC;YACnB,MAAM,IAAI,KAAK,CACb,oGAAoG;gBAClG,oEAAoE,CACvE,CAAC;QACJ,CAAC;QAED,OAAO,IAAA,6BAAoB,EAAC;YAC1B,YAAY;YACZ,QAAQ,EAAE,IAAI,CAAC,QAAQ,CAAC,QAAQ;YAChC,KAAK,EAAE,IAAI,CAAC,QAAQ,CAAC,KAAK;YAC1B,gBAAgB;SACjB,CAAC,CAAC;IACL,CAAC;;AA5IH,sCA6IC;;;AAED,SAAgB,oBAAoB,CAClC,OAAe,EACf,IAAuC,EACvC,YAAqB;IAErB,IAAI,CAAC;QACH,IAAI,YAAY,EAAE,CAAC;YACjB,IAAA,wBAAQ,EAAC,OAAO,EAAE,EAAE,GAAG,IAAI,EAAE,KAAK,EAAE,SAAS,EAAE,CAAC,CAAC;YACjD,OAAO,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,QAAQ,EAAE,CAAC,EAAE,CAAC;QACjD,CAAC;aAAM,CAAC;YACN,MAAM,MAAM,GAAG,IAAA,wBAAQ,EAAC,OAAO,EAAE,EAAE,GAAG,IAAI,EAAE,KAAK,EAAE,MAAM,EAAE,CAAC,CAAC,QAAQ,EAAE,CAAC;YACxE,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,EAAE,EAAE,QAAQ,EAAE,CAAC,EAAE,CAAC;QAC7C,CAAC;IACH,CAAC;IAAC,OAAO,KAAU,EAAE,CAAC;QACpB,MAAM,MAAM,GAAG,KAAK,CAAC,MAAM,CAAC,CAAC,CAAC,KAAK,CAAC,MAAM,CAAC,QAAQ,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;QAC3D,MAAM,MAAM,GAAG,KAAK,CAAC,MAAM,CAAC,CAAC,CAAC,KAAK,CAAC,MAAM,CAAC,QAAQ,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;QAC3D,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,KAAK,CAAC,MAAM,IAAI,CAAC,EAAE,CAAC;IACzD,CAAC;AACH,CAAC;AAED,SAAgB,cAAc,CAC5B,KAAU,EACV,eAAwB,KAAK;IAE7B,IAAI,CAAC;QACH,MAAM,YAAY,GAAG,IAAI,CAAC,OAAO,CAAC,KAAK,EAAE,eAAe,CAAC,CAAC;QAE1D,sDAAsD;QACtD,IAAI,CAAC,EAAE,CAAC,UAAU,CAAC,YAAY,CAAC,EAAE,CAAC;YACjC,MAAM,IAAI,KAAK,CACb,8BAA8B,YAAY,IAAI;gBAC5C,0FAA0F,CAC7F,CAAC;QACJ,CAAC;QAED,MAAM,QAAQ,GAAG,IAAI,CAAC,KAAK,CAAC,EAAE,CAAC,YAAY,CAAC,YAAY,EAAE,MAAM,CAAC,CAAC,CAAC;QACnE,MAAM,MAAM,GAAG,MAAM,CAAC,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC;QAE/C,KAAK,MAAM,CAAC,EAAE,YAAY,CAAC,IAAI,MAAM,EAAE,CAAC;YACtC,MAAM,IAAI,GAAsC;gBAC9C,GAAG,EAAE,IAAI,CAAC,OAAO,CAAC,KAAK,EAAG,YAAoB,CAAC,gBAAgB,CAAC;gBAChE,GAAG,EAAE,OAAO,CAAC,GAAG;gBAChB,QAAQ,EAAE,OAAO;aAClB,CAAC;YAEF,MAAM,UAAU,GAAG,oBAAoB,CACrC,gBAAgB,EAChB,IAAI,EACJ,YAAY,CACb,CAAC;YACF,IAAI,UAAU,CAAC,QAAQ,KAAK,CAAC;gBAC3B,MAAM,IAAI,KAAK,CACb,0BAA0B,UAAU,CAAC,MAAM,IAAI,UAAU,CAAC,MAAM,EAAE,CACnE,CAAC;YAEJ,MAAM,WAAW,GAAG,oBAAoB,CACtC,+BAA+B,EAC/B,IAAI,EACJ,YAAY,CACb,CAAC;YACF,IAAI,WAAW,CAAC,QAAQ,KAAK,CAAC,EAAE,CAAC;gBAC/B,OAAO;oBACL,MAAM,EAAE,WAAW,CAAC,MAAM;oBAC1B,MAAM,EAAE,WAAW,CAAC,MAAM;oBAC1B,KAAK,EAAE,IAAI,KAAK,CACd,2BAA2B,WAAW,CAAC,MAAM,IAAI,WAAW,CAAC,MAAM,EAAE,CACtE;iBACF,CAAC;YACJ,CAAC;QACH,CAAC;QAED,OAAO,EAAE,MAAM,EAAE,2BAA2B,EAAE,MAAM,EAAE,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC;IAC1E,CAAC;IAAC,OAAO,KAAU,EAAE,CAAC;QACpB,OAAO,CAAC,KAAK,CAAC,uCAAuC,EAAE,KAAK,CAAC,CAAC;QAC9D,OAAO,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,KAAK,EAAE,CAAC;IAC3C,CAAC;AACH,CAAC;AAED,SAAgB,qBAAqB,CACnC,KAAU,EACV,eAAwB,KAAK;IAE7B,IAAI,CAAC;QACH,MAAM,YAAY,GAAG,IAAI,CAAC,OAAO,CAAC,KAAK,EAAE,eAAe,CAAC,CAAC;QAE1D,sDAAsD;QACtD,IAAI,CAAC,EAAE,CAAC,UAAU,CAAC,YAAY,CAAC,EAAE,CAAC;YACjC,MAAM,IAAI,KAAK,CACb,8BAA8B,YAAY,IAAI;gBAC5C,0FAA0F,CAC7F,CAAC;QACJ,CAAC;QAED,MAAM,QAAQ,GAAG,IAAI,CAAC,KAAK,CAAC,EAAE,CAAC,YAAY,CAAC,YAAY,EAAE,MAAM,CAAC,CAAC,CAAC;QACnE,MAAM,MAAM,GAAG,MAAM,CAAC,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC;QAE/C,KAAK,MAAM,CAAC,EAAE,YAAY,CAAC,IAAI,MAAM,EAAE,CAAC;YACtC,MAAM,IAAI,GAAsC;gBAC9C,GAAG,EAAE,IAAI,CAAC,OAAO,CAAC,KAAK,EAAG,YAAoB,CAAC,gBAAgB,CAAC;gBAChE,GAAG,EAAE,OAAO,CAAC,GAAG;gBAChB,QAAQ,EAAE,OAAO;aAClB,CAAC;YAEF,MAAM,UAAU,GAAG,oBAAoB,CACrC,gBAAgB,EAChB,IAAI,EACJ,YAAY,CACb,CAAC;YACF,IAAI,UAAU,CAAC,QAAQ,KAAK,CAAC;gBAC3B,MAAM,IAAI,KAAK,CACb,0BAA0B,UAAU,CAAC,MAAM,IAAI,UAAU,CAAC,MAAM,EAAE,CACnE,CAAC;YAEJ,MAAM,UAAU,GAAG,oBAAoB,CACrC,4DAA4D,EAC5D,IAAI,EACJ,YAAY,CACb,CAAC;YACF,OAAO;gBACL,MAAM,EAAE,UAAU,CAAC,MAAM;gBACzB,MAAM,EAAE,UAAU,CAAC,MAAM;gBACzB,QAAQ,EAAE,UAAU,CAAC,QAAQ;gBAC7B,KAAK,EAAE,IAAI;aACZ,CAAC;QACJ,CAAC;QAED,OAAO;YACL,MAAM,EAAE,0BAA0B;YAClC,MAAM,EAAE,EAAE;YACV,QAAQ,EAAE,CAAC;YACX,KAAK,EAAE,IAAI;SACZ,CAAC;IACJ,CAAC;IAAC,OAAO,KAAU,EAAE,CAAC;QACpB,OAAO,CAAC,KAAK,CAAC,sCAAsC,EAAE,KAAK,CAAC,CAAC;QAC7D,OAAO,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,QAAQ,EAAE,CAAC,EAAE,KAAK,EAAE,CAAC;IACxD,CAAC;AACH,CAAC;AACD,SAAgB,wBAAwB,CAAC,KAAU;IACjD,IAAI,CAAC;QACH,MAAM,YAAY,GAAG,IAAI,CAAC,OAAO,CAAC,KAAK,EAAE,eAAe,CAAC,CAAC;QAE1D,sDAAsD;QACtD,IAAI,CAAC,EAAE,CAAC,UAAU,CAAC,YAAY,CAAC,EAAE,CAAC;YACjC,MAAM,IAAI,KAAK,CACb,8BAA8B,YAAY,IAAI;gBAC5C,0FAA0F,CAC7F,CAAC;QACJ,CAAC;QAED,MAAM,QAAQ,GAAG,IAAI,CAAC,KAAK,CAAC,EAAE,CAAC,YAAY,CAAC,YAAY,EAAE,MAAM,CAAC,CAAC,CAAC;QACnE,MAAM,MAAM,GAAG,MAAM,CAAC,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC;QAE/C,KAAK,MAAM,CAAC,EAAE,YAAY,CAAC,IAAI,MAAM,EAAE,CAAC;YACtC,MAAM,IAAI,GAAG;gBACX,GAAG,EAAE,IAAI,CAAC,OAAO,CAAC,KAAK,EAAG,YAAoB,CAAC,gBAAgB,CAAC;gBAChE,GAAG,EAAE,OAAO,CAAC,GAAG;gBAChB,KAAK,EAAE,MAAM;aACP,CAAC;YAET,IAAA,wBAAQ,EAAC,gBAAgB,EAAE,IAAI,CAAC,CAAC;YAEjC,IAAI,UAAkB,CAAC;YACvB,IAAI,CAAC;gBACH,UAAU,GAAG,IAAA,wBAAQ,EACnB,gDAAgD,EAChD,IAAI,CACL,CAAC,QAAQ,EAAE,CAAC;YACf,CAAC;YAAC,OAAO,KAAU,EAAE,CAAC;gBACpB,UAAU,GAAG,KAAK,CAAC,MAAM,CAAC,CAAC,CAAC,KAAK,CAAC,MAAM,CAAC,QAAQ,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;YAC3D,CAAC;YAED,IACE,UAAU,CAAC,QAAQ,CACjB,4DAA4D,CAC7D,EACD,CAAC;gBACD,OAAO,IAAI,eAAe,CACxB,mDAAmD,EACnD,IAAI,CACL,CAAC;YACJ,CAAC;iBAAM,CAAC;gBACN,MAAM,IAAI,KAAK,CAAC,8BAA8B,UAAU,EAAE,CAAC,CAAC;YAC9D,CAAC;QACH,CAAC;QAED,OAAO,IAAI,eAAe,CACxB,mDAAmD,EACnD,IAAI,CACL,CAAC;IACJ,CAAC;IAAC,OAAO,KAAK,EAAE,CAAC;QACf,OAAO,CAAC,KAAK,CAAC,sCAAsC,EAAE,KAAK,CAAC,CAAC;QAC7D,MAAM,KAAK,CAAC;IACd,CAAC;AACH,CAAC;AAED,SAAgB,gBAAgB,CAC9B,KAAU,EACV,eAAwB,KAAK;IAE7B,IAAI,CAAC;QACH,MAAM,YAAY,GAAG,IAAI,CAAC,OAAO,CAAC,KAAK,EAAE,eAAe,CAAC,CAAC;QAE1D,sDAAsD;QACtD,IAAI,CAAC,EAAE,CAAC,UAAU,CAAC,YAAY,CAAC,EAAE,CAAC;YACjC,MAAM,IAAI,KAAK,CACb,8BAA8B,YAAY,IAAI;gBAC5C,0FAA0F,CAC7F,CAAC;QACJ,CAAC;QAED,MAAM,QAAQ,GAAG,IAAI,CAAC,KAAK,CAAC,EAAE,CAAC,YAAY,CAAC,YAAY,EAAE,MAAM,CAAC,CAAC,CAAC;QACnE,MAAM,MAAM,GAAG,MAAM,CAAC,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC;QAE/C,KAAK,MAAM,CAAC,EAAE,YAAY,CAAC,IAAI,MAAM,EAAE,CAAC;YACtC,MAAM,IAAI,GAAsC;gBAC9C,GAAG,EAAE,IAAI,CAAC,OAAO,CAAC,KAAK,EAAG,YAAoB,CAAC,gBAAgB,CAAC;gBAChE,GAAG,EAAE,OAAO,CAAC,GAAG;gBAChB,QAAQ,EAAE,OAAO;aAClB,CAAC;YAEF,MAAM,UAAU,GAAG,oBAAoB,CACrC,gBAAgB,EAChB,IAAI,EACJ,YAAY,CACb,CAAC;YACF,IAAI,UAAU,CAAC,QAAQ,KAAK,CAAC;gBAC3B,MAAM,IAAI,KAAK,CACb,0BAA0B,UAAU,CAAC,MAAM,IAAI,UAAU,CAAC,MAAM,EAAE,CACnE,CAAC;YAEJ,MAAM,aAAa,GAAG,oBAAoB,CACxC,iCAAiC,EACjC,IAAI,EACJ,YAAY,CACb,CAAC;YACF,IAAI,aAAa,CAAC,QAAQ,KAAK,CAAC;gBAC9B,MAAM,IAAI,KAAK,CACb,6BAA6B,aAAa,CAAC,MAAM,IAAI,aAAa,CAAC,MAAM,EAAE,CAC5E,CAAC;QACN,CAAC;QAED,OAAO,IAAI,eAAe,CACxB,0CAA0C,EAC1C,IAAI,CACL,CAAC;IACJ,CAAC;IAAC,OAAO,KAAU,EAAE,CAAC;QACpB,OAAO,CAAC,KAAK,CAAC,yCAAyC,EAAE,KAAK,CAAC,CAAC;QAChE,OAAO,IAAI,eAAe,CACxB,0CAA0C,EAC1C,KAAK,CACN,CAAC;IACJ,CAAC;AACH,CAAC;AAED,SAAgB,iCAAiC,CAC/C,KAAU,EACV,eAAwB,KAAK;IAE7B,MAAM,WAAW,GAAG,cAAc,CAAC,KAAK,EAAE,YAAY,CAAC,CAAC;IACxD,IAAI,WAAW,CAAC,KAAK,EAAE,CAAC;QACtB,OAAO,IAAI,eAAe,CAAC,WAAW,CAAC,KAAK,CAAC,OAAO,EAAE,KAAK,CAAC,CAAC;IAC/D,CAAC;IAED,MAAM,UAAU,GAAG,qBAAqB,CAAC,KAAK,EAAE,YAAY,CAAC,CAAC;IAC9D,IAAI,UAAU,CAAC,KAAK,EAAE,CAAC;QACrB,OAAO,IAAI,eAAe,CAAC,UAAU,CAAC,KAAK,CAAC,OAAO,EAAE,KAAK,CAAC,CAAC;IAC9D,CAAC;IAED,IAAI,UAAU,CAAC,QAAQ,KAAK,CAAC,EAAE,CAAC;QAC9B,OAAO,IAAI,eAAe,CACxB,4CAA4C,UAAU,CAAC,MAAM,EAAE,EAC/D,KAAK,CACN,CAAC;IACJ,CAAC;IAED,OAAO,IAAI,eAAe,CACxB,8DAA8D,EAC9D,IAAI,CACL,CAAC;AACJ,CAAC;AAED,SAAgB,6BAA6B,CAC3C,KAAU,EACV,OAAqC;IAErC,MAAM,YAAY,GAAG,OAAO,CAAC,GAAG,CAAC,aAAa,KAAK,MAAM,CAAC;IAC1D,MAAM,aAAa,GAAG,OAAO,EAAE,aAAa,IAAI,KAAK,CAAC;IAEtD,8CAA8C;IAC9C,MAAM,QAAQ,GAAiC,KAAa,CAAC,QAAQ,CAAC;IACtE,MAAM,eAAe,GAAG,aAAa,IAAI,QAAQ,CAAC;IAElD,IAAI,CAAC;QACH,MAAM,mBAAmB,GAAG,iCAAiC,CAC3D,KAAK,EACL,YAAY,CACb,CAAC;QACF,IAAI,CAAC,mBAAmB,CAAC,OAAO,EAAE,CAAC;YACjC,MAAM,IAAI,KAAK,CAAC,mBAAmB,CAAC,OAAO,CAAC,CAAC;QAC/C,CAAC;IACH,CAAC;IAAC,OAAO,KAAK,EAAE,CAAC;QACf,OAAO,CAAC,KAAK,CAAC,qDAAqD,EAAE,KAAK,CAAC,CAAC;QAC5E,MAAM,KAAK,CAAC,CAAC,8CAA8C;IAC7D,CAAC;YAAS,CAAC;QACT,IAAI,CAAC;YACH,IAAI,eAAe,EAAE,CAAC;gBACpB,yCAAyC;gBACzC,MAAM,SAAS,GACb,OAAQ,KAAa,CAAC,mBAAmB,KAAK,UAAU;oBACtD,CAAC,CAAE,KAAa,CAAC,mBAAmB,EAAE;oBACtC,CAAC,CAAC,EAAE,CAAC;gBAET,MAAM,aAAa,GAAG,gCAAgC,CACpD,KAAK,EACL,QAAS,EACT,SAAS,EACT,YAAY,CACb,CAAC;gBAEF,IAAI,CAAC,aAAa,CAAC,OAAO,EAAE,CAAC;oBAC3B,MAAM,IAAI,KAAK,CACb,gCAAgC,aAAa,CAAC,OAAO,EAAE,CACxD,CAAC;gBACJ,CAAC;YACH,CAAC;iBAAM,CAAC;gBACN,6CAA6C;gBAC7C,MAAM,aAAa,GAAG,gBAAgB,CAAC,KAAK,EAAE,YAAY,CAAC,CAAC;gBAC5D,IAAI,CAAC,aAAa,CAAC,OAAO,EAAE,CAAC;oBAC3B,OAAO,CAAC,KAAK,CACX,iCAAiC,EACjC,aAAa,CAAC,OAAO,CACtB,CAAC;gBACJ,CAAC;YACH,CAAC;QACH,CAAC;QAAC,OAAO,YAAY,EAAE,CAAC;YACtB,OAAO,CAAC,KAAK,CAAC,iCAAiC,EAAE,YAAY,CAAC,CAAC;YAC/D,MAAM,YAAY,CAAC,CAAC,4BAA4B;QAClD,CAAC;gBAAS,CAAC;YACT,iDAAiD;YACjD,IAAI,CAAC;gBACH,IAAI,EAAE,CAAC,UAAU,CAAC,KAAK,CAAC,EAAE,CAAC;oBACzB,IAAA,wBAAQ,EAAC,WAAW,KAAK,GAAG,CAAC,CAAC;gBAChC,CAAC;YACH,CAAC;YAAC,OAAO,YAAY,EAAE,CAAC;gBACtB,wDAAwD;YAC1D,CAAC;QACH,CAAC;IACH,CAAC;AACH,CAAC;AAED;;;;;;;;;;;;GAYG;AACH,SAAgB,gCAAgC,CAC9C,KAAU,EACV,QAAyB,EACzB,SAA6B,EAC7B,eAAwB,KAAK;IAE7B,IAAI,CAAC;QACH,OAAO,CAAC,GAAG,CAAC,yCAAyC,CAAC,CAAC;QAEvD,gCAAgC;QAChC,MAAM,aAAa,GAAG,gBAAgB,CAAC,KAAK,EAAE,YAAY,CAAC,CAAC;QAE5D,IAAI,CAAC,aAAa,CAAC,OAAO,EAAE,CAAC;YAC3B,MAAM,IAAI,KAAK,CAAC,6BAA6B,aAAa,CAAC,OAAO,EAAE,CAAC,CAAC;QACxE,CAAC;QAED,OAAO,CAAC,GAAG,CAAC,oDAAoD,CAAC,CAAC;QAElE,uDAAuD;QACvD,IAAI,SAAS,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;YAC3B,OAAO,CAAC,GAAG,CAAC,oDAAoD,CAAC,CAAC;YAClE,OAAO,IAAI,eAAe,CACxB,sDAAsD,EACtD,IAAI,CACL,CAAC;QACJ,CAAC;QAED,OAAO,CAAC,GAAG,CACT,kCAAkC,SAAS,CAAC,MAAM,eAAe,CAClE,CAAC;QACF,OAAO,CAAC,GAAG,CAAC,yDAAyD,CAAC,CAAC;QAEvE,wCAAwC;QACxC,MAAM,KAAK,GAAG,CAAC,EAAU,EAAE,EAAE;YAC3B,IAAA,wBAAQ,EAAC,SAAS,EAAE,GAAG,IAAI,EAAE,EAAE,EAAE,KAAK,EAAE,QAAQ,EAAE,CAAC,CAAC;QACtD,CAAC,CAAC;QACF,KAAK,CAAC,KAAK,CAAC,CAAC;QAEb,wDAAwD;QACxD,OAAO,CAAC,GAAG,CAAC,oCAAoC,CAAC,CAAC;QAClD,MAAM,kBAAkB,GAAG,IAAA,gCAAsB,EAC/C,QAAQ,CAAC,KAAK,EACd,SAAS,CACV,CAAC;QAEF,IAAI,CAAC,kBAAkB,CAAC,OAAO,EAAE,CAAC;YAChC,mDAAmD;YACnD,OAAO,CAAC,IAAI,CAAC,oDAAoD,CAAC,CAAC;YACnE,KAAK,CAAC,KAAK,CAAC,CAAC;YAEb,MAAM,WAAW,GAAG,IAAA,gCAAsB,EAAC,QAAQ,CAAC,KAAK,EAAE,SAAS,CAAC,CAAC;YAEtE,IAAI,CAAC,WAAW,CAAC,OAAO,EAAE,CAAC;gBACzB,MAAM,YAAY,GAChB,yCAAyC;oBACzC,eAAe,WAAW,CAAC,aAAa,cAAc;oBACtD,YAAY,WAAW,CAAC,UAAU,uBAAuB;oBACzD,mBAAmB;oBACnB,WAAW,CAAC,iBAAiB,CAAC,GAAG,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,SAAS,EAAE,EAAE,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;gBAEtE,OAAO,CAAC,KAAK,CAAC,kCAAkC,EAAE,YAAY,CAAC,CAAC;gBAChE,MAAM,IAAI,KAAK,CAAC,YAAY,CAAC,CAAC;YAChC,CAAC;YAED,OAAO,CAAC,GAAG,CAAC,6CAA6C,CAAC,CAAC;QAC7D,CAAC;aAAM,CAAC;YACN,OAAO,CAAC,GAAG,CAAC,4CAA4C,CAAC,CAAC;QAC5D,CAAC;QAED,OAAO,IAAI,eAAe,CACxB,2DAA2D,EAC3D,IAAI,CACL,CAAC;IACJ,CAAC;IAAC,OAAO,KAAU,EAAE,CAAC;QACpB,OAAO,CAAC,KAAK,CACX,4DAA4D,EAC5D,KAAK,CACN,CAAC;QACF,OAAO,IAAI,eAAe,CACxB,8CAA8C,KAAK,CAAC,OAAO,EAAE,EAC7D,KAAK,CACN,CAAC;IACJ,CAAC;AACH,CAAC;AAED,SAAgB,aAAa,CAAC,KAAU;IACtC,IAAI,CAAC;QACH,MAAM,YAAY,GAAG,IAAI,CAAC,OAAO,CAAC,KAAK,EAAE,eAAe,CAAC,CAAC;QAE1D,sDAAsD;QACtD,IAAI,CAAC,EAAE,CAAC,UAAU,CAAC,YAAY,CAAC,EAAE,CAAC;YACjC,MAAM,IAAI,KAAK,CACb,8BAA8B,YAAY,IAAI;gBAC5C,0FAA0F,CAC7F,CAAC;QACJ,CAAC;QAED,MAAM,QAAQ,GAAG,IAAI,CAAC,KAAK,CAAC,EAAE,CAAC,YAAY,CAAC,YAAY,EAAE,MAAM,CAAC,CAAC,CAAC;QACnE,MAAM,MAAM,GAAG,MAAM,CAAC,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC;QAC/C,MAAM,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE,YAAY,CAAC,EAAE,EAAE;YAClC,MAAM,IAAI,GAAG;gBACX,GAAG,EAAE,IAAI,CAAC,OAAO,CAAC,KAAK,EAAG,YAAoB,CAAC,gBAAgB,CAAC;gBAChE,GAAG,EAAE,OAAO,CAAC,GAAG;gBAChB,KAAK,EAAE,MAAM;aACP,CAAC;YACT,IAAA,wBAAQ,EAAC,gBAAgB,EAAE,IAAI,CAAC,CAAC;YACjC,IAAA,wBAAQ,EAAC,yCAAyC,EAAE,IAAI,CAAC,CAAC;QAC5D,CAAC,CAAC,CAAC;QAEH,OAAO,IAAI,eAAe,CACxB,2CAA2C,EAC3C,IAAI,CACL,CAAC;IACJ,CAAC;IAAC,OAAO,KAAK,EAAE,CAAC;QACf,OAAO,CAAC,KAAK,CAAC,sCAAsC,EAAE,KAAK,CAAC,CAAC;QAC7D,MAAM,KAAK,CAAC;QACZ,OAAO,IAAI,eAAe,CACxB,8CAA8C,EAC9C,KAAK,CACN,CAAC;IACJ,CAAC;AACH,CAAC;AAED,MAAa,eAAe;IAC1B;;;;OAIG;IACH,YACkB,OAAe,EACf,OAAgB;QADhB,YAAO,GAAP,OAAO,CAAQ;QACf,YAAO,GAAP,OAAO,CAAS;QAEhC,IAAI,CAAC,OAAO,EAAE,CAAC;YACb,MAAM,IAAI,KAAK,CAAC,OAAO,CAAC,CAAC;QAC3B,CAAC;IACH,CAAC;;AAbH,0CAcC;;;AAED;;;;;;;;;GASG;AACH,SAAgB,mBAAmB;IACjC,IAAI,CAAC;QACH,IAAA,wBAAQ,EAAC,4DAA4D,CAAC,CAAC;IACzE,CAAC;IAAC,OAAO,KAAK,EAAE,CAAC;QACf,OAAO,CAAC,KAAK,CAAC,uBAAuB,EAAE,KAAK,CAAC,CAAC;IAChD,CAAC;AACH,CAAC;AAED,2BAA2B;AAC3B,yCAWuB;AALrB,iHAAA,sBAAsB,OAAA;AACtB,iHAAA,sBAAsB,OAAA;AACtB,0HAAA,+BAA+B,OAAA;AAC/B,gHAAA,qBAAqB,OAAA;AACrB,mHAAA,wBAAwB,OAAA","sourcesContent":["import { execSync, ExecSyncOptionsWithStringEncoding } from \"child_process\";\nimport * as fs from \"fs\";\nimport * as path from \"path\";\nimport * as cdktf from \"cdktf\";\nimport { TerraformStack } from \"cdktf\";\nimport { Construct } from \"constructs\";\nimport { ResourceMetadata, verifyResourcesDeleted } from \"./lib/cleanup\";\nimport { TestRunMetadata, TestRunOptions } from \"./lib/metadata\";\nimport { generateResourceName } from \"./lib/naming\";\n\n// Re-export types used in public APIs for jsii compliance\nexport { TestRunOptions, TestRunMetadata, CIContext } from \"./lib/metadata\";\n\n/**\n * Options for BaseTestStack constructor\n */\nexport interface BaseTestStackOptions {\n  /**\n   * Test run configuration options\n   */\n  readonly testRunOptions?: TestRunOptions;\n}\n\n/**\n * Base stack for integration tests with optional metadata support\n *\n * When metadata is enabled, automatically generates unique test run IDs,\n * injects system tags, and provides utilities for resource naming.\n */\nexport class BaseTestStack extends TerraformStack {\n  public readonly name: string;\n\n  /**\n   * Optional test run metadata (only present when using BaseTestStackOptions)\n   */\n  public readonly metadata?: TestRunMetadata;\n\n  /**\n   * Registry of resources created in this stack for tracking and cleanup verification\n   */\n  private readonly resourceRegistry: Map<string, ResourceMetadata> = new Map();\n\n  constructor(scope: Construct, id: string, options?: BaseTestStackOptions) {\n    super(scope, id);\n\n    // Generate metadata if options are provided\n    if (options?.testRunOptions) {\n      this.metadata = new TestRunMetadata(id, options.testRunOptions);\n\n      // Log test run information\n      console.log(`[Test Run] ID: ${this.metadata.runId}`);\n      console.log(`[Test Run] Name: ${this.metadata.testName}`);\n      console.log(\n        `[Test Run] Created: ${this.metadata.createdAt.toISOString()}`,\n      );\n      console.log(\n        `[Test Run] Cleanup After: ${this.metadata.cleanupAfter.toISOString()}`,\n      );\n      if (this.metadata.ciContext) {\n        console.log(\n          `[Test Run] CI Platform: ${this.metadata.ciContext.platform}`,\n        );\n      }\n    }\n\n    const name = new cdktf.TerraformVariable(this, \"name\", {\n      type: \"string\",\n      default: this.metadata?.testName || \"test\",\n      description: \"System name used to randomize the resources\",\n    });\n\n    this.name = name.value;\n  }\n\n  /**\n   * Registers a resource for tracking and cleanup verification\n   *\n   * @param resourceId - Azure resource ID\n   * @param resourceType - Azure resource type\n   * @param name - Resource name\n   * @param location - Optional resource location\n   * @param tags - Optional resource tags\n   */\n  public registerResource(\n    resourceId: string,\n    resourceType: string,\n    name: string,\n    location?: string,\n    tags?: Record<string, string>,\n  ): void {\n    if (!this.metadata) {\n      console.warn(\n        \"[BaseTestStack] Resource registration requires metadata. \" +\n          \"Initialize with testRunOptions to enable resource tracking.\",\n      );\n      return;\n    }\n\n    const metadata: ResourceMetadata = {\n      resourceId,\n      resourceType,\n      name,\n      location,\n      tags: tags || {},\n      testRunId: this.metadata.runId,\n      createdAt: this.metadata.createdAt,\n    };\n\n    this.resourceRegistry.set(resourceId, metadata);\n    console.log(\n      `[BaseTestStack] Registered resource: ${name} (${resourceType})`,\n    );\n  }\n\n  /**\n   * Retrieves all registered resources\n   *\n   * @returns Array of registered resource metadata\n   */\n  public registeredResources(): ResourceMetadata[] {\n    return Array.from(this.resourceRegistry.values());\n  }\n\n  /**\n   * Generates system tags for resources (only available when metadata is present)\n   *\n   * @returns Integration test system tags\n   * @throws Error if metadata is not initialized\n   */\n  public systemTags(): Record<string, string> {\n    if (!this.metadata) {\n      throw new Error(\n        \"System tags are only available when BaseTestStack is initialized with testRunOptions. \" +\n          \"Pass { testRunOptions: {} } to the constructor to enable metadata.\",\n      );\n    }\n    return this.metadata.generateSystemTags();\n  }\n\n  /**\n   * Generates a unique resource name with proper Azure compliance\n   *\n   * @param resourceType - Azure resource type (e.g., 'Microsoft.Resources/resourceGroups')\n   * @param customIdentifier - Optional custom identifier (defaults to test name)\n   * @returns Unique, Azure-compliant resource name\n   * @throws Error if metadata is not initialized\n   *\n   * @example\n   * const stack = new BaseTestStack(app, 'test-storage', { testRunOptions: {} });\n   * const rgName = stack.generateResourceName('Microsoft.Resources/resourceGroups');\n   * // Returns: 'rg-test-storage-a1b2c3'\n   */\n  public generateResourceName(\n    resourceType: string,\n    customIdentifier?: string,\n  ): string {\n    if (!this.metadata) {\n      throw new Error(\n        \"Resource name generation is only available when BaseTestStack is initialized with testRunOptions. \" +\n          \"Pass { testRunOptions: {} } to the constructor to enable metadata.\",\n      );\n    }\n\n    return generateResourceName({\n      resourceType,\n      testName: this.metadata.testName,\n      runId: this.metadata.runId,\n      customIdentifier,\n    });\n  }\n}\n\nexport function execTerraformCommand(\n  command: string,\n  opts: ExecSyncOptionsWithStringEncoding,\n  streamOutput: boolean,\n): { stdout: string; stderr: string; exitCode: number } {\n  try {\n    if (streamOutput) {\n      execSync(command, { ...opts, stdio: \"inherit\" });\n      return { stdout: \"\", stderr: \"\", exitCode: 0 };\n    } else {\n      const stdout = execSync(command, { ...opts, stdio: \"pipe\" }).toString();\n      return { stdout, stderr: \"\", exitCode: 0 };\n    }\n  } catch (error: any) {\n    const stdout = error.stdout ? error.stdout.toString() : \"\";\n    const stderr = error.stderr ? error.stderr.toString() : \"\";\n    return { stdout, stderr, exitCode: error.status || 1 };\n  }\n}\n\nexport function TerraformApply(\n  stack: any,\n  streamOutput: boolean = false,\n): { stdout: string; stderr: string; error: any } {\n  try {\n    const manifestPath = path.resolve(stack, \"manifest.json\");\n\n    // Safety check: verify manifest exists before reading\n    if (!fs.existsSync(manifestPath)) {\n      throw new Error(\n        `Manifest file not found at ${manifestPath}. ` +\n          `Ensure Testing.fullSynth() completed successfully and the output directory still exists.`,\n      );\n    }\n\n    const manifest = JSON.parse(fs.readFileSync(manifestPath, \"utf8\"));\n    const stacks = Object.entries(manifest.stacks);\n\n    for (const [, stackDetails] of stacks) {\n      const opts: ExecSyncOptionsWithStringEncoding = {\n        cwd: path.resolve(stack, (stackDetails as any).workingDirectory),\n        env: process.env,\n        encoding: \"utf-8\",\n      };\n\n      const initResult = execTerraformCommand(\n        `terraform init`,\n        opts,\n        streamOutput,\n      );\n      if (initResult.exitCode !== 0)\n        throw new Error(\n          `Terraform init failed: ${initResult.stdout} ${initResult.stderr}`,\n        );\n\n      const applyResult = execTerraformCommand(\n        `terraform apply -auto-approve`,\n        opts,\n        streamOutput,\n      );\n      if (applyResult.exitCode !== 0) {\n        return {\n          stdout: applyResult.stdout,\n          stderr: applyResult.stderr,\n          error: new Error(\n            `Terraform apply failed: ${applyResult.stdout} ${applyResult.stderr}`,\n          ),\n        };\n      }\n    }\n\n    return { stdout: \"Terraform apply succeeded\", stderr: \"\", error: null };\n  } catch (error: any) {\n    console.error(\"Error during Terraform init or apply:\", error);\n    return { stdout: \"\", stderr: \"\", error };\n  }\n}\n\nexport function TerraformPlanExitCode(\n  stack: any,\n  streamOutput: boolean = false,\n): { stdout: string; stderr: string; exitCode: number; error: any } {\n  try {\n    const manifestPath = path.resolve(stack, \"manifest.json\");\n\n    // Safety check: verify manifest exists before reading\n    if (!fs.existsSync(manifestPath)) {\n      throw new Error(\n        `Manifest file not found at ${manifestPath}. ` +\n          `Ensure Testing.fullSynth() completed successfully and the output directory still exists.`,\n      );\n    }\n\n    const manifest = JSON.parse(fs.readFileSync(manifestPath, \"utf8\"));\n    const stacks = Object.entries(manifest.stacks);\n\n    for (const [, stackDetails] of stacks) {\n      const opts: ExecSyncOptionsWithStringEncoding = {\n        cwd: path.resolve(stack, (stackDetails as any).workingDirectory),\n        env: process.env,\n        encoding: \"utf-8\",\n      };\n\n      const initResult = execTerraformCommand(\n        `terraform init`,\n        opts,\n        streamOutput,\n      );\n      if (initResult.exitCode !== 0)\n        throw new Error(\n          `Terraform init failed: ${initResult.stdout} ${initResult.stderr}`,\n        );\n\n      const planResult = execTerraformCommand(\n        `terraform plan -input=false -lock=false -detailed-exitcode`,\n        opts,\n        streamOutput,\n      );\n      return {\n        stdout: planResult.stdout,\n        stderr: planResult.stderr,\n        exitCode: planResult.exitCode,\n        error: null,\n      };\n    }\n\n    return {\n      stdout: \"Terraform plan succeeded\",\n      stderr: \"\",\n      exitCode: 0,\n      error: null,\n    };\n  } catch (error: any) {\n    console.error(\"Error during Terraform init or plan:\", error);\n    return { stdout: \"\", stderr: \"\", exitCode: 1, error };\n  }\n}\nexport function TerraformIdempotentCheck(stack: any): AssertionReturn {\n  try {\n    const manifestPath = path.resolve(stack, \"manifest.json\");\n\n    // Safety check: verify manifest exists before reading\n    if (!fs.existsSync(manifestPath)) {\n      throw new Error(\n        `Manifest file not found at ${manifestPath}. ` +\n          `Ensure Testing.fullSynth() completed successfully and the output directory still exists.`,\n      );\n    }\n\n    const manifest = JSON.parse(fs.readFileSync(manifestPath, \"utf8\"));\n    const stacks = Object.entries(manifest.stacks);\n\n    for (const [, stackDetails] of stacks) {\n      const opts = {\n        cwd: path.resolve(stack, (stackDetails as any).workingDirectory),\n        env: process.env,\n        stdio: \"pipe\",\n      } as any;\n\n      execSync(`terraform init`, opts);\n\n      let planOutput: string;\n      try {\n        planOutput = execSync(\n          `terraform plan -input=false -detailed-exitcode`,\n          opts,\n        ).toString();\n      } catch (error: any) {\n        planOutput = error.stdout ? error.stdout.toString() : \"\";\n      }\n\n      if (\n        planOutput.includes(\n          \"No changes. Your infrastructure matches the configuration.\",\n        )\n      ) {\n        return new AssertionReturn(\n          `Expected subject to be idempotent with no changes`,\n          true,\n        );\n      } else {\n        throw new Error(`Plan resulted in changes:\\n${planOutput}`);\n      }\n    }\n\n    return new AssertionReturn(\n      `Expected subject to be idempotent with no changes`,\n      true,\n    );\n  } catch (error) {\n    console.error(\"Error during Terraform init or plan:\", error);\n    throw error;\n  }\n}\n\nexport function TerraformDestroy(\n  stack: any,\n  streamOutput: boolean = false,\n): AssertionReturn {\n  try {\n    const manifestPath = path.resolve(stack, \"manifest.json\");\n\n    // Safety check: verify manifest exists before reading\n    if (!fs.existsSync(manifestPath)) {\n      throw new Error(\n        `Manifest file not found at ${manifestPath}. ` +\n          `Ensure Testing.fullSynth() completed successfully and the output directory still exists.`,\n      );\n    }\n\n    const manifest = JSON.parse(fs.readFileSync(manifestPath, \"utf8\"));\n    const stacks = Object.entries(manifest.stacks);\n\n    for (const [, stackDetails] of stacks) {\n      const opts: ExecSyncOptionsWithStringEncoding = {\n        cwd: path.resolve(stack, (stackDetails as any).workingDirectory),\n        env: process.env,\n        encoding: \"utf-8\",\n      };\n\n      const initResult = execTerraformCommand(\n        `terraform init`,\n        opts,\n        streamOutput,\n      );\n      if (initResult.exitCode !== 0)\n        throw new Error(\n          `Terraform init failed: ${initResult.stdout} ${initResult.stderr}`,\n        );\n\n      const destroyResult = execTerraformCommand(\n        `terraform destroy -auto-approve`,\n        opts,\n        streamOutput,\n      );\n      if (destroyResult.exitCode !== 0)\n        throw new Error(\n          `Terraform destroy failed: ${destroyResult.stdout} ${destroyResult.stderr}`,\n        );\n    }\n\n    return new AssertionReturn(\n      `Expected subject to destroy successfully`,\n      true,\n    );\n  } catch (error: any) {\n    console.error(\"Error during Terraform init or destroy:\", error);\n    return new AssertionReturn(\n      `Expected subject to destroy successfully`,\n      false,\n    );\n  }\n}\n\nexport function TerraformApplyAndCheckIdempotency(\n  stack: any,\n  streamOutput: boolean = false,\n): AssertionReturn {\n  const applyResult = TerraformApply(stack, streamOutput);\n  if (applyResult.error) {\n    return new AssertionReturn(applyResult.error.message, false);\n  }\n\n  const planResult = TerraformPlanExitCode(stack, streamOutput);\n  if (planResult.error) {\n    return new AssertionReturn(planResult.error.message, false);\n  }\n\n  if (planResult.exitCode !== 0) {\n    return new AssertionReturn(\n      `Terraform configuration not idempotent:\\n${planResult.stdout}`,\n      false,\n    );\n  }\n\n  return new AssertionReturn(\n    `Terraform apply and idempotency check completed successfully`,\n    true,\n  );\n}\n\nexport function TerraformApplyCheckAndDestroy(\n  stack: any,\n  options?: { verifyCleanup?: boolean },\n): void {\n  const streamOutput = process.env.STREAM_OUTPUT === \"true\";\n  const verifyCleanup = options?.verifyCleanup ?? false;\n\n  // Extract metadata and resources if available\n  const metadata: TestRunMetadata | undefined = (stack as any).metadata;\n  const hasVerification = verifyCleanup && metadata;\n\n  try {\n    const applyAndCheckResult = TerraformApplyAndCheckIdempotency(\n      stack,\n      streamOutput,\n    );\n    if (!applyAndCheckResult.success) {\n      throw new Error(applyAndCheckResult.message);\n    }\n  } catch (error) {\n    console.error(\"Error during Terraform apply and idempotency check:\", error);\n    throw error; // Re-throw the error to ensure the test fails\n  } finally {\n    try {\n      if (hasVerification) {\n        // Use enhanced destroy with verification\n        const resources: ResourceMetadata[] =\n          typeof (stack as any).registeredResources === \"function\"\n            ? (stack as any).registeredResources()\n            : [];\n\n        const destroyResult = TerraformDestroyWithVerification(\n          stack,\n          metadata!,\n          resources,\n          streamOutput,\n        );\n\n        if (!destroyResult.success) {\n          throw new Error(\n            `Destroy verification failed: ${destroyResult.message}`,\n          );\n        }\n      } else {\n        // Use standard destroy (backward compatible)\n        const destroyResult = TerraformDestroy(stack, streamOutput);\n        if (!destroyResult.success) {\n          console.error(\n            \"Error during Terraform destroy:\",\n            destroyResult.message,\n          );\n        }\n      }\n    } catch (destroyError) {\n      console.error(\"Error during Terraform destroy:\", destroyError);\n      throw destroyError; // Re-throw to fail the test\n    } finally {\n      // Clean up this specific test's output directory\n      try {\n        if (fs.existsSync(stack)) {\n          execSync(`rm -rf \"${stack}\"`);\n        }\n      } catch (cleanupError) {\n        // Ignore cleanup errors - directory may already be gone\n      }\n    }\n  }\n}\n\n/**\n * Enhanced terraform destroy with cleanup verification\n *\n * Performs terraform destroy and verifies resource cleanup via\n * Azure Resource Graph queries. Implements retry logic for\n * eventual consistency.\n *\n * @param stack - Terraform stack directory path\n * @param metadata - Test run metadata\n * @param resources - List of resources to verify deletion\n * @param streamOutput - Whether to stream command output\n * @returns Assertion result\n */\nexport function TerraformDestroyWithVerification(\n  stack: any,\n  metadata: TestRunMetadata,\n  resources: ResourceMetadata[],\n  streamOutput: boolean = false,\n): AssertionReturn {\n  try {\n    console.log(\"[Destroy] Starting terraform destroy...\");\n\n    // Step 1: Run terraform destroy\n    const destroyResult = TerraformDestroy(stack, streamOutput);\n\n    if (!destroyResult.success) {\n      throw new Error(`Terraform destroy failed: ${destroyResult.message}`);\n    }\n\n    console.log(\"[Destroy] Terraform destroy completed successfully\");\n\n    // Step 2: If no resources to verify, skip verification\n    if (resources.length === 0) {\n      console.log(\"[Destroy] No resources to verify (none registered)\");\n      return new AssertionReturn(\n        \"Terraform destroy completed (no verification needed)\",\n        true,\n      );\n    }\n\n    console.log(\n      `[Destroy] Verifying cleanup of ${resources.length} resources...`,\n    );\n    console.log(\"[Destroy] Waiting 30s for Azure eventual consistency...\");\n\n    // Step 3: Wait for eventual consistency\n    const sleep = (ms: number) => {\n      execSync(`sleep ${ms / 1000}`, { stdio: \"ignore\" });\n    };\n    sleep(30000);\n\n    // Step 4: Verify resources are deleted with retry logic\n    console.log(\"[Destroy] Starting verification...\");\n    const verificationResult = verifyResourcesDeleted(\n      metadata.runId,\n      resources,\n    );\n\n    if (!verificationResult.success) {\n      // Step 5: Retry verification after additional wait\n      console.warn(\"[Destroy] Initial verification failed, retrying...\");\n      sleep(30000);\n\n      const retryResult = verifyResourcesDeleted(metadata.runId, resources);\n\n      if (!retryResult.success) {\n        const errorMessage =\n          `Resource cleanup verification failed:\\n` +\n          `  Expected: ${retryResult.expectedCount} resources\\n` +\n          `  Found: ${retryResult.foundCount} orphaned resources\\n` +\n          `  Orphaned IDs:\\n` +\n          retryResult.orphanedResources.map((id) => `    - ${id}`).join(\"\\n\");\n\n        console.error(\"[Destroy] ✗ Verification failed:\", errorMessage);\n        throw new Error(errorMessage);\n      }\n\n      console.log(\"[Destroy] ✓ Verification succeeded on retry\");\n    } else {\n      console.log(\"[Destroy] ✓ All resources verified deleted\");\n    }\n\n    return new AssertionReturn(\n      \"Terraform destroy and verification completed successfully\",\n      true,\n    );\n  } catch (error: any) {\n    console.error(\n      \"[Destroy] Error during Terraform destroy and verification:\",\n      error,\n    );\n    return new AssertionReturn(\n      `Terraform destroy and verification failed: ${error.message}`,\n      false,\n    );\n  }\n}\n\nexport function TerraformPlan(stack: any): AssertionReturn {\n  try {\n    const manifestPath = path.resolve(stack, \"manifest.json\");\n\n    // Safety check: verify manifest exists before reading\n    if (!fs.existsSync(manifestPath)) {\n      throw new Error(\n        `Manifest file not found at ${manifestPath}. ` +\n          `Ensure Testing.fullSynth() completed successfully and the output directory still exists.`,\n      );\n    }\n\n    const manifest = JSON.parse(fs.readFileSync(manifestPath, \"utf8\"));\n    const stacks = Object.entries(manifest.stacks);\n    stacks.forEach(([, stackDetails]) => {\n      const opts = {\n        cwd: path.resolve(stack, (stackDetails as any).workingDirectory),\n        env: process.env,\n        stdio: \"pipe\",\n      } as any;\n      execSync(`terraform init`, opts);\n      execSync(`terraform plan -input=false -lock=false`, opts);\n    });\n\n    return new AssertionReturn(\n      `Expected subject not to plan successfully`,\n      true,\n    );\n  } catch (error) {\n    console.error(\"Error during Terraform init or plan:\", error);\n    throw error;\n    return new AssertionReturn(\n      \"Expected subject to plan successfully, false\",\n      false,\n    );\n  }\n}\n\nexport class AssertionReturn {\n  /**\n   * Create an AssertionReturn\n   * @param message - String message containing information about the result of the assertion\n   * @param success - Boolean success denoting the success of the assertion\n   */\n  constructor(\n    public readonly message: string,\n    public readonly success: boolean,\n  ) {\n    if (!success) {\n      throw new Error(message);\n    }\n  }\n}\n\n/**\n * Cleanup function for removing all CDKTF output directories in /tmp.\n *\n * WARNING: This function should NOT be used in afterAll() hooks when running\n * tests in parallel, as it will delete directories that other running tests\n * may still be using. Instead, TerraformApplyCheckAndDestroy now cleans up\n * its own directory automatically.\n *\n * This function is kept for manual cleanup or single-threaded test scenarios.\n */\nexport function cleanupCdkTfOutDirs() {\n  try {\n    execSync('find /tmp -name \"cdktf.outdir.*\" -type d -exec rm -rf {} +');\n  } catch (error) {\n    console.error(\"Error during cleanup:\", error);\n  }\n}\n\n// Export cleanup utilities\nexport {\n  ResourceMetadata,\n  VerificationResult,\n  CleanupOptions,\n  OrphanedResource,\n  CleanupResult,\n  ResourceCleanupService,\n  verifyResourcesDeleted,\n  verifyResourcesDeletedWithRetry,\n  findOrphanedResources,\n  cleanupOrphanedResources,\n} from \"./lib/cleanup\";\n"]}