@microsoft/terraform-cdk-constructs 1.8.0 → 2.2.0

package/lib/azure-containerapps/test/container-app.spec.js

@@ -0,0 +1,839 @@
+"use strict";
+/**
+ * Comprehensive tests for the unified ContainerApp implementation
+ *
+ * This test suite validates the unified ContainerApp class using the
+ * AzapiResource framework. Tests cover automatic version resolution,
+ * explicit version pinning, schema validation, property transformation, and
+ * full backward compatibility.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const cdktn_1 = require("cdktn");
+const cdktn = require("cdktn");
+const api_version_manager_1 = require("../../core-azure/lib/version-manager/api-version-manager");
+const version_interfaces_1 = require("../../core-azure/lib/version-manager/interfaces/version-interfaces");
+const container_app_1 = require("../lib/container-app");
+const container_app_schemas_1 = require("../lib/container-app-schemas");
+describe("ContainerApp - Unified Implementation", () => {
+    let app;
+    let stack;
+    let manager;
+    const defaultEnvironmentId = "/subscriptions/sub-id/resourceGroups/rg/providers/Microsoft.App/managedEnvironments/env";
+    const minimalTemplate = {
+        containers: [
+            {
+                name: "my-app",
+                image: "mcr.microsoft.com/azuredocs/containerapps-helloworld:latest",
+            },
+        ],
+    };
+    beforeEach(() => {
+        app = cdktn_1.Testing.app();
+        stack = new cdktn.TerraformStack(app, "TestStack");
+        manager = api_version_manager_1.ApiVersionManager.instance();
+        // Ensure schemas are registered
+        try {
+            manager.registerResourceType(container_app_schemas_1.CONTAINER_APP_TYPE, container_app_schemas_1.ALL_CONTAINER_APP_VERSIONS);
+        }
+        catch (error) {
+            // Ignore if already registered
+        }
+    });
+    describe("Constructor and Basic Properties", () => {
+        it("should create Container App with automatic latest version resolution", () => {
+            const props = {
+                name: "my-container-app",
+                location: "eastus",
+                environmentId: defaultEnvironmentId,
+                template: minimalTemplate,
+            };
+            const containerApp = new container_app_1.ContainerApp(stack, "TestApp", props);
+            expect(containerApp).toBeInstanceOf(container_app_1.ContainerApp);
+            expect(containerApp.resolvedApiVersion).toBe("2025-07-01");
+            expect(containerApp.props).toBe(props);
+        });
+        it("should create Container App with explicit version pinning", () => {
+            const props = {
+                name: "my-container-app",
+                location: "eastus",
+                environmentId: defaultEnvironmentId,
+                template: minimalTemplate,
+                apiVersion: "2024-03-01",
+                tags: { environment: "test" },
+            };
+            const containerApp = new container_app_1.ContainerApp(stack, "TestApp", props);
+            expect(containerApp.resolvedApiVersion).toBe("2024-03-01");
+            expect(containerApp.tags).toEqual({ environment: "test" });
+        });
+        it("should require location property", () => {
+            const props = {
+                name: "my-container-app",
+                location: "eastus",
+                environmentId: defaultEnvironmentId,
+                template: minimalTemplate,
+            };
+            const containerApp = new container_app_1.ContainerApp(stack, "TestApp", props);
+            expect(containerApp.location).toBe("eastus");
+            expect(containerApp.props.location).toBe("eastus");
+        });
+        it("should store environmentId property", () => {
+            const props = {
+                name: "my-container-app",
+                location: "eastus",
+                environmentId: defaultEnvironmentId,
+                template: minimalTemplate,
+            };
+            const containerApp = new container_app_1.ContainerApp(stack, "TestApp", props);
+            expect(containerApp.props.environmentId).toBe(defaultEnvironmentId);
+        });
+    });
+    describe("Framework Integration", () => {
+        it("should resolve latest API version automatically", () => {
+            const containerApp = new container_app_1.ContainerApp(stack, "TestApp", {
+                name: "my-container-app",
+                location: "eastus",
+                environmentId: defaultEnvironmentId,
+                template: minimalTemplate,
+            });
+            expect(containerApp.resolvedApiVersion).toBe("2025-07-01");
+            expect(containerApp.latestVersion()).toBe("2025-07-01");
+        });
+        it("should provide version configuration", () => {
+            const containerApp = new container_app_1.ContainerApp(stack, "TestApp", {
+                name: "my-container-app",
+                location: "eastus",
+                environmentId: defaultEnvironmentId,
+                template: minimalTemplate,
+            });
+            expect(containerApp.versionConfig).toBeDefined();
+            expect(containerApp.versionConfig.version).toBe("2025-07-01");
+            expect(containerApp.versionConfig.supportLevel).toBe(version_interfaces_1.VersionSupportLevel.ACTIVE);
+        });
+        it("should provide supported versions", () => {
+            const containerApp = new container_app_1.ContainerApp(stack, "TestApp", {
+                name: "my-container-app",
+                location: "eastus",
+                environmentId: defaultEnvironmentId,
+                template: minimalTemplate,
+            });
+            const versions = containerApp.supportedVersions();
+            expect(versions).toContain("2024-03-01");
+            expect(versions).toContain("2025-07-01");
+            expect(versions.length).toBeGreaterThanOrEqual(2);
+        });
+    });
+    describe("Public Methods - Read-only Properties", () => {
+        it("should provide FQDN", () => {
+            const containerApp = new container_app_1.ContainerApp(stack, "TestApp", {
+                name: "my-container-app",
+                location: "eastus",
+                environmentId: defaultEnvironmentId,
+                template: minimalTemplate,
+            });
+            expect(containerApp.fqdn).toBeDefined();
+            expect(typeof containerApp.fqdn).toBe("string");
+        });
+        it("should provide latest revision FQDN", () => {
+            const containerApp = new container_app_1.ContainerApp(stack, "TestApp", {
+                name: "my-container-app",
+                location: "eastus",
+                environmentId: defaultEnvironmentId,
+                template: minimalTemplate,
+            });
+            expect(containerApp.latestRevisionFqdn).toBeDefined();
+            expect(typeof containerApp.latestRevisionFqdn).toBe("string");
+        });
+        it("should provide latest ready revision name", () => {
+            const containerApp = new container_app_1.ContainerApp(stack, "TestApp", {
+                name: "my-container-app",
+                location: "eastus",
+                environmentId: defaultEnvironmentId,
+                template: minimalTemplate,
+            });
+            expect(containerApp.latestReadyRevisionName).toBeDefined();
+            expect(typeof containerApp.latestReadyRevisionName).toBe("string");
+        });
+        it("should provide provisioning state", () => {
+            const containerApp = new container_app_1.ContainerApp(stack, "TestApp", {
+                name: "my-container-app",
+                location: "eastus",
+                environmentId: defaultEnvironmentId,
+                template: minimalTemplate,
+            });
+            expect(containerApp.provisioningState).toBeDefined();
+            expect(typeof containerApp.provisioningState).toBe("string");
+        });
+        it("should provide running status", () => {
+            const containerApp = new container_app_1.ContainerApp(stack, "TestApp", {
+                name: "my-container-app",
+                location: "eastus",
+                environmentId: defaultEnvironmentId,
+                template: minimalTemplate,
+            });
+            expect(containerApp.runningStatus).toBeDefined();
+            expect(typeof containerApp.runningStatus).toBe("string");
+        });
+    });
+    describe("Tag Management", () => {
+        it("should allow adding tags", () => {
+            const containerApp = new container_app_1.ContainerApp(stack, "TestApp", {
+                name: "my-container-app",
+                location: "eastus",
+                environmentId: defaultEnvironmentId,
+                template: minimalTemplate,
+                tags: { initial: "tag" },
+            });
+            containerApp.addTag("newKey", "newValue");
+            expect(containerApp.props.tags).toHaveProperty("newKey", "newValue");
+            expect(containerApp.props.tags).toHaveProperty("initial", "tag");
+        });
+        it("should allow removing tags", () => {
+            const containerApp = new container_app_1.ContainerApp(stack, "TestApp", {
+                name: "my-container-app",
+                location: "eastus",
+                environmentId: defaultEnvironmentId,
+                template: minimalTemplate,
+                tags: { key1: "value1", key2: "value2" },
+            });
+            containerApp.removeTag("key1");
+            expect(containerApp.props.tags).not.toHaveProperty("key1");
+            expect(containerApp.props.tags).toHaveProperty("key2", "value2");
+        });
+        it("should handle adding tags when no initial tags exist", () => {
+            const containerApp = new container_app_1.ContainerApp(stack, "TestApp", {
+                name: "my-container-app",
+                location: "eastus",
+                environmentId: defaultEnvironmentId,
+                template: minimalTemplate,
+            });
+            containerApp.addTag("newKey", "newValue");
+            expect(containerApp.props.tags).toHaveProperty("newKey", "newValue");
+        });
+    });
+    describe("Outputs", () => {
+        it("should create all required outputs", () => {
+            const containerApp = new container_app_1.ContainerApp(stack, "TestApp", {
+                name: "my-container-app",
+                location: "eastus",
+                environmentId: defaultEnvironmentId,
+                template: minimalTemplate,
+            });
+            expect(containerApp.idOutput).toBeDefined();
+            expect(containerApp.locationOutput).toBeDefined();
+            expect(containerApp.nameOutput).toBeDefined();
+            expect(containerApp.tagsOutput).toBeDefined();
+            expect(containerApp.fqdnOutput).toBeDefined();
+            expect(containerApp.latestRevisionFqdnOutput).toBeDefined();
+            expect(containerApp.latestReadyRevisionNameOutput).toBeDefined();
+            expect(containerApp.provisioningStateOutput).toBeDefined();
+        });
+        it("should have correct logical IDs for outputs", () => {
+            new container_app_1.ContainerApp(stack, "TestApp", {
+                name: "my-container-app",
+                location: "eastus",
+                environmentId: defaultEnvironmentId,
+                template: minimalTemplate,
+            });
+            const synthesized = cdktn_1.Testing.synth(stack);
+            expect(synthesized).toContain('"id"');
+            expect(synthesized).toContain('"location"');
+            expect(synthesized).toContain('"name"');
+            expect(synthesized).toContain('"tags"');
+            expect(synthesized).toContain('"fqdn"');
+            expect(synthesized).toContain('"latest_revision_fqdn"');
+            expect(synthesized).toContain('"latest_ready_revision_name"');
+            expect(synthesized).toContain('"provisioning_state"');
+        });
+    });
+    describe("Ingress Configuration", () => {
+        it("should include external ingress in resource body", () => {
+            new container_app_1.ContainerApp(stack, "TestApp", {
+                name: "my-container-app",
+                location: "eastus",
+                environmentId: defaultEnvironmentId,
+                template: minimalTemplate,
+                configuration: {
+                    ingress: {
+                        external: true,
+                        targetPort: 3000,
+                        transport: "http",
+                    },
+                },
+            });
+            const synthesized = cdktn_1.Testing.synth(stack);
+            expect(synthesized).toContain("ingress");
+            expect(synthesized).toContain("3000");
+        });
+        it("should include CORS policy in ingress", () => {
+            new container_app_1.ContainerApp(stack, "TestApp", {
+                name: "my-container-app",
+                location: "eastus",
+                environmentId: defaultEnvironmentId,
+                template: minimalTemplate,
+                configuration: {
+                    ingress: {
+                        external: true,
+                        targetPort: 3000,
+                        corsPolicy: {
+                            allowedOrigins: ["https://example.com"],
+                            allowedMethods: ["GET", "POST"],
+                            allowCredentials: true,
+                        },
+                    },
+                },
+            });
+            const synthesized = cdktn_1.Testing.synth(stack);
+            expect(synthesized).toContain("corsPolicy");
+            expect(synthesized).toContain("https://example.com");
+        });
+        it("should include IP security restrictions", () => {
+            new container_app_1.ContainerApp(stack, "TestApp", {
+                name: "my-container-app",
+                location: "eastus",
+                environmentId: defaultEnvironmentId,
+                template: minimalTemplate,
+                configuration: {
+                    ingress: {
+                        external: true,
+                        targetPort: 3000,
+                        ipSecurityRestrictions: [
+                            {
+                                name: "AllowOffice",
+                                ipAddressRange: "192.168.1.0/24",
+                                action: "Allow",
+                            },
+                        ],
+                    },
+                },
+            });
+            const synthesized = cdktn_1.Testing.synth(stack);
+            expect(synthesized).toContain("ipSecurityRestrictions");
+            expect(synthesized).toContain("AllowOffice");
+        });
+        it("should include sticky sessions configuration", () => {
+            new container_app_1.ContainerApp(stack, "TestApp", {
+                name: "my-container-app",
+                location: "eastus",
+                environmentId: defaultEnvironmentId,
+                template: minimalTemplate,
+                configuration: {
+                    ingress: {
+                        external: true,
+                        targetPort: 3000,
+                        stickySessions: { affinity: "sticky" },
+                    },
+                },
+            });
+            const synthesized = cdktn_1.Testing.synth(stack);
+            expect(synthesized).toContain("stickySessions");
+            expect(synthesized).toContain("sticky");
+        });
+    });
+    describe("Dapr Configuration", () => {
+        it("should include Dapr sidecar configuration", () => {
+            new container_app_1.ContainerApp(stack, "TestApp", {
+                name: "my-container-app",
+                location: "eastus",
+                environmentId: defaultEnvironmentId,
+                template: minimalTemplate,
+                configuration: {
+                    dapr: {
+                        enabled: true,
+                        appId: "my-app",
+                        appPort: 3000,
+                        appProtocol: "http",
+                    },
+                },
+            });
+            const synthesized = cdktn_1.Testing.synth(stack);
+            expect(synthesized).toContain("dapr");
+            expect(synthesized).toContain("my-app");
+        });
+        it("should support Dapr health checks", () => {
+            new container_app_1.ContainerApp(stack, "TestApp", {
+                name: "my-container-app",
+                location: "eastus",
+                environmentId: defaultEnvironmentId,
+                template: minimalTemplate,
+                configuration: {
+                    dapr: {
+                        enabled: true,
+                        appId: "my-app",
+                        appPort: 3000,
+                        appHealth: {
+                            enabled: true,
+                            path: "/health",
+                            probeIntervalSeconds: 3,
+                            probeTimeoutMilliseconds: 1000,
+                            threshold: 3,
+                        },
+                    },
+                },
+            });
+            const synthesized = cdktn_1.Testing.synth(stack);
+            expect(synthesized).toContain("appHealth");
+            expect(synthesized).toContain("/health");
+        });
+    });
+    describe("Scale Configuration", () => {
+        it("should include HTTP scaling rules", () => {
+            new container_app_1.ContainerApp(stack, "TestApp", {
+                name: "my-container-app",
+                location: "eastus",
+                environmentId: defaultEnvironmentId,
+                template: {
+                    containers: minimalTemplate.containers,
+                    scale: {
+                        minReplicas: 1,
+                        maxReplicas: 10,
+                        rules: [
+                            {
+                                name: "http-rule",
+                                http: {
+                                    metadata: { concurrentRequests: "50" },
+                                },
+                            },
+                        ],
+                    },
+                },
+            });
+            const synthesized = cdktn_1.Testing.synth(stack);
+            expect(synthesized).toContain("scale");
+            expect(synthesized).toContain("http-rule");
+            expect(synthesized).toContain("concurrentRequests");
+        });
+        it("should include custom KEDA scaling rules", () => {
+            new container_app_1.ContainerApp(stack, "TestApp", {
+                name: "my-container-app",
+                location: "eastus",
+                environmentId: defaultEnvironmentId,
+                template: {
+                    containers: minimalTemplate.containers,
+                    scale: {
+                        minReplicas: 0,
+                        maxReplicas: 5,
+                        rules: [
+                            {
+                                name: "servicebus-rule",
+                                custom: {
+                                    type: "azure-servicebus",
+                                    metadata: {
+                                        queueName: "myqueue",
+                                        namespace: "mynamespace",
+                                        messageCount: "5",
+                                    },
+                                },
+                            },
+                        ],
+                    },
+                },
+            });
+            const synthesized = cdktn_1.Testing.synth(stack);
+            expect(synthesized).toContain("azure-servicebus");
+            expect(synthesized).toContain("myqueue");
+        });
+        it("should include Azure Queue scaling rules", () => {
+            new container_app_1.ContainerApp(stack, "TestApp", {
+                name: "my-container-app",
+                location: "eastus",
+                environmentId: defaultEnvironmentId,
+                template: {
+                    containers: minimalTemplate.containers,
+                    scale: {
+                        minReplicas: 0,
+                        maxReplicas: 5,
+                        rules: [
+                            {
+                                name: "azure-queue-rule",
+                                azureQueue: {
+                                    accountName: "account1",
+                                    queueName: "queue1",
+                                    queueLength: 1,
+                                    identity: "system",
+                                },
+                            },
+                        ],
+                    },
+                },
+            });
+            const synthesized = cdktn_1.Testing.synth(stack);
+            expect(synthesized).toContain("azureQueue");
+            expect(synthesized).toContain("account1");
+        });
+    });
+    describe("Container Configuration", () => {
+        it("should include container resources", () => {
+            new container_app_1.ContainerApp(stack, "TestApp", {
+                name: "my-container-app",
+                location: "eastus",
+                environmentId: defaultEnvironmentId,
+                template: {
+                    containers: [
+                        {
+                            name: "my-app",
+                            image: "myregistry.azurecr.io/myapp:latest",
+                            resources: { cpu: 0.5, memory: "1Gi" },
+                        },
+                    ],
+                },
+            });
+            const synthesized = cdktn_1.Testing.synth(stack);
+            expect(synthesized).toContain("0.5");
+            expect(synthesized).toContain("1Gi");
+        });
+        it("should include environment variables", () => {
+            new container_app_1.ContainerApp(stack, "TestApp", {
+                name: "my-container-app",
+                location: "eastus",
+                environmentId: defaultEnvironmentId,
+                template: {
+                    containers: [
+                        {
+                            name: "my-app",
+                            image: "myapp:latest",
+                            env: [
+                                { name: "PORT", value: "3000" },
+                                { name: "DB_PASSWORD", secretRef: "db-password" },
+                            ],
+                        },
+                    ],
+                },
+            });
+            const synthesized = cdktn_1.Testing.synth(stack);
+            expect(synthesized).toContain("PORT");
+            expect(synthesized).toContain("3000");
+            expect(synthesized).toContain("db-password");
+        });
+        it("should include health probes", () => {
+            new container_app_1.ContainerApp(stack, "TestApp", {
+                name: "my-container-app",
+                location: "eastus",
+                environmentId: defaultEnvironmentId,
+                template: {
+                    containers: [
+                        {
+                            name: "my-app",
+                            image: "myapp:latest",
+                            probes: [
+                                {
+                                    type: "Liveness",
+                                    httpGet: {
+                                        path: "/health",
+                                        port: 8080,
+                                    },
+                                    initialDelaySeconds: 3,
+                                    periodSeconds: 3,
+                                },
+                            ],
+                        },
+                    ],
+                },
+            });
+            const synthesized = cdktn_1.Testing.synth(stack);
+            expect(synthesized).toContain("Liveness");
+            expect(synthesized).toContain("/health");
+        });
+        it("should include init containers", () => {
+            new container_app_1.ContainerApp(stack, "TestApp", {
+                name: "my-container-app",
+                location: "eastus",
+                environmentId: defaultEnvironmentId,
+                template: {
+                    containers: minimalTemplate.containers,
+                    initContainers: [
+                        {
+                            name: "init",
+                            image: "busybox:latest",
+                            command: ["/bin/sh"],
+                            args: ["-c", "echo hello"],
+                            resources: { cpu: 0.25, memory: "0.5Gi" },
+                        },
+                    ],
+                },
+            });
+            const synthesized = cdktn_1.Testing.synth(stack);
+            expect(synthesized).toContain("initContainers");
+            expect(synthesized).toContain("busybox:latest");
+        });
+        it("should include volume mounts", () => {
+            new container_app_1.ContainerApp(stack, "TestApp", {
+                name: "my-container-app",
+                location: "eastus",
+                environmentId: defaultEnvironmentId,
+                template: {
+                    containers: [
+                        {
+                            name: "my-app",
+                            image: "myapp:latest",
+                            volumeMounts: [
+                                {
+                                    volumeName: "azurefile",
+                                    mountPath: "/mnt/data",
+                                },
+                            ],
+                        },
+                    ],
+                    volumes: [
+                        {
+                            name: "azurefile",
+                            storageType: "AzureFile",
+                            storageName: "mystorage",
+                        },
+                    ],
+                },
+            });
+            const synthesized = cdktn_1.Testing.synth(stack);
+            expect(synthesized).toContain("volumeMounts");
+            expect(synthesized).toContain("azurefile");
+            expect(synthesized).toContain("AzureFile");
+        });
+    });
+    describe("Secrets and Registries", () => {
+        it("should include secrets in configuration", () => {
+            new container_app_1.ContainerApp(stack, "TestApp", {
+                name: "my-container-app",
+                location: "eastus",
+                environmentId: defaultEnvironmentId,
+                template: minimalTemplate,
+                configuration: {
+                    secrets: [
+                        { name: "db-password", value: "supersecret" },
+                        {
+                            name: "kv-secret",
+                            keyVaultUrl: "https://myvault.vault.azure.net/secrets/mysecret",
+                            identity: "system",
+                        },
+                    ],
+                },
+            });
+            const synthesized = cdktn_1.Testing.synth(stack);
+            expect(synthesized).toContain("secrets");
+            expect(synthesized).toContain("db-password");
+            expect(synthesized).toContain("kv-secret");
+        });
+        it("should include container registries", () => {
+            new container_app_1.ContainerApp(stack, "TestApp", {
+                name: "my-container-app",
+                location: "eastus",
+                environmentId: defaultEnvironmentId,
+                template: minimalTemplate,
+                configuration: {
+                    registries: [
+                        {
+                            server: "myregistry.azurecr.io",
+                            identity: "/subscriptions/sub-id/resourceGroups/rg/providers/Microsoft.ManagedIdentity/userAssignedIdentities/myid",
+                        },
+                    ],
+                },
+            });
+            const synthesized = cdktn_1.Testing.synth(stack);
+            expect(synthesized).toContain("registries");
+            expect(synthesized).toContain("myregistry.azurecr.io");
+        });
+    });
+    describe("Identity Configuration", () => {
+        it("should include SystemAssigned identity", () => {
+            new container_app_1.ContainerApp(stack, "TestApp", {
+                name: "my-container-app",
+                location: "eastus",
+                environmentId: defaultEnvironmentId,
+                template: minimalTemplate,
+                identity: {
+                    type: "SystemAssigned",
+                },
+            });
+            const synthesized = cdktn_1.Testing.synth(stack);
+            expect(synthesized).toContain("identity");
+            expect(synthesized).toContain("SystemAssigned");
+        });
+        it("should include UserAssigned identity", () => {
+            const identityId = "/subscriptions/sub-id/resourceGroups/rg/providers/Microsoft.ManagedIdentity/userAssignedIdentities/myidentity";
+            new container_app_1.ContainerApp(stack, "TestApp", {
+                name: "my-container-app",
+                location: "eastus",
+                environmentId: defaultEnvironmentId,
+                template: minimalTemplate,
+                identity: {
+                    type: "SystemAssigned,UserAssigned",
+                    userAssignedIdentities: {
+                        [identityId]: {},
+                    },
+                },
+            });
+            const synthesized = cdktn_1.Testing.synth(stack);
+            expect(synthesized).toContain("SystemAssigned,UserAssigned");
+            expect(synthesized).toContain("userAssignedIdentities");
+        });
+    });
+    describe("Revision Mode", () => {
+        it("should support multiple revision mode", () => {
+            new container_app_1.ContainerApp(stack, "TestApp", {
+                name: "my-container-app",
+                location: "eastus",
+                environmentId: defaultEnvironmentId,
+                template: minimalTemplate,
+                configuration: {
+                    activeRevisionsMode: "Multiple",
+                    ingress: {
+                        external: true,
+                        targetPort: 3000,
+                        traffic: [
+                            { revisionName: "my-container-app-v1", weight: 80 },
+                            {
+                                revisionName: "my-container-app-v2",
+                                weight: 20,
+                                label: "staging",
+                            },
+                        ],
+                    },
+                },
+            });
+            const synthesized = cdktn_1.Testing.synth(stack);
+            expect(synthesized).toContain("Multiple");
+            expect(synthesized).toContain("traffic");
+        });
+    });
+    describe("Workload Profile", () => {
+        it("should include workload profile name", () => {
+            new container_app_1.ContainerApp(stack, "TestApp", {
+                name: "my-container-app",
+                location: "eastus",
+                environmentId: defaultEnvironmentId,
+                template: minimalTemplate,
+                workloadProfileName: "My-GP-01",
+            });
+            const synthesized = cdktn_1.Testing.synth(stack);
+            expect(synthesized).toContain("workloadProfileName");
+            expect(synthesized).toContain("My-GP-01");
+        });
+    });
+    describe("Ignore Changes Configuration", () => {
+        it("should apply ignore changes lifecycle rules", () => {
+            new container_app_1.ContainerApp(stack, "TestApp", {
+                name: "my-container-app",
+                location: "eastus",
+                environmentId: defaultEnvironmentId,
+                template: minimalTemplate,
+                ignoreChanges: ["tags"],
+            });
+            const synthesized = cdktn_1.Testing.synth(stack);
+            expect(synthesized).toContain("ignore_changes");
+        });
+    });
+    describe("CDK Terraform Integration", () => {
+        it("should synthesize to valid Terraform configuration", () => {
+            new container_app_1.ContainerApp(stack, "SynthTest", {
+                name: "my-container-app",
+                location: "eastus",
+                environmentId: defaultEnvironmentId,
+                template: minimalTemplate,
+                tags: { test: "synthesis" },
+            });
+            const synthesized = cdktn_1.Testing.synth(stack);
+            expect(synthesized).toBeDefined();
+            const stackConfig = JSON.parse(synthesized);
+            expect(stackConfig.resource).toBeDefined();
+        });
+        it("should generate correct resource type in Terraform", () => {
+            new container_app_1.ContainerApp(stack, "SynthTest", {
+                name: "my-container-app",
+                location: "eastus",
+                environmentId: defaultEnvironmentId,
+                template: minimalTemplate,
+            });
+            const synthesized = cdktn_1.Testing.synth(stack);
+            expect(synthesized).toContain("Microsoft.App/containerApps");
+            expect(synthesized).toContain("2025-07-01");
+        });
+        it("should include all properties in Terraform body", () => {
+            new container_app_1.ContainerApp(stack, "SynthTest", {
+                name: "my-container-app",
+                location: "eastus",
+                environmentId: defaultEnvironmentId,
+                template: minimalTemplate,
+                tags: { env: "test" },
+            });
+            const synthesized = cdktn_1.Testing.synth(stack);
+            expect(synthesized).toContain("eastus");
+            expect(synthesized).toContain("env");
+            expect(synthesized).toContain("environmentId");
+            expect(synthesized).toContain("template");
+        });
+    });
+    describe("Resource Identification", () => {
+        it("should provide resource ID", () => {
+            const containerApp = new container_app_1.ContainerApp(stack, "TestApp", {
+                name: "my-container-app",
+                location: "eastus",
+                environmentId: defaultEnvironmentId,
+                template: minimalTemplate,
+            });
+            expect(containerApp.id).toBeDefined();
+            expect(typeof containerApp.id).toBe("string");
+        });
+        it("should provide resource name from props", () => {
+            const containerApp = new container_app_1.ContainerApp(stack, "TestApp", {
+                name: "my-container-app",
+                location: "eastus",
+                environmentId: defaultEnvironmentId,
+                template: minimalTemplate,
+            });
+            expect(containerApp.props.name).toBe("my-container-app");
+        });
+    });
+    describe("JSII Compliance", () => {
+        it("should have proper return types for all public methods", () => {
+            const containerApp = new container_app_1.ContainerApp(stack, "TestApp", {
+                name: "my-container-app",
+                location: "eastus",
+                environmentId: defaultEnvironmentId,
+                template: minimalTemplate,
+            });
+            expect(typeof containerApp.fqdn).toBe("string");
+            expect(typeof containerApp.latestRevisionFqdn).toBe("string");
+            expect(typeof containerApp.latestReadyRevisionName).toBe("string");
+            expect(typeof containerApp.provisioningState).toBe("string");
+            expect(typeof containerApp.runningStatus).toBe("string");
+        });
+        it("should not use function types in public interface", () => {
+            const containerApp = new container_app_1.ContainerApp(stack, "TestApp", {
+                name: "my-container-app",
+                location: "eastus",
+                environmentId: defaultEnvironmentId,
+                template: minimalTemplate,
+            });
+            expect(typeof containerApp.addTag).toBe("function");
+            expect(typeof containerApp.removeTag).toBe("function");
+            containerApp.addTag("test", "value");
+            expect(containerApp.props.tags).toHaveProperty("test", "value");
+        });
+    });
+    describe("Schema Registration", () => {
+        it("should register schemas successfully", () => {
+            const containerApp = new container_app_1.ContainerApp(stack, "TestApp", {
+                name: "my-container-app",
+                location: "eastus",
+                environmentId: defaultEnvironmentId,
+                template: minimalTemplate,
+            });
+            expect(containerApp).toBeDefined();
+            expect(containerApp.resolvedApiVersion).toBe("2025-07-01");
+        });
+        it("should handle multiple instantiations without errors", () => {
+            new container_app_1.ContainerApp(stack, "TestApp1", {
+                name: "my-container-app-1",
+                location: "eastus",
+                environmentId: defaultEnvironmentId,
+                template: minimalTemplate,
+            });
+            const app2 = new container_app_1.ContainerApp(stack, "TestApp2", {
+                name: "my-container-app-2",
+                location: "westus",
+                environmentId: defaultEnvironmentId,
+                template: minimalTemplate,
+            });
+            expect(app2).toBeDefined();
+        });
+    });
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"container-app.spec.js","sourceRoot":"","sources":["../../../src/azure-containerapps/test/container-app.spec.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Comprehensive tests for the unified ContainerApp implementation\n *\n * This test suite validates the unified ContainerApp class using the\n * AzapiResource framework. Tests cover automatic version resolution,\n * explicit version pinning, schema validation, property transformation, and\n * full backward compatibility.\n */\n\nimport { Testing } from \"cdktn\";\nimport * as cdktn from \"cdktn\";\nimport { ApiVersionManager } from \"../../core-azure/lib/version-manager/api-version-manager\";\nimport { VersionSupportLevel } from \"../../core-azure/lib/version-manager/interfaces/version-interfaces\";\nimport { ContainerApp, ContainerAppProps } from \"../lib/container-app\";\nimport {\n  ALL_CONTAINER_APP_VERSIONS,\n  CONTAINER_APP_TYPE,\n} from \"../lib/container-app-schemas\";\n\ndescribe(\"ContainerApp - Unified Implementation\", () => {\n  let app: cdktn.App;\n  let stack: cdktn.TerraformStack;\n  let manager: ApiVersionManager;\n\n  const defaultEnvironmentId =\n    \"/subscriptions/sub-id/resourceGroups/rg/providers/Microsoft.App/managedEnvironments/env\";\n\n  const minimalTemplate = {\n    containers: [\n      {\n        name: \"my-app\",\n        image: \"mcr.microsoft.com/azuredocs/containerapps-helloworld:latest\",\n      },\n    ],\n  };\n\n  beforeEach(() => {\n    app = Testing.app();\n    stack = new cdktn.TerraformStack(app, \"TestStack\");\n    manager = ApiVersionManager.instance();\n\n    // Ensure schemas are registered\n    try {\n      manager.registerResourceType(\n        CONTAINER_APP_TYPE,\n        ALL_CONTAINER_APP_VERSIONS,\n      );\n    } catch (error) {\n      // Ignore if already registered\n    }\n  });\n\n  describe(\"Constructor and Basic Properties\", () => {\n    it(\"should create Container App with automatic latest version resolution\", () => {\n      const props: ContainerAppProps = {\n        name: \"my-container-app\",\n        location: \"eastus\",\n        environmentId: defaultEnvironmentId,\n        template: minimalTemplate,\n      };\n\n      const containerApp = new ContainerApp(stack, \"TestApp\", props);\n\n      expect(containerApp).toBeInstanceOf(ContainerApp);\n      expect(containerApp.resolvedApiVersion).toBe(\"2025-07-01\");\n      expect(containerApp.props).toBe(props);\n    });\n\n    it(\"should create Container App with explicit version pinning\", () => {\n      const props: ContainerAppProps = {\n        name: \"my-container-app\",\n        location: \"eastus\",\n        environmentId: defaultEnvironmentId,\n        template: minimalTemplate,\n        apiVersion: \"2024-03-01\",\n        tags: { environment: \"test\" },\n      };\n\n      const containerApp = new ContainerApp(stack, \"TestApp\", props);\n\n      expect(containerApp.resolvedApiVersion).toBe(\"2024-03-01\");\n      expect(containerApp.tags).toEqual({ environment: \"test\" });\n    });\n\n    it(\"should require location property\", () => {\n      const props: ContainerAppProps = {\n        name: \"my-container-app\",\n        location: \"eastus\",\n        environmentId: defaultEnvironmentId,\n        template: minimalTemplate,\n      };\n\n      const containerApp = new ContainerApp(stack, \"TestApp\", props);\n\n      expect(containerApp.location).toBe(\"eastus\");\n      expect(containerApp.props.location).toBe(\"eastus\");\n    });\n\n    it(\"should store environmentId property\", () => {\n      const props: ContainerAppProps = {\n        name: \"my-container-app\",\n        location: \"eastus\",\n        environmentId: defaultEnvironmentId,\n        template: minimalTemplate,\n      };\n\n      const containerApp = new ContainerApp(stack, \"TestApp\", props);\n\n      expect(containerApp.props.environmentId).toBe(defaultEnvironmentId);\n    });\n  });\n\n  describe(\"Framework Integration\", () => {\n    it(\"should resolve latest API version automatically\", () => {\n      const containerApp = new ContainerApp(stack, \"TestApp\", {\n        name: \"my-container-app\",\n        location: \"eastus\",\n        environmentId: defaultEnvironmentId,\n        template: minimalTemplate,\n      });\n\n      expect(containerApp.resolvedApiVersion).toBe(\"2025-07-01\");\n      expect(containerApp.latestVersion()).toBe(\"2025-07-01\");\n    });\n\n    it(\"should provide version configuration\", () => {\n      const containerApp = new ContainerApp(stack, \"TestApp\", {\n        name: \"my-container-app\",\n        location: \"eastus\",\n        environmentId: defaultEnvironmentId,\n        template: minimalTemplate,\n      });\n\n      expect(containerApp.versionConfig).toBeDefined();\n      expect(containerApp.versionConfig.version).toBe(\"2025-07-01\");\n      expect(containerApp.versionConfig.supportLevel).toBe(\n        VersionSupportLevel.ACTIVE,\n      );\n    });\n\n    it(\"should provide supported versions\", () => {\n      const containerApp = new ContainerApp(stack, \"TestApp\", {\n        name: \"my-container-app\",\n        location: \"eastus\",\n        environmentId: defaultEnvironmentId,\n        template: minimalTemplate,\n      });\n\n      const versions = containerApp.supportedVersions();\n      expect(versions).toContain(\"2024-03-01\");\n      expect(versions).toContain(\"2025-07-01\");\n      expect(versions.length).toBeGreaterThanOrEqual(2);\n    });\n  });\n\n  describe(\"Public Methods - Read-only Properties\", () => {\n    it(\"should provide FQDN\", () => {\n      const containerApp = new ContainerApp(stack, \"TestApp\", {\n        name: \"my-container-app\",\n        location: \"eastus\",\n        environmentId: defaultEnvironmentId,\n        template: minimalTemplate,\n      });\n\n      expect(containerApp.fqdn).toBeDefined();\n      expect(typeof containerApp.fqdn).toBe(\"string\");\n    });\n\n    it(\"should provide latest revision FQDN\", () => {\n      const containerApp = new ContainerApp(stack, \"TestApp\", {\n        name: \"my-container-app\",\n        location: \"eastus\",\n        environmentId: defaultEnvironmentId,\n        template: minimalTemplate,\n      });\n\n      expect(containerApp.latestRevisionFqdn).toBeDefined();\n      expect(typeof containerApp.latestRevisionFqdn).toBe(\"string\");\n    });\n\n    it(\"should provide latest ready revision name\", () => {\n      const containerApp = new ContainerApp(stack, \"TestApp\", {\n        name: \"my-container-app\",\n        location: \"eastus\",\n        environmentId: defaultEnvironmentId,\n        template: minimalTemplate,\n      });\n\n      expect(containerApp.latestReadyRevisionName).toBeDefined();\n      expect(typeof containerApp.latestReadyRevisionName).toBe(\"string\");\n    });\n\n    it(\"should provide provisioning state\", () => {\n      const containerApp = new ContainerApp(stack, \"TestApp\", {\n        name: \"my-container-app\",\n        location: \"eastus\",\n        environmentId: defaultEnvironmentId,\n        template: minimalTemplate,\n      });\n\n      expect(containerApp.provisioningState).toBeDefined();\n      expect(typeof containerApp.provisioningState).toBe(\"string\");\n    });\n\n    it(\"should provide running status\", () => {\n      const containerApp = new ContainerApp(stack, \"TestApp\", {\n        name: \"my-container-app\",\n        location: \"eastus\",\n        environmentId: defaultEnvironmentId,\n        template: minimalTemplate,\n      });\n\n      expect(containerApp.runningStatus).toBeDefined();\n      expect(typeof containerApp.runningStatus).toBe(\"string\");\n    });\n  });\n\n  describe(\"Tag Management\", () => {\n    it(\"should allow adding tags\", () => {\n      const containerApp = new ContainerApp(stack, \"TestApp\", {\n        name: \"my-container-app\",\n        location: \"eastus\",\n        environmentId: defaultEnvironmentId,\n        template: minimalTemplate,\n        tags: { initial: \"tag\" },\n      });\n\n      containerApp.addTag(\"newKey\", \"newValue\");\n      expect(containerApp.props.tags).toHaveProperty(\"newKey\", \"newValue\");\n      expect(containerApp.props.tags).toHaveProperty(\"initial\", \"tag\");\n    });\n\n    it(\"should allow removing tags\", () => {\n      const containerApp = new ContainerApp(stack, \"TestApp\", {\n        name: \"my-container-app\",\n        location: \"eastus\",\n        environmentId: defaultEnvironmentId,\n        template: minimalTemplate,\n        tags: { key1: \"value1\", key2: \"value2\" },\n      });\n\n      containerApp.removeTag(\"key1\");\n      expect(containerApp.props.tags).not.toHaveProperty(\"key1\");\n      expect(containerApp.props.tags).toHaveProperty(\"key2\", \"value2\");\n    });\n\n    it(\"should handle adding tags when no initial tags exist\", () => {\n      const containerApp = new ContainerApp(stack, \"TestApp\", {\n        name: \"my-container-app\",\n        location: \"eastus\",\n        environmentId: defaultEnvironmentId,\n        template: minimalTemplate,\n      });\n\n      containerApp.addTag(\"newKey\", \"newValue\");\n      expect(containerApp.props.tags).toHaveProperty(\"newKey\", \"newValue\");\n    });\n  });\n\n  describe(\"Outputs\", () => {\n    it(\"should create all required outputs\", () => {\n      const containerApp = new ContainerApp(stack, \"TestApp\", {\n        name: \"my-container-app\",\n        location: \"eastus\",\n        environmentId: defaultEnvironmentId,\n        template: minimalTemplate,\n      });\n\n      expect(containerApp.idOutput).toBeDefined();\n      expect(containerApp.locationOutput).toBeDefined();\n      expect(containerApp.nameOutput).toBeDefined();\n      expect(containerApp.tagsOutput).toBeDefined();\n      expect(containerApp.fqdnOutput).toBeDefined();\n      expect(containerApp.latestRevisionFqdnOutput).toBeDefined();\n      expect(containerApp.latestReadyRevisionNameOutput).toBeDefined();\n      expect(containerApp.provisioningStateOutput).toBeDefined();\n    });\n\n    it(\"should have correct logical IDs for outputs\", () => {\n      new ContainerApp(stack, \"TestApp\", {\n        name: \"my-container-app\",\n        location: \"eastus\",\n        environmentId: defaultEnvironmentId,\n        template: minimalTemplate,\n      });\n\n      const synthesized = Testing.synth(stack);\n      expect(synthesized).toContain('\"id\"');\n      expect(synthesized).toContain('\"location\"');\n      expect(synthesized).toContain('\"name\"');\n      expect(synthesized).toContain('\"tags\"');\n      expect(synthesized).toContain('\"fqdn\"');\n      expect(synthesized).toContain('\"latest_revision_fqdn\"');\n      expect(synthesized).toContain('\"latest_ready_revision_name\"');\n      expect(synthesized).toContain('\"provisioning_state\"');\n    });\n  });\n\n  describe(\"Ingress Configuration\", () => {\n    it(\"should include external ingress in resource body\", () => {\n      new ContainerApp(stack, \"TestApp\", {\n        name: \"my-container-app\",\n        location: \"eastus\",\n        environmentId: defaultEnvironmentId,\n        template: minimalTemplate,\n        configuration: {\n          ingress: {\n            external: true,\n            targetPort: 3000,\n            transport: \"http\",\n          },\n        },\n      });\n\n      const synthesized = Testing.synth(stack);\n      expect(synthesized).toContain(\"ingress\");\n      expect(synthesized).toContain(\"3000\");\n    });\n\n    it(\"should include CORS policy in ingress\", () => {\n      new ContainerApp(stack, \"TestApp\", {\n        name: \"my-container-app\",\n        location: \"eastus\",\n        environmentId: defaultEnvironmentId,\n        template: minimalTemplate,\n        configuration: {\n          ingress: {\n            external: true,\n            targetPort: 3000,\n            corsPolicy: {\n              allowedOrigins: [\"https://example.com\"],\n              allowedMethods: [\"GET\", \"POST\"],\n              allowCredentials: true,\n            },\n          },\n        },\n      });\n\n      const synthesized = Testing.synth(stack);\n      expect(synthesized).toContain(\"corsPolicy\");\n      expect(synthesized).toContain(\"https://example.com\");\n    });\n\n    it(\"should include IP security restrictions\", () => {\n      new ContainerApp(stack, \"TestApp\", {\n        name: \"my-container-app\",\n        location: \"eastus\",\n        environmentId: defaultEnvironmentId,\n        template: minimalTemplate,\n        configuration: {\n          ingress: {\n            external: true,\n            targetPort: 3000,\n            ipSecurityRestrictions: [\n              {\n                name: \"AllowOffice\",\n                ipAddressRange: \"192.168.1.0/24\",\n                action: \"Allow\",\n              },\n            ],\n          },\n        },\n      });\n\n      const synthesized = Testing.synth(stack);\n      expect(synthesized).toContain(\"ipSecurityRestrictions\");\n      expect(synthesized).toContain(\"AllowOffice\");\n    });\n\n    it(\"should include sticky sessions configuration\", () => {\n      new ContainerApp(stack, \"TestApp\", {\n        name: \"my-container-app\",\n        location: \"eastus\",\n        environmentId: defaultEnvironmentId,\n        template: minimalTemplate,\n        configuration: {\n          ingress: {\n            external: true,\n            targetPort: 3000,\n            stickySessions: { affinity: \"sticky\" },\n          },\n        },\n      });\n\n      const synthesized = Testing.synth(stack);\n      expect(synthesized).toContain(\"stickySessions\");\n      expect(synthesized).toContain(\"sticky\");\n    });\n  });\n\n  describe(\"Dapr Configuration\", () => {\n    it(\"should include Dapr sidecar configuration\", () => {\n      new ContainerApp(stack, \"TestApp\", {\n        name: \"my-container-app\",\n        location: \"eastus\",\n        environmentId: defaultEnvironmentId,\n        template: minimalTemplate,\n        configuration: {\n          dapr: {\n            enabled: true,\n            appId: \"my-app\",\n            appPort: 3000,\n            appProtocol: \"http\",\n          },\n        },\n      });\n\n      const synthesized = Testing.synth(stack);\n      expect(synthesized).toContain(\"dapr\");\n      expect(synthesized).toContain(\"my-app\");\n    });\n\n    it(\"should support Dapr health checks\", () => {\n      new ContainerApp(stack, \"TestApp\", {\n        name: \"my-container-app\",\n        location: \"eastus\",\n        environmentId: defaultEnvironmentId,\n        template: minimalTemplate,\n        configuration: {\n          dapr: {\n            enabled: true,\n            appId: \"my-app\",\n            appPort: 3000,\n            appHealth: {\n              enabled: true,\n              path: \"/health\",\n              probeIntervalSeconds: 3,\n              probeTimeoutMilliseconds: 1000,\n              threshold: 3,\n            },\n          },\n        },\n      });\n\n      const synthesized = Testing.synth(stack);\n      expect(synthesized).toContain(\"appHealth\");\n      expect(synthesized).toContain(\"/health\");\n    });\n  });\n\n  describe(\"Scale Configuration\", () => {\n    it(\"should include HTTP scaling rules\", () => {\n      new ContainerApp(stack, \"TestApp\", {\n        name: \"my-container-app\",\n        location: \"eastus\",\n        environmentId: defaultEnvironmentId,\n        template: {\n          containers: minimalTemplate.containers,\n          scale: {\n            minReplicas: 1,\n            maxReplicas: 10,\n            rules: [\n              {\n                name: \"http-rule\",\n                http: {\n                  metadata: { concurrentRequests: \"50\" },\n                },\n              },\n            ],\n          },\n        },\n      });\n\n      const synthesized = Testing.synth(stack);\n      expect(synthesized).toContain(\"scale\");\n      expect(synthesized).toContain(\"http-rule\");\n      expect(synthesized).toContain(\"concurrentRequests\");\n    });\n\n    it(\"should include custom KEDA scaling rules\", () => {\n      new ContainerApp(stack, \"TestApp\", {\n        name: \"my-container-app\",\n        location: \"eastus\",\n        environmentId: defaultEnvironmentId,\n        template: {\n          containers: minimalTemplate.containers,\n          scale: {\n            minReplicas: 0,\n            maxReplicas: 5,\n            rules: [\n              {\n                name: \"servicebus-rule\",\n                custom: {\n                  type: \"azure-servicebus\",\n                  metadata: {\n                    queueName: \"myqueue\",\n                    namespace: \"mynamespace\",\n                    messageCount: \"5\",\n                  },\n                },\n              },\n            ],\n          },\n        },\n      });\n\n      const synthesized = Testing.synth(stack);\n      expect(synthesized).toContain(\"azure-servicebus\");\n      expect(synthesized).toContain(\"myqueue\");\n    });\n\n    it(\"should include Azure Queue scaling rules\", () => {\n      new ContainerApp(stack, \"TestApp\", {\n        name: \"my-container-app\",\n        location: \"eastus\",\n        environmentId: defaultEnvironmentId,\n        template: {\n          containers: minimalTemplate.containers,\n          scale: {\n            minReplicas: 0,\n            maxReplicas: 5,\n            rules: [\n              {\n                name: \"azure-queue-rule\",\n                azureQueue: {\n                  accountName: \"account1\",\n                  queueName: \"queue1\",\n                  queueLength: 1,\n                  identity: \"system\",\n                },\n              },\n            ],\n          },\n        },\n      });\n\n      const synthesized = Testing.synth(stack);\n      expect(synthesized).toContain(\"azureQueue\");\n      expect(synthesized).toContain(\"account1\");\n    });\n  });\n\n  describe(\"Container Configuration\", () => {\n    it(\"should include container resources\", () => {\n      new ContainerApp(stack, \"TestApp\", {\n        name: \"my-container-app\",\n        location: \"eastus\",\n        environmentId: defaultEnvironmentId,\n        template: {\n          containers: [\n            {\n              name: \"my-app\",\n              image: \"myregistry.azurecr.io/myapp:latest\",\n              resources: { cpu: 0.5, memory: \"1Gi\" },\n            },\n          ],\n        },\n      });\n\n      const synthesized = Testing.synth(stack);\n      expect(synthesized).toContain(\"0.5\");\n      expect(synthesized).toContain(\"1Gi\");\n    });\n\n    it(\"should include environment variables\", () => {\n      new ContainerApp(stack, \"TestApp\", {\n        name: \"my-container-app\",\n        location: \"eastus\",\n        environmentId: defaultEnvironmentId,\n        template: {\n          containers: [\n            {\n              name: \"my-app\",\n              image: \"myapp:latest\",\n              env: [\n                { name: \"PORT\", value: \"3000\" },\n                { name: \"DB_PASSWORD\", secretRef: \"db-password\" },\n              ],\n            },\n          ],\n        },\n      });\n\n      const synthesized = Testing.synth(stack);\n      expect(synthesized).toContain(\"PORT\");\n      expect(synthesized).toContain(\"3000\");\n      expect(synthesized).toContain(\"db-password\");\n    });\n\n    it(\"should include health probes\", () => {\n      new ContainerApp(stack, \"TestApp\", {\n        name: \"my-container-app\",\n        location: \"eastus\",\n        environmentId: defaultEnvironmentId,\n        template: {\n          containers: [\n            {\n              name: \"my-app\",\n              image: \"myapp:latest\",\n              probes: [\n                {\n                  type: \"Liveness\",\n                  httpGet: {\n                    path: \"/health\",\n                    port: 8080,\n                  },\n                  initialDelaySeconds: 3,\n                  periodSeconds: 3,\n                },\n              ],\n            },\n          ],\n        },\n      });\n\n      const synthesized = Testing.synth(stack);\n      expect(synthesized).toContain(\"Liveness\");\n      expect(synthesized).toContain(\"/health\");\n    });\n\n    it(\"should include init containers\", () => {\n      new ContainerApp(stack, \"TestApp\", {\n        name: \"my-container-app\",\n        location: \"eastus\",\n        environmentId: defaultEnvironmentId,\n        template: {\n          containers: minimalTemplate.containers,\n          initContainers: [\n            {\n              name: \"init\",\n              image: \"busybox:latest\",\n              command: [\"/bin/sh\"],\n              args: [\"-c\", \"echo hello\"],\n              resources: { cpu: 0.25, memory: \"0.5Gi\" },\n            },\n          ],\n        },\n      });\n\n      const synthesized = Testing.synth(stack);\n      expect(synthesized).toContain(\"initContainers\");\n      expect(synthesized).toContain(\"busybox:latest\");\n    });\n\n    it(\"should include volume mounts\", () => {\n      new ContainerApp(stack, \"TestApp\", {\n        name: \"my-container-app\",\n        location: \"eastus\",\n        environmentId: defaultEnvironmentId,\n        template: {\n          containers: [\n            {\n              name: \"my-app\",\n              image: \"myapp:latest\",\n              volumeMounts: [\n                {\n                  volumeName: \"azurefile\",\n                  mountPath: \"/mnt/data\",\n                },\n              ],\n            },\n          ],\n          volumes: [\n            {\n              name: \"azurefile\",\n              storageType: \"AzureFile\",\n              storageName: \"mystorage\",\n            },\n          ],\n        },\n      });\n\n      const synthesized = Testing.synth(stack);\n      expect(synthesized).toContain(\"volumeMounts\");\n      expect(synthesized).toContain(\"azurefile\");\n      expect(synthesized).toContain(\"AzureFile\");\n    });\n  });\n\n  describe(\"Secrets and Registries\", () => {\n    it(\"should include secrets in configuration\", () => {\n      new ContainerApp(stack, \"TestApp\", {\n        name: \"my-container-app\",\n        location: \"eastus\",\n        environmentId: defaultEnvironmentId,\n        template: minimalTemplate,\n        configuration: {\n          secrets: [\n            { name: \"db-password\", value: \"supersecret\" },\n            {\n              name: \"kv-secret\",\n              keyVaultUrl: \"https://myvault.vault.azure.net/secrets/mysecret\",\n              identity: \"system\",\n            },\n          ],\n        },\n      });\n\n      const synthesized = Testing.synth(stack);\n      expect(synthesized).toContain(\"secrets\");\n      expect(synthesized).toContain(\"db-password\");\n      expect(synthesized).toContain(\"kv-secret\");\n    });\n\n    it(\"should include container registries\", () => {\n      new ContainerApp(stack, \"TestApp\", {\n        name: \"my-container-app\",\n        location: \"eastus\",\n        environmentId: defaultEnvironmentId,\n        template: minimalTemplate,\n        configuration: {\n          registries: [\n            {\n              server: \"myregistry.azurecr.io\",\n              identity:\n                \"/subscriptions/sub-id/resourceGroups/rg/providers/Microsoft.ManagedIdentity/userAssignedIdentities/myid\",\n            },\n          ],\n        },\n      });\n\n      const synthesized = Testing.synth(stack);\n      expect(synthesized).toContain(\"registries\");\n      expect(synthesized).toContain(\"myregistry.azurecr.io\");\n    });\n  });\n\n  describe(\"Identity Configuration\", () => {\n    it(\"should include SystemAssigned identity\", () => {\n      new ContainerApp(stack, \"TestApp\", {\n        name: \"my-container-app\",\n        location: \"eastus\",\n        environmentId: defaultEnvironmentId,\n        template: minimalTemplate,\n        identity: {\n          type: \"SystemAssigned\",\n        },\n      });\n\n      const synthesized = Testing.synth(stack);\n      expect(synthesized).toContain(\"identity\");\n      expect(synthesized).toContain(\"SystemAssigned\");\n    });\n\n    it(\"should include UserAssigned identity\", () => {\n      const identityId =\n        \"/subscriptions/sub-id/resourceGroups/rg/providers/Microsoft.ManagedIdentity/userAssignedIdentities/myidentity\";\n\n      new ContainerApp(stack, \"TestApp\", {\n        name: \"my-container-app\",\n        location: \"eastus\",\n        environmentId: defaultEnvironmentId,\n        template: minimalTemplate,\n        identity: {\n          type: \"SystemAssigned,UserAssigned\",\n          userAssignedIdentities: {\n            [identityId]: {},\n          },\n        },\n      });\n\n      const synthesized = Testing.synth(stack);\n      expect(synthesized).toContain(\"SystemAssigned,UserAssigned\");\n      expect(synthesized).toContain(\"userAssignedIdentities\");\n    });\n  });\n\n  describe(\"Revision Mode\", () => {\n    it(\"should support multiple revision mode\", () => {\n      new ContainerApp(stack, \"TestApp\", {\n        name: \"my-container-app\",\n        location: \"eastus\",\n        environmentId: defaultEnvironmentId,\n        template: minimalTemplate,\n        configuration: {\n          activeRevisionsMode: \"Multiple\",\n          ingress: {\n            external: true,\n            targetPort: 3000,\n            traffic: [\n              { revisionName: \"my-container-app-v1\", weight: 80 },\n              {\n                revisionName: \"my-container-app-v2\",\n                weight: 20,\n                label: \"staging\",\n              },\n            ],\n          },\n        },\n      });\n\n      const synthesized = Testing.synth(stack);\n      expect(synthesized).toContain(\"Multiple\");\n      expect(synthesized).toContain(\"traffic\");\n    });\n  });\n\n  describe(\"Workload Profile\", () => {\n    it(\"should include workload profile name\", () => {\n      new ContainerApp(stack, \"TestApp\", {\n        name: \"my-container-app\",\n        location: \"eastus\",\n        environmentId: defaultEnvironmentId,\n        template: minimalTemplate,\n        workloadProfileName: \"My-GP-01\",\n      });\n\n      const synthesized = Testing.synth(stack);\n      expect(synthesized).toContain(\"workloadProfileName\");\n      expect(synthesized).toContain(\"My-GP-01\");\n    });\n  });\n\n  describe(\"Ignore Changes Configuration\", () => {\n    it(\"should apply ignore changes lifecycle rules\", () => {\n      new ContainerApp(stack, \"TestApp\", {\n        name: \"my-container-app\",\n        location: \"eastus\",\n        environmentId: defaultEnvironmentId,\n        template: minimalTemplate,\n        ignoreChanges: [\"tags\"],\n      });\n\n      const synthesized = Testing.synth(stack);\n      expect(synthesized).toContain(\"ignore_changes\");\n    });\n  });\n\n  describe(\"CDK Terraform Integration\", () => {\n    it(\"should synthesize to valid Terraform configuration\", () => {\n      new ContainerApp(stack, \"SynthTest\", {\n        name: \"my-container-app\",\n        location: \"eastus\",\n        environmentId: defaultEnvironmentId,\n        template: minimalTemplate,\n        tags: { test: \"synthesis\" },\n      });\n\n      const synthesized = Testing.synth(stack);\n      expect(synthesized).toBeDefined();\n\n      const stackConfig = JSON.parse(synthesized);\n      expect(stackConfig.resource).toBeDefined();\n    });\n\n    it(\"should generate correct resource type in Terraform\", () => {\n      new ContainerApp(stack, \"SynthTest\", {\n        name: \"my-container-app\",\n        location: \"eastus\",\n        environmentId: defaultEnvironmentId,\n        template: minimalTemplate,\n      });\n\n      const synthesized = Testing.synth(stack);\n      expect(synthesized).toContain(\"Microsoft.App/containerApps\");\n      expect(synthesized).toContain(\"2025-07-01\");\n    });\n\n    it(\"should include all properties in Terraform body\", () => {\n      new ContainerApp(stack, \"SynthTest\", {\n        name: \"my-container-app\",\n        location: \"eastus\",\n        environmentId: defaultEnvironmentId,\n        template: minimalTemplate,\n        tags: { env: \"test\" },\n      });\n\n      const synthesized = Testing.synth(stack);\n      expect(synthesized).toContain(\"eastus\");\n      expect(synthesized).toContain(\"env\");\n      expect(synthesized).toContain(\"environmentId\");\n      expect(synthesized).toContain(\"template\");\n    });\n  });\n\n  describe(\"Resource Identification\", () => {\n    it(\"should provide resource ID\", () => {\n      const containerApp = new ContainerApp(stack, \"TestApp\", {\n        name: \"my-container-app\",\n        location: \"eastus\",\n        environmentId: defaultEnvironmentId,\n        template: minimalTemplate,\n      });\n\n      expect(containerApp.id).toBeDefined();\n      expect(typeof containerApp.id).toBe(\"string\");\n    });\n\n    it(\"should provide resource name from props\", () => {\n      const containerApp = new ContainerApp(stack, \"TestApp\", {\n        name: \"my-container-app\",\n        location: \"eastus\",\n        environmentId: defaultEnvironmentId,\n        template: minimalTemplate,\n      });\n\n      expect(containerApp.props.name).toBe(\"my-container-app\");\n    });\n  });\n\n  describe(\"JSII Compliance\", () => {\n    it(\"should have proper return types for all public methods\", () => {\n      const containerApp = new ContainerApp(stack, \"TestApp\", {\n        name: \"my-container-app\",\n        location: \"eastus\",\n        environmentId: defaultEnvironmentId,\n        template: minimalTemplate,\n      });\n\n      expect(typeof containerApp.fqdn).toBe(\"string\");\n      expect(typeof containerApp.latestRevisionFqdn).toBe(\"string\");\n      expect(typeof containerApp.latestReadyRevisionName).toBe(\"string\");\n      expect(typeof containerApp.provisioningState).toBe(\"string\");\n      expect(typeof containerApp.runningStatus).toBe(\"string\");\n    });\n\n    it(\"should not use function types in public interface\", () => {\n      const containerApp = new ContainerApp(stack, \"TestApp\", {\n        name: \"my-container-app\",\n        location: \"eastus\",\n        environmentId: defaultEnvironmentId,\n        template: minimalTemplate,\n      });\n\n      expect(typeof containerApp.addTag).toBe(\"function\");\n      expect(typeof containerApp.removeTag).toBe(\"function\");\n\n      containerApp.addTag(\"test\", \"value\");\n      expect(containerApp.props.tags).toHaveProperty(\"test\", \"value\");\n    });\n  });\n\n  describe(\"Schema Registration\", () => {\n    it(\"should register schemas successfully\", () => {\n      const containerApp = new ContainerApp(stack, \"TestApp\", {\n        name: \"my-container-app\",\n        location: \"eastus\",\n        environmentId: defaultEnvironmentId,\n        template: minimalTemplate,\n      });\n\n      expect(containerApp).toBeDefined();\n      expect(containerApp.resolvedApiVersion).toBe(\"2025-07-01\");\n    });\n\n    it(\"should handle multiple instantiations without errors\", () => {\n      new ContainerApp(stack, \"TestApp1\", {\n        name: \"my-container-app-1\",\n        location: \"eastus\",\n        environmentId: defaultEnvironmentId,\n        template: minimalTemplate,\n      });\n\n      const app2 = new ContainerApp(stack, \"TestApp2\", {\n        name: \"my-container-app-2\",\n        location: \"westus\",\n        environmentId: defaultEnvironmentId,\n        template: minimalTemplate,\n      });\n\n      expect(app2).toBeDefined();\n    });\n  });\n});\n"]}