@microsoft/terraform-cdk-constructs 1.8.0 → 2.2.0

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

@@ -0,0 +1,412 @@
+"use strict";
+/**
+ * Comprehensive tests for the unified ContainerAppEnvironment implementation
+ *
+ * This test suite validates the unified ContainerAppEnvironment 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_environment_1 = require("../lib/container-app-environment");
+const container_app_environment_schemas_1 = require("../lib/container-app-environment-schemas");
+describe("ContainerAppEnvironment - Unified Implementation", () => {
+    let app;
+    let stack;
+    let manager;
+    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_environment_schemas_1.CONTAINER_APP_ENVIRONMENT_TYPE, container_app_environment_schemas_1.ALL_CONTAINER_APP_ENVIRONMENT_VERSIONS);
+        }
+        catch (error) {
+            // Ignore if already registered
+        }
+    });
+    describe("Constructor and Basic Properties", () => {
+        it("should create Container App Environment with automatic latest version resolution", () => {
+            const props = {
+                name: "my-container-env",
+                location: "eastus",
+            };
+            const env = new container_app_environment_1.ContainerAppEnvironment(stack, "TestEnv", props);
+            expect(env).toBeInstanceOf(container_app_environment_1.ContainerAppEnvironment);
+            expect(env.resolvedApiVersion).toBe("2025-07-01");
+            expect(env.props).toBe(props);
+        });
+        it("should create Container App Environment with explicit version pinning", () => {
+            const props = {
+                name: "my-container-env",
+                location: "eastus",
+                apiVersion: "2024-03-01",
+                tags: { environment: "test" },
+            };
+            const env = new container_app_environment_1.ContainerAppEnvironment(stack, "TestEnv", props);
+            expect(env.resolvedApiVersion).toBe("2024-03-01");
+            expect(env.tags).toEqual({ environment: "test" });
+        });
+        it("should require location property", () => {
+            const props = {
+                name: "my-container-env",
+                location: "eastus",
+            };
+            const env = new container_app_environment_1.ContainerAppEnvironment(stack, "TestEnv", props);
+            expect(env.location).toBe("eastus");
+            expect(env.props.location).toBe("eastus");
+        });
+    });
+    describe("Framework Integration", () => {
+        it("should resolve latest API version automatically", () => {
+            const env = new container_app_environment_1.ContainerAppEnvironment(stack, "TestEnv", {
+                name: "my-container-env",
+                location: "eastus",
+            });
+            expect(env.resolvedApiVersion).toBe("2025-07-01");
+            expect(env.latestVersion()).toBe("2025-07-01");
+        });
+        it("should provide version configuration", () => {
+            const env = new container_app_environment_1.ContainerAppEnvironment(stack, "TestEnv", {
+                name: "my-container-env",
+                location: "eastus",
+            });
+            expect(env.versionConfig).toBeDefined();
+            expect(env.versionConfig.version).toBe("2025-07-01");
+            expect(env.versionConfig.supportLevel).toBe(version_interfaces_1.VersionSupportLevel.ACTIVE);
+        });
+        it("should provide supported versions", () => {
+            const env = new container_app_environment_1.ContainerAppEnvironment(stack, "TestEnv", {
+                name: "my-container-env",
+                location: "eastus",
+            });
+            const versions = env.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 default domain", () => {
+            const env = new container_app_environment_1.ContainerAppEnvironment(stack, "TestEnv", {
+                name: "my-container-env",
+                location: "eastus",
+            });
+            expect(env.defaultDomain).toBeDefined();
+            expect(typeof env.defaultDomain).toBe("string");
+        });
+        it("should provide static IP", () => {
+            const env = new container_app_environment_1.ContainerAppEnvironment(stack, "TestEnv", {
+                name: "my-container-env",
+                location: "eastus",
+            });
+            expect(env.staticIp).toBeDefined();
+            expect(typeof env.staticIp).toBe("string");
+        });
+        it("should provide provisioning state", () => {
+            const env = new container_app_environment_1.ContainerAppEnvironment(stack, "TestEnv", {
+                name: "my-container-env",
+                location: "eastus",
+            });
+            expect(env.provisioningState).toBeDefined();
+            expect(typeof env.provisioningState).toBe("string");
+        });
+    });
+    describe("Tag Management", () => {
+        it("should allow adding tags", () => {
+            const env = new container_app_environment_1.ContainerAppEnvironment(stack, "TestEnv", {
+                name: "my-container-env",
+                location: "eastus",
+                tags: { initial: "tag" },
+            });
+            env.addTag("newKey", "newValue");
+            expect(env.props.tags).toHaveProperty("newKey", "newValue");
+            expect(env.props.tags).toHaveProperty("initial", "tag");
+        });
+        it("should allow removing tags", () => {
+            const env = new container_app_environment_1.ContainerAppEnvironment(stack, "TestEnv", {
+                name: "my-container-env",
+                location: "eastus",
+                tags: { key1: "value1", key2: "value2" },
+            });
+            env.removeTag("key1");
+            expect(env.props.tags).not.toHaveProperty("key1");
+            expect(env.props.tags).toHaveProperty("key2", "value2");
+        });
+        it("should handle adding tags when no initial tags exist", () => {
+            const env = new container_app_environment_1.ContainerAppEnvironment(stack, "TestEnv", {
+                name: "my-container-env",
+                location: "eastus",
+            });
+            env.addTag("newKey", "newValue");
+            expect(env.props.tags).toHaveProperty("newKey", "newValue");
+        });
+    });
+    describe("Outputs", () => {
+        it("should create all required outputs", () => {
+            const env = new container_app_environment_1.ContainerAppEnvironment(stack, "TestEnv", {
+                name: "my-container-env",
+                location: "eastus",
+            });
+            expect(env.idOutput).toBeDefined();
+            expect(env.locationOutput).toBeDefined();
+            expect(env.nameOutput).toBeDefined();
+            expect(env.tagsOutput).toBeDefined();
+            expect(env.defaultDomainOutput).toBeDefined();
+            expect(env.staticIpOutput).toBeDefined();
+            expect(env.provisioningStateOutput).toBeDefined();
+        });
+        it("should have correct logical IDs for outputs", () => {
+            new container_app_environment_1.ContainerAppEnvironment(stack, "TestEnv", {
+                name: "my-container-env",
+                location: "eastus",
+            });
+            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('"default_domain"');
+            expect(synthesized).toContain('"static_ip"');
+            expect(synthesized).toContain('"provisioning_state"');
+        });
+    });
+    describe("App Logs Configuration", () => {
+        it("should include Log Analytics configuration in resource body", () => {
+            new container_app_environment_1.ContainerAppEnvironment(stack, "TestEnv", {
+                name: "my-container-env",
+                location: "eastus",
+                appLogsConfiguration: {
+                    destination: "log-analytics",
+                    logAnalyticsConfiguration: {
+                        customerId: "workspace-id-123",
+                        sharedKey: "shared-key-abc",
+                    },
+                },
+            });
+            const synthesized = cdktn_1.Testing.synth(stack);
+            expect(synthesized).toContain("appLogsConfiguration");
+            expect(synthesized).toContain("log-analytics");
+            expect(synthesized).toContain("workspace-id-123");
+        });
+        it("should support azure-monitor destination", () => {
+            new container_app_environment_1.ContainerAppEnvironment(stack, "TestEnv", {
+                name: "my-container-env",
+                location: "eastus",
+                appLogsConfiguration: {
+                    destination: "azure-monitor",
+                },
+            });
+            const synthesized = cdktn_1.Testing.synth(stack);
+            expect(synthesized).toContain("azure-monitor");
+        });
+    });
+    describe("VNet Configuration", () => {
+        it("should include VNet configuration in resource body", () => {
+            new container_app_environment_1.ContainerAppEnvironment(stack, "TestEnv", {
+                name: "my-container-env",
+                location: "eastus",
+                vnetConfiguration: {
+                    infrastructureSubnetId: "/subscriptions/sub-id/resourceGroups/rg/providers/Microsoft.Network/virtualNetworks/vnet/subnets/subnet",
+                    internal: true,
+                },
+            });
+            const synthesized = cdktn_1.Testing.synth(stack);
+            expect(synthesized).toContain("vnetConfiguration");
+            expect(synthesized).toContain("infrastructureSubnetId");
+        });
+    });
+    describe("Workload Profiles", () => {
+        it("should include workload profiles in resource body", () => {
+            new container_app_environment_1.ContainerAppEnvironment(stack, "TestEnv", {
+                name: "my-container-env",
+                location: "eastus",
+                workloadProfiles: [
+                    {
+                        name: "My-consumption-01",
+                        workloadProfileType: "Consumption",
+                    },
+                    {
+                        name: "My-GP-01",
+                        workloadProfileType: "GeneralPurpose",
+                        minimumCount: 3,
+                        maximumCount: 12,
+                    },
+                ],
+            });
+            const synthesized = cdktn_1.Testing.synth(stack);
+            expect(synthesized).toContain("workloadProfiles");
+            expect(synthesized).toContain("Consumption");
+            expect(synthesized).toContain("GeneralPurpose");
+        });
+    });
+    describe("Zone Redundancy", () => {
+        it("should include zone redundancy when set to true", () => {
+            new container_app_environment_1.ContainerAppEnvironment(stack, "TestEnv", {
+                name: "my-container-env",
+                location: "eastus",
+                zoneRedundant: true,
+            });
+            const synthesized = cdktn_1.Testing.synth(stack);
+            expect(synthesized).toContain("zoneRedundant");
+        });
+    });
+    describe("2025-07-01 Features", () => {
+        it("should support peer authentication (mTLS)", () => {
+            new container_app_environment_1.ContainerAppEnvironment(stack, "TestEnv", {
+                name: "my-container-env",
+                location: "eastus",
+                peerAuthentication: {
+                    mtls: { enabled: true },
+                },
+            });
+            const synthesized = cdktn_1.Testing.synth(stack);
+            expect(synthesized).toContain("peerAuthentication");
+            expect(synthesized).toContain("mtls");
+        });
+        it("should support peer traffic encryption", () => {
+            new container_app_environment_1.ContainerAppEnvironment(stack, "TestEnv", {
+                name: "my-container-env",
+                location: "eastus",
+                peerTrafficConfiguration: {
+                    encryption: { enabled: true },
+                },
+            });
+            const synthesized = cdktn_1.Testing.synth(stack);
+            expect(synthesized).toContain("peerTrafficConfiguration");
+            expect(synthesized).toContain("encryption");
+        });
+        it("should support ingress configuration", () => {
+            new container_app_environment_1.ContainerAppEnvironment(stack, "TestEnv", {
+                name: "my-container-env",
+                location: "eastus",
+                ingressConfiguration: {
+                    workloadProfileName: "My-CO-01",
+                    terminationGracePeriodSeconds: 3600,
+                    headerCountLimit: 30,
+                    requestIdleTimeout: 5,
+                },
+            });
+            const synthesized = cdktn_1.Testing.synth(stack);
+            expect(synthesized).toContain("ingressConfiguration");
+            expect(synthesized).toContain("My-CO-01");
+        });
+        it("should support public network access control", () => {
+            new container_app_environment_1.ContainerAppEnvironment(stack, "TestEnv", {
+                name: "my-container-env",
+                location: "eastus",
+                publicNetworkAccess: "Disabled",
+            });
+            const synthesized = cdktn_1.Testing.synth(stack);
+            expect(synthesized).toContain("publicNetworkAccess");
+            expect(synthesized).toContain("Disabled");
+        });
+    });
+    describe("Ignore Changes Configuration", () => {
+        it("should apply ignore changes lifecycle rules", () => {
+            new container_app_environment_1.ContainerAppEnvironment(stack, "TestEnv", {
+                name: "my-container-env",
+                location: "eastus",
+                ignoreChanges: ["tags"],
+            });
+            const synthesized = cdktn_1.Testing.synth(stack);
+            expect(synthesized).toContain("ignore_changes");
+        });
+        it("should handle multiple ignore changes properties", () => {
+            new container_app_environment_1.ContainerAppEnvironment(stack, "TestEnv2", {
+                name: "my-container-env-2",
+                location: "eastus",
+                ignoreChanges: ["tags", "location"],
+            });
+            const synthesized = cdktn_1.Testing.synth(stack);
+            expect(synthesized).toBeDefined();
+        });
+    });
+    describe("CDK Terraform Integration", () => {
+        it("should synthesize to valid Terraform configuration", () => {
+            new container_app_environment_1.ContainerAppEnvironment(stack, "SynthTest", {
+                name: "my-container-env",
+                location: "eastus",
+                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_environment_1.ContainerAppEnvironment(stack, "SynthTest", {
+                name: "my-container-env",
+                location: "eastus",
+            });
+            const synthesized = cdktn_1.Testing.synth(stack);
+            expect(synthesized).toContain("Microsoft.App/managedEnvironments");
+            expect(synthesized).toContain("2025-07-01");
+        });
+    });
+    describe("Resource Identification", () => {
+        it("should provide resource ID", () => {
+            const env = new container_app_environment_1.ContainerAppEnvironment(stack, "TestEnv", {
+                name: "my-container-env",
+                location: "eastus",
+            });
+            expect(env.id).toBeDefined();
+            expect(typeof env.id).toBe("string");
+        });
+        it("should provide resource name from props", () => {
+            const env = new container_app_environment_1.ContainerAppEnvironment(stack, "TestEnv", {
+                name: "my-container-env",
+                location: "eastus",
+            });
+            expect(env.props.name).toBe("my-container-env");
+        });
+    });
+    describe("JSII Compliance", () => {
+        it("should have proper return types for all public methods", () => {
+            const env = new container_app_environment_1.ContainerAppEnvironment(stack, "TestEnv", {
+                name: "my-container-env",
+                location: "eastus",
+            });
+            expect(typeof env.defaultDomain).toBe("string");
+            expect(typeof env.staticIp).toBe("string");
+            expect(typeof env.provisioningState).toBe("string");
+        });
+        it("should not use function types in public interface", () => {
+            const env = new container_app_environment_1.ContainerAppEnvironment(stack, "TestEnv", {
+                name: "my-container-env",
+                location: "eastus",
+            });
+            expect(typeof env.addTag).toBe("function");
+            expect(typeof env.removeTag).toBe("function");
+            env.addTag("test", "value");
+            expect(env.props.tags).toHaveProperty("test", "value");
+        });
+    });
+    describe("Schema Registration", () => {
+        it("should register schemas successfully", () => {
+            const env = new container_app_environment_1.ContainerAppEnvironment(stack, "TestEnv", {
+                name: "my-container-env",
+                location: "eastus",
+            });
+            expect(env).toBeDefined();
+            expect(env.resolvedApiVersion).toBe("2025-07-01");
+        });
+        it("should handle multiple instantiations without errors", () => {
+            new container_app_environment_1.ContainerAppEnvironment(stack, "TestEnv1", {
+                name: "my-container-env-1",
+                location: "eastus",
+            });
+            const env2 = new container_app_environment_1.ContainerAppEnvironment(stack, "TestEnv2", {
+                name: "my-container-env-2",
+                location: "westus",
+            });
+            expect(env2).toBeDefined();
+        });
+    });
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"container-app-environment.spec.js","sourceRoot":"","sources":["../../../src/azure-containerapps/test/container-app-environment.spec.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Comprehensive tests for the unified ContainerAppEnvironment implementation\n *\n * This test suite validates the unified ContainerAppEnvironment 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 {\n  ContainerAppEnvironment,\n  ContainerAppEnvironmentProps,\n} from \"../lib/container-app-environment\";\nimport {\n  ALL_CONTAINER_APP_ENVIRONMENT_VERSIONS,\n  CONTAINER_APP_ENVIRONMENT_TYPE,\n} from \"../lib/container-app-environment-schemas\";\n\ndescribe(\"ContainerAppEnvironment - Unified Implementation\", () => {\n  let app: cdktn.App;\n  let stack: cdktn.TerraformStack;\n  let manager: ApiVersionManager;\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_ENVIRONMENT_TYPE,\n        ALL_CONTAINER_APP_ENVIRONMENT_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 Environment with automatic latest version resolution\", () => {\n      const props: ContainerAppEnvironmentProps = {\n        name: \"my-container-env\",\n        location: \"eastus\",\n      };\n\n      const env = new ContainerAppEnvironment(stack, \"TestEnv\", props);\n\n      expect(env).toBeInstanceOf(ContainerAppEnvironment);\n      expect(env.resolvedApiVersion).toBe(\"2025-07-01\");\n      expect(env.props).toBe(props);\n    });\n\n    it(\"should create Container App Environment with explicit version pinning\", () => {\n      const props: ContainerAppEnvironmentProps = {\n        name: \"my-container-env\",\n        location: \"eastus\",\n        apiVersion: \"2024-03-01\",\n        tags: { environment: \"test\" },\n      };\n\n      const env = new ContainerAppEnvironment(stack, \"TestEnv\", props);\n\n      expect(env.resolvedApiVersion).toBe(\"2024-03-01\");\n      expect(env.tags).toEqual({ environment: \"test\" });\n    });\n\n    it(\"should require location property\", () => {\n      const props: ContainerAppEnvironmentProps = {\n        name: \"my-container-env\",\n        location: \"eastus\",\n      };\n\n      const env = new ContainerAppEnvironment(stack, \"TestEnv\", props);\n\n      expect(env.location).toBe(\"eastus\");\n      expect(env.props.location).toBe(\"eastus\");\n    });\n  });\n\n  describe(\"Framework Integration\", () => {\n    it(\"should resolve latest API version automatically\", () => {\n      const env = new ContainerAppEnvironment(stack, \"TestEnv\", {\n        name: \"my-container-env\",\n        location: \"eastus\",\n      });\n\n      expect(env.resolvedApiVersion).toBe(\"2025-07-01\");\n      expect(env.latestVersion()).toBe(\"2025-07-01\");\n    });\n\n    it(\"should provide version configuration\", () => {\n      const env = new ContainerAppEnvironment(stack, \"TestEnv\", {\n        name: \"my-container-env\",\n        location: \"eastus\",\n      });\n\n      expect(env.versionConfig).toBeDefined();\n      expect(env.versionConfig.version).toBe(\"2025-07-01\");\n      expect(env.versionConfig.supportLevel).toBe(VersionSupportLevel.ACTIVE);\n    });\n\n    it(\"should provide supported versions\", () => {\n      const env = new ContainerAppEnvironment(stack, \"TestEnv\", {\n        name: \"my-container-env\",\n        location: \"eastus\",\n      });\n\n      const versions = env.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 default domain\", () => {\n      const env = new ContainerAppEnvironment(stack, \"TestEnv\", {\n        name: \"my-container-env\",\n        location: \"eastus\",\n      });\n\n      expect(env.defaultDomain).toBeDefined();\n      expect(typeof env.defaultDomain).toBe(\"string\");\n    });\n\n    it(\"should provide static IP\", () => {\n      const env = new ContainerAppEnvironment(stack, \"TestEnv\", {\n        name: \"my-container-env\",\n        location: \"eastus\",\n      });\n\n      expect(env.staticIp).toBeDefined();\n      expect(typeof env.staticIp).toBe(\"string\");\n    });\n\n    it(\"should provide provisioning state\", () => {\n      const env = new ContainerAppEnvironment(stack, \"TestEnv\", {\n        name: \"my-container-env\",\n        location: \"eastus\",\n      });\n\n      expect(env.provisioningState).toBeDefined();\n      expect(typeof env.provisioningState).toBe(\"string\");\n    });\n  });\n\n  describe(\"Tag Management\", () => {\n    it(\"should allow adding tags\", () => {\n      const env = new ContainerAppEnvironment(stack, \"TestEnv\", {\n        name: \"my-container-env\",\n        location: \"eastus\",\n        tags: { initial: \"tag\" },\n      });\n\n      env.addTag(\"newKey\", \"newValue\");\n      expect(env.props.tags).toHaveProperty(\"newKey\", \"newValue\");\n      expect(env.props.tags).toHaveProperty(\"initial\", \"tag\");\n    });\n\n    it(\"should allow removing tags\", () => {\n      const env = new ContainerAppEnvironment(stack, \"TestEnv\", {\n        name: \"my-container-env\",\n        location: \"eastus\",\n        tags: { key1: \"value1\", key2: \"value2\" },\n      });\n\n      env.removeTag(\"key1\");\n      expect(env.props.tags).not.toHaveProperty(\"key1\");\n      expect(env.props.tags).toHaveProperty(\"key2\", \"value2\");\n    });\n\n    it(\"should handle adding tags when no initial tags exist\", () => {\n      const env = new ContainerAppEnvironment(stack, \"TestEnv\", {\n        name: \"my-container-env\",\n        location: \"eastus\",\n      });\n\n      env.addTag(\"newKey\", \"newValue\");\n      expect(env.props.tags).toHaveProperty(\"newKey\", \"newValue\");\n    });\n  });\n\n  describe(\"Outputs\", () => {\n    it(\"should create all required outputs\", () => {\n      const env = new ContainerAppEnvironment(stack, \"TestEnv\", {\n        name: \"my-container-env\",\n        location: \"eastus\",\n      });\n\n      expect(env.idOutput).toBeDefined();\n      expect(env.locationOutput).toBeDefined();\n      expect(env.nameOutput).toBeDefined();\n      expect(env.tagsOutput).toBeDefined();\n      expect(env.defaultDomainOutput).toBeDefined();\n      expect(env.staticIpOutput).toBeDefined();\n      expect(env.provisioningStateOutput).toBeDefined();\n    });\n\n    it(\"should have correct logical IDs for outputs\", () => {\n      new ContainerAppEnvironment(stack, \"TestEnv\", {\n        name: \"my-container-env\",\n        location: \"eastus\",\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('\"default_domain\"');\n      expect(synthesized).toContain('\"static_ip\"');\n      expect(synthesized).toContain('\"provisioning_state\"');\n    });\n  });\n\n  describe(\"App Logs Configuration\", () => {\n    it(\"should include Log Analytics configuration in resource body\", () => {\n      new ContainerAppEnvironment(stack, \"TestEnv\", {\n        name: \"my-container-env\",\n        location: \"eastus\",\n        appLogsConfiguration: {\n          destination: \"log-analytics\",\n          logAnalyticsConfiguration: {\n            customerId: \"workspace-id-123\",\n            sharedKey: \"shared-key-abc\",\n          },\n        },\n      });\n\n      const synthesized = Testing.synth(stack);\n      expect(synthesized).toContain(\"appLogsConfiguration\");\n      expect(synthesized).toContain(\"log-analytics\");\n      expect(synthesized).toContain(\"workspace-id-123\");\n    });\n\n    it(\"should support azure-monitor destination\", () => {\n      new ContainerAppEnvironment(stack, \"TestEnv\", {\n        name: \"my-container-env\",\n        location: \"eastus\",\n        appLogsConfiguration: {\n          destination: \"azure-monitor\",\n        },\n      });\n\n      const synthesized = Testing.synth(stack);\n      expect(synthesized).toContain(\"azure-monitor\");\n    });\n  });\n\n  describe(\"VNet Configuration\", () => {\n    it(\"should include VNet configuration in resource body\", () => {\n      new ContainerAppEnvironment(stack, \"TestEnv\", {\n        name: \"my-container-env\",\n        location: \"eastus\",\n        vnetConfiguration: {\n          infrastructureSubnetId:\n            \"/subscriptions/sub-id/resourceGroups/rg/providers/Microsoft.Network/virtualNetworks/vnet/subnets/subnet\",\n          internal: true,\n        },\n      });\n\n      const synthesized = Testing.synth(stack);\n      expect(synthesized).toContain(\"vnetConfiguration\");\n      expect(synthesized).toContain(\"infrastructureSubnetId\");\n    });\n  });\n\n  describe(\"Workload Profiles\", () => {\n    it(\"should include workload profiles in resource body\", () => {\n      new ContainerAppEnvironment(stack, \"TestEnv\", {\n        name: \"my-container-env\",\n        location: \"eastus\",\n        workloadProfiles: [\n          {\n            name: \"My-consumption-01\",\n            workloadProfileType: \"Consumption\",\n          },\n          {\n            name: \"My-GP-01\",\n            workloadProfileType: \"GeneralPurpose\",\n            minimumCount: 3,\n            maximumCount: 12,\n          },\n        ],\n      });\n\n      const synthesized = Testing.synth(stack);\n      expect(synthesized).toContain(\"workloadProfiles\");\n      expect(synthesized).toContain(\"Consumption\");\n      expect(synthesized).toContain(\"GeneralPurpose\");\n    });\n  });\n\n  describe(\"Zone Redundancy\", () => {\n    it(\"should include zone redundancy when set to true\", () => {\n      new ContainerAppEnvironment(stack, \"TestEnv\", {\n        name: \"my-container-env\",\n        location: \"eastus\",\n        zoneRedundant: true,\n      });\n\n      const synthesized = Testing.synth(stack);\n      expect(synthesized).toContain(\"zoneRedundant\");\n    });\n  });\n\n  describe(\"2025-07-01 Features\", () => {\n    it(\"should support peer authentication (mTLS)\", () => {\n      new ContainerAppEnvironment(stack, \"TestEnv\", {\n        name: \"my-container-env\",\n        location: \"eastus\",\n        peerAuthentication: {\n          mtls: { enabled: true },\n        },\n      });\n\n      const synthesized = Testing.synth(stack);\n      expect(synthesized).toContain(\"peerAuthentication\");\n      expect(synthesized).toContain(\"mtls\");\n    });\n\n    it(\"should support peer traffic encryption\", () => {\n      new ContainerAppEnvironment(stack, \"TestEnv\", {\n        name: \"my-container-env\",\n        location: \"eastus\",\n        peerTrafficConfiguration: {\n          encryption: { enabled: true },\n        },\n      });\n\n      const synthesized = Testing.synth(stack);\n      expect(synthesized).toContain(\"peerTrafficConfiguration\");\n      expect(synthesized).toContain(\"encryption\");\n    });\n\n    it(\"should support ingress configuration\", () => {\n      new ContainerAppEnvironment(stack, \"TestEnv\", {\n        name: \"my-container-env\",\n        location: \"eastus\",\n        ingressConfiguration: {\n          workloadProfileName: \"My-CO-01\",\n          terminationGracePeriodSeconds: 3600,\n          headerCountLimit: 30,\n          requestIdleTimeout: 5,\n        },\n      });\n\n      const synthesized = Testing.synth(stack);\n      expect(synthesized).toContain(\"ingressConfiguration\");\n      expect(synthesized).toContain(\"My-CO-01\");\n    });\n\n    it(\"should support public network access control\", () => {\n      new ContainerAppEnvironment(stack, \"TestEnv\", {\n        name: \"my-container-env\",\n        location: \"eastus\",\n        publicNetworkAccess: \"Disabled\",\n      });\n\n      const synthesized = Testing.synth(stack);\n      expect(synthesized).toContain(\"publicNetworkAccess\");\n      expect(synthesized).toContain(\"Disabled\");\n    });\n  });\n\n  describe(\"Ignore Changes Configuration\", () => {\n    it(\"should apply ignore changes lifecycle rules\", () => {\n      new ContainerAppEnvironment(stack, \"TestEnv\", {\n        name: \"my-container-env\",\n        location: \"eastus\",\n        ignoreChanges: [\"tags\"],\n      });\n\n      const synthesized = Testing.synth(stack);\n      expect(synthesized).toContain(\"ignore_changes\");\n    });\n\n    it(\"should handle multiple ignore changes properties\", () => {\n      new ContainerAppEnvironment(stack, \"TestEnv2\", {\n        name: \"my-container-env-2\",\n        location: \"eastus\",\n        ignoreChanges: [\"tags\", \"location\"],\n      });\n\n      const synthesized = Testing.synth(stack);\n      expect(synthesized).toBeDefined();\n    });\n  });\n\n  describe(\"CDK Terraform Integration\", () => {\n    it(\"should synthesize to valid Terraform configuration\", () => {\n      new ContainerAppEnvironment(stack, \"SynthTest\", {\n        name: \"my-container-env\",\n        location: \"eastus\",\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 ContainerAppEnvironment(stack, \"SynthTest\", {\n        name: \"my-container-env\",\n        location: \"eastus\",\n      });\n\n      const synthesized = Testing.synth(stack);\n      expect(synthesized).toContain(\"Microsoft.App/managedEnvironments\");\n      expect(synthesized).toContain(\"2025-07-01\");\n    });\n  });\n\n  describe(\"Resource Identification\", () => {\n    it(\"should provide resource ID\", () => {\n      const env = new ContainerAppEnvironment(stack, \"TestEnv\", {\n        name: \"my-container-env\",\n        location: \"eastus\",\n      });\n\n      expect(env.id).toBeDefined();\n      expect(typeof env.id).toBe(\"string\");\n    });\n\n    it(\"should provide resource name from props\", () => {\n      const env = new ContainerAppEnvironment(stack, \"TestEnv\", {\n        name: \"my-container-env\",\n        location: \"eastus\",\n      });\n\n      expect(env.props.name).toBe(\"my-container-env\");\n    });\n  });\n\n  describe(\"JSII Compliance\", () => {\n    it(\"should have proper return types for all public methods\", () => {\n      const env = new ContainerAppEnvironment(stack, \"TestEnv\", {\n        name: \"my-container-env\",\n        location: \"eastus\",\n      });\n\n      expect(typeof env.defaultDomain).toBe(\"string\");\n      expect(typeof env.staticIp).toBe(\"string\");\n      expect(typeof env.provisioningState).toBe(\"string\");\n    });\n\n    it(\"should not use function types in public interface\", () => {\n      const env = new ContainerAppEnvironment(stack, \"TestEnv\", {\n        name: \"my-container-env\",\n        location: \"eastus\",\n      });\n\n      expect(typeof env.addTag).toBe(\"function\");\n      expect(typeof env.removeTag).toBe(\"function\");\n\n      env.addTag(\"test\", \"value\");\n      expect(env.props.tags).toHaveProperty(\"test\", \"value\");\n    });\n  });\n\n  describe(\"Schema Registration\", () => {\n    it(\"should register schemas successfully\", () => {\n      const env = new ContainerAppEnvironment(stack, \"TestEnv\", {\n        name: \"my-container-env\",\n        location: \"eastus\",\n      });\n\n      expect(env).toBeDefined();\n      expect(env.resolvedApiVersion).toBe(\"2025-07-01\");\n    });\n\n    it(\"should handle multiple instantiations without errors\", () => {\n      new ContainerAppEnvironment(stack, \"TestEnv1\", {\n        name: \"my-container-env-1\",\n        location: \"eastus\",\n      });\n\n      const env2 = new ContainerAppEnvironment(stack, \"TestEnv2\", {\n        name: \"my-container-env-2\",\n        location: \"westus\",\n      });\n\n      expect(env2).toBeDefined();\n    });\n  });\n});\n"]}

package/lib/azure-containerapps/test/container-app.integ.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Integration test for Azure Container App
+ *
+ * This test demonstrates usage of the ContainerApp construct with
+ * a Container App Environment, and validates deployment, idempotency,
+ * and cleanup.
+ *
+ * Run with: npm run integration:nostream
+ */
+import "cdktn/lib/testing/adapters/jest";

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

@@ -0,0 +1,119 @@
+"use strict";
+/**
+ * Integration test for Azure Container App
+ *
+ * This test demonstrates usage of the ContainerApp construct with
+ * a Container App Environment, and validates deployment, idempotency,
+ * and cleanup.
+ *
+ * Run with: npm run integration:nostream
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const cdktn_1 = require("cdktn");
+require("cdktn/lib/testing/adapters/jest");
+const resource_group_1 = require("../../azure-resourcegroup/lib/resource-group");
+const provider_1 = require("../../core-azure/lib/azapi/providers-azapi/provider");
+const testing_1 = require("../../testing");
+const metadata_1 = require("../../testing/lib/metadata");
+const container_app_1 = require("../lib/container-app");
+const container_app_environment_1 = require("../lib/container-app-environment");
+// Generate unique test run metadata for this test suite
+const testMetadata = new metadata_1.TestRunMetadata("containerapp-integration", {
+    maxAgeHours: 4,
+});
+/**
+ * Example stack demonstrating Container App usage
+ */
+class ContainerAppExampleStack extends testing_1.BaseTestStack {
+    constructor(scope, id) {
+        super(scope, id, {
+            testRunOptions: {
+                maxAgeHours: testMetadata.maxAgeHours,
+                autoCleanup: testMetadata.autoCleanup,
+                cleanupPolicy: testMetadata.cleanupPolicy,
+            },
+        });
+        // Configure AZAPI provider
+        new provider_1.AzapiProvider(this, "azapi", {});
+        // Generate unique names
+        const resourceGroupName = this.generateResourceName("Microsoft.Resources/resourceGroups", "containerapp");
+        const envName = this.generateResourceName("Microsoft.App/managedEnvironments", "containerapp");
+        const appName = this.generateResourceName("Microsoft.App/containerApps", "containerapp");
+        // Create resource group
+        const resourceGroup = new resource_group_1.ResourceGroup(this, "test-rg", {
+            name: resourceGroupName,
+            location: "eastus",
+            tags: {
+                ...this.systemTags(),
+                purpose: "container-app-testing",
+            },
+        });
+        // Create Container App Environment
+        const environment = new container_app_environment_1.ContainerAppEnvironment(this, "container-env", {
+            name: envName,
+            location: "eastus",
+            apiVersion: "2025-02-02-preview",
+            resourceGroupId: resourceGroup.id,
+            workloadProfiles: [
+                {
+                    name: "Consumption",
+                    workloadProfileType: "Consumption",
+                },
+            ],
+            tags: {
+                ...this.systemTags(),
+                purpose: "container-app-hosting",
+            },
+        });
+        // Create Container App with external ingress
+        new container_app_1.ContainerApp(this, "container-app", {
+            name: appName,
+            location: "eastus",
+            apiVersion: "2025-02-02-preview",
+            resourceGroupId: resourceGroup.id,
+            environmentId: environment.id,
+            template: {
+                containers: [
+                    {
+                        name: "helloworld",
+                        image: "mcr.microsoft.com/azuredocs/containerapps-helloworld:latest",
+                        resources: {
+                            cpu: 0.25,
+                            memory: "0.5Gi",
+                        },
+                    },
+                ],
+                scale: {
+                    minReplicas: 0,
+                    maxReplicas: 1,
+                },
+            },
+            configuration: {
+                ingress: {
+                    external: true,
+                    targetPort: 80,
+                    transport: "auto",
+                },
+            },
+            tags: {
+                ...this.systemTags(),
+                example: "complete",
+                environment: "test",
+                purpose: "container-app-demo",
+            },
+        });
+    }
+}
+describe("ContainerApp Integration Test", () => {
+    it("should deploy Container App with environment, validate idempotency, and cleanup", () => {
+        const app = cdktn_1.Testing.app();
+        const stack = new ContainerAppExampleStack(app, "test-containerapp");
+        const synthesized = cdktn_1.Testing.fullSynth(stack);
+        // This will:
+        // 1. Run terraform apply to deploy resources (RG, Environment, App)
+        // 2. Run terraform plan to check idempotency (no changes expected)
+        // 3. Run terraform destroy to cleanup resources
+        (0, testing_1.TerraformApplyCheckAndDestroy)(synthesized, { verifyCleanup: true });
+    }, 900000); // 15 minute timeout for deployment and cleanup
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"container-app.integ.js","sourceRoot":"","sources":["../../../src/azure-containerapps/test/container-app.integ.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Integration test for Azure Container App\n *\n * This test demonstrates usage of the ContainerApp construct with\n * a Container App Environment, and validates deployment, idempotency,\n * and cleanup.\n *\n * Run with: npm run integration:nostream\n */\n\nimport { Testing } from \"cdktn\";\nimport { Construct } from \"constructs\";\nimport \"cdktn/lib/testing/adapters/jest\";\nimport { ResourceGroup } from \"../../azure-resourcegroup/lib/resource-group\";\nimport { AzapiProvider } from \"../../core-azure/lib/azapi/providers-azapi/provider\";\nimport { BaseTestStack, TerraformApplyCheckAndDestroy } from \"../../testing\";\nimport { TestRunMetadata } from \"../../testing/lib/metadata\";\nimport { ContainerApp } from \"../lib/container-app\";\nimport { ContainerAppEnvironment } from \"../lib/container-app-environment\";\n\n// Generate unique test run metadata for this test suite\nconst testMetadata = new TestRunMetadata(\"containerapp-integration\", {\n  maxAgeHours: 4,\n});\n\n/**\n * Example stack demonstrating Container App usage\n */\nclass ContainerAppExampleStack extends BaseTestStack {\n  constructor(scope: Construct, id: string) {\n    super(scope, id, {\n      testRunOptions: {\n        maxAgeHours: testMetadata.maxAgeHours,\n        autoCleanup: testMetadata.autoCleanup,\n        cleanupPolicy: testMetadata.cleanupPolicy,\n      },\n    });\n\n    // Configure AZAPI provider\n    new AzapiProvider(this, \"azapi\", {});\n\n    // Generate unique names\n    const resourceGroupName = this.generateResourceName(\n      \"Microsoft.Resources/resourceGroups\",\n      \"containerapp\",\n    );\n    const envName = this.generateResourceName(\n      \"Microsoft.App/managedEnvironments\",\n      \"containerapp\",\n    );\n    const appName = this.generateResourceName(\n      \"Microsoft.App/containerApps\",\n      \"containerapp\",\n    );\n\n    // Create resource group\n    const resourceGroup = new ResourceGroup(this, \"test-rg\", {\n      name: resourceGroupName,\n      location: \"eastus\",\n      tags: {\n        ...this.systemTags(),\n        purpose: \"container-app-testing\",\n      },\n    });\n\n    // Create Container App Environment\n    const environment = new ContainerAppEnvironment(this, \"container-env\", {\n      name: envName,\n      location: \"eastus\",\n      apiVersion: \"2025-02-02-preview\",\n      resourceGroupId: resourceGroup.id,\n      workloadProfiles: [\n        {\n          name: \"Consumption\",\n          workloadProfileType: \"Consumption\",\n        },\n      ],\n      tags: {\n        ...this.systemTags(),\n        purpose: \"container-app-hosting\",\n      },\n    });\n\n    // Create Container App with external ingress\n    new ContainerApp(this, \"container-app\", {\n      name: appName,\n      location: \"eastus\",\n      apiVersion: \"2025-02-02-preview\",\n      resourceGroupId: resourceGroup.id,\n      environmentId: environment.id,\n      template: {\n        containers: [\n          {\n            name: \"helloworld\",\n            image:\n              \"mcr.microsoft.com/azuredocs/containerapps-helloworld:latest\",\n            resources: {\n              cpu: 0.25,\n              memory: \"0.5Gi\",\n            },\n          },\n        ],\n        scale: {\n          minReplicas: 0,\n          maxReplicas: 1,\n        },\n      },\n      configuration: {\n        ingress: {\n          external: true,\n          targetPort: 80,\n          transport: \"auto\",\n        },\n      },\n      tags: {\n        ...this.systemTags(),\n        example: \"complete\",\n        environment: \"test\",\n        purpose: \"container-app-demo\",\n      },\n    });\n  }\n}\n\ndescribe(\"ContainerApp Integration Test\", () => {\n  it(\"should deploy Container App with environment, validate idempotency, and cleanup\", () => {\n    const app = Testing.app();\n    const stack = new ContainerAppExampleStack(app, \"test-containerapp\");\n    const synthesized = Testing.fullSynth(stack);\n\n    // This will:\n    // 1. Run terraform apply to deploy resources (RG, Environment, App)\n    // 2. Run terraform plan to check idempotency (no changes expected)\n    // 3. Run terraform destroy to cleanup resources\n    TerraformApplyCheckAndDestroy(synthesized, { verifyCleanup: true });\n  }, 900000); // 15 minute timeout for deployment and cleanup\n});\n"]}