@microsoft/terraform-cdk-constructs 1.9.0 → 1.10.0

package/lib/azure-cosmosdb/test/cosmos-db.integ.js

@@ -0,0 +1,98 @@
+"use strict";
+/**
+ * Integration test for Azure Cosmos DB Account
+ *
+ * This test demonstrates basic usage of the CosmosDbAccount construct
+ * and validates deployment, idempotency, and cleanup.
+ *
+ * Run with: npm run integration:nostream
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const cdktf_1 = require("cdktf");
+require("cdktf/lib/testing/adapters/jest");
+const azure_resourcegroup_1 = require("../../azure-resourcegroup");
+const provider_1 = require("../../core-azure/lib/azapi/providers-azapi/provider");
+const testing_1 = require("../../testing");
+const metadata_1 = require("../../testing/lib/metadata");
+const cosmos_db_1 = require("../lib/cosmos-db");
+// Generate unique test run metadata for this test suite
+const testMetadata = new metadata_1.TestRunMetadata("cosmos-db-integration", {
+    maxAgeHours: 4,
+});
+/**
+ * Example stack demonstrating Cosmos DB Account usage
+ */
+class CosmosDbExampleStack 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", {});
+        // Create a resource group
+        const rgName = this.generateResourceName("Microsoft.Resources/resourceGroups", "cosmos");
+        const resourceGroup = new azure_resourcegroup_1.ResourceGroup(this, "example-rg", {
+            name: rgName,
+            location: "centralus",
+            tags: {
+                ...this.systemTags(),
+            },
+        });
+        // Generate unique cosmos db account names (must be globally unique)
+        const basicName = this.generateResourceName("Microsoft.DocumentDB/databaseAccounts", "basic");
+        const versionedName = this.generateResourceName("Microsoft.DocumentDB/databaseAccounts", "vers");
+        const serverlessName = this.generateResourceName("Microsoft.DocumentDB/databaseAccounts", "srvls");
+        // Example 1: Basic Cosmos DB account (Core SQL API)
+        new cosmos_db_1.CosmosDbAccount(this, "basic-cosmos", {
+            name: basicName,
+            location: resourceGroup.props.location,
+            resourceGroupId: resourceGroup.id,
+            tags: {
+                ...this.systemTags(),
+                example: "basic",
+            },
+        });
+        // Example 2: Cosmos DB account with specific API version and Strong consistency
+        new cosmos_db_1.CosmosDbAccount(this, "versioned-cosmos", {
+            name: versionedName,
+            location: resourceGroup.props.location,
+            resourceGroupId: resourceGroup.id,
+            apiVersion: "2024-05-15",
+            consistencyPolicy: {
+                defaultConsistencyLevel: "Strong",
+            },
+            tags: {
+                ...this.systemTags(),
+                example: "versioned",
+            },
+        });
+        // Example 3: Serverless Cosmos DB account
+        new cosmos_db_1.CosmosDbAccount(this, "serverless-cosmos", {
+            name: serverlessName,
+            location: resourceGroup.props.location,
+            resourceGroupId: resourceGroup.id,
+            capabilities: [{ name: "EnableServerless" }],
+            tags: {
+                ...this.systemTags(),
+                example: "serverless",
+            },
+        });
+    }
+}
+describe("Cosmos DB Account Integration Test", () => {
+    it("should deploy, validate idempotency, and cleanup cosmos db resources", () => {
+        const app = cdktf_1.Testing.app();
+        const stack = new CosmosDbExampleStack(app, "test-cosmos-db");
+        const synthesized = cdktf_1.Testing.fullSynth(stack);
+        // This will:
+        // 1. Run terraform apply to deploy resources
+        // 2. Run terraform plan to check idempotency (no changes expected)
+        // 3. Run terraform destroy to cleanup resources
+        (0, testing_1.TerraformApplyCheckAndDestroy)(synthesized, { verifyCleanup: true });
+    }, 1800000); // 30 minute timeout (Cosmos DB account creation is slow)
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"cosmos-db.integ.js","sourceRoot":"","sources":["../../../src/azure-cosmosdb/test/cosmos-db.integ.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Integration test for Azure Cosmos DB Account\n *\n * This test demonstrates basic usage of the CosmosDbAccount construct\n * and validates deployment, idempotency, and cleanup.\n *\n * Run with: npm run integration:nostream\n */\n\nimport { Testing } from \"cdktf\";\nimport { Construct } from \"constructs\";\nimport \"cdktf/lib/testing/adapters/jest\";\nimport { ResourceGroup } from \"../../azure-resourcegroup\";\nimport { AzapiProvider } from \"../../core-azure/lib/azapi/providers-azapi/provider\";\nimport { BaseTestStack, TerraformApplyCheckAndDestroy } from \"../../testing\";\nimport { TestRunMetadata } from \"../../testing/lib/metadata\";\nimport { CosmosDbAccount } from \"../lib/cosmos-db\";\n\n// Generate unique test run metadata for this test suite\nconst testMetadata = new TestRunMetadata(\"cosmos-db-integration\", {\n  maxAgeHours: 4,\n});\n\n/**\n * Example stack demonstrating Cosmos DB Account usage\n */\nclass CosmosDbExampleStack 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    // Create a resource group\n    const rgName = this.generateResourceName(\n      \"Microsoft.Resources/resourceGroups\",\n      \"cosmos\",\n    );\n\n    const resourceGroup = new ResourceGroup(this, \"example-rg\", {\n      name: rgName,\n      location: \"centralus\",\n      tags: {\n        ...this.systemTags(),\n      },\n    });\n\n    // Generate unique cosmos db account names (must be globally unique)\n    const basicName = this.generateResourceName(\n      \"Microsoft.DocumentDB/databaseAccounts\",\n      \"basic\",\n    );\n    const versionedName = this.generateResourceName(\n      \"Microsoft.DocumentDB/databaseAccounts\",\n      \"vers\",\n    );\n    const serverlessName = this.generateResourceName(\n      \"Microsoft.DocumentDB/databaseAccounts\",\n      \"srvls\",\n    );\n\n    // Example 1: Basic Cosmos DB account (Core SQL API)\n    new CosmosDbAccount(this, \"basic-cosmos\", {\n      name: basicName,\n      location: resourceGroup.props.location!,\n      resourceGroupId: resourceGroup.id,\n      tags: {\n        ...this.systemTags(),\n        example: \"basic\",\n      },\n    });\n\n    // Example 2: Cosmos DB account with specific API version and Strong consistency\n    new CosmosDbAccount(this, \"versioned-cosmos\", {\n      name: versionedName,\n      location: resourceGroup.props.location!,\n      resourceGroupId: resourceGroup.id,\n      apiVersion: \"2024-05-15\",\n      consistencyPolicy: {\n        defaultConsistencyLevel: \"Strong\",\n      },\n      tags: {\n        ...this.systemTags(),\n        example: \"versioned\",\n      },\n    });\n\n    // Example 3: Serverless Cosmos DB account\n    new CosmosDbAccount(this, \"serverless-cosmos\", {\n      name: serverlessName,\n      location: resourceGroup.props.location!,\n      resourceGroupId: resourceGroup.id,\n      capabilities: [{ name: \"EnableServerless\" }],\n      tags: {\n        ...this.systemTags(),\n        example: \"serverless\",\n      },\n    });\n  }\n}\n\ndescribe(\"Cosmos DB Account Integration Test\", () => {\n  it(\"should deploy, validate idempotency, and cleanup cosmos db resources\", () => {\n    const app = Testing.app();\n    const stack = new CosmosDbExampleStack(app, \"test-cosmos-db\");\n    const synthesized = Testing.fullSynth(stack);\n\n    // This will:\n    // 1. Run terraform apply to deploy resources\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  }, 1800000); // 30 minute timeout (Cosmos DB account creation is slow)\n});\n"]}

package/lib/azure-cosmosdb/test/cosmos-db.spec.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Unit tests for Azure Cosmos DB Account using VersionedAzapiResource framework
+ */
+export {};

package/lib/azure-cosmosdb/test/cosmos-db.spec.js

@@ -0,0 +1,339 @@
+"use strict";
+/**
+ * Unit tests for Azure Cosmos DB Account using VersionedAzapiResource framework
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const cdktf_1 = require("cdktf");
+const cdktf = require("cdktf");
+const azure_resourcegroup_1 = require("../../azure-resourcegroup");
+const cosmos_db_1 = require("../lib/cosmos-db");
+describe("CosmosDbAccount", () => {
+    let app;
+    let stack;
+    beforeEach(() => {
+        app = cdktf_1.Testing.app();
+        stack = new cdktf.TerraformStack(app, "TestStack");
+    });
+    describe("constructor", () => {
+        it("should create a cosmos db account with required properties", () => {
+            const rg = new azure_resourcegroup_1.ResourceGroup(stack, "TestRG", {
+                name: "test-rg",
+                location: "eastus",
+            });
+            const props = {
+                name: "testcosmosaccount",
+                location: "eastus",
+                resourceGroupId: rg.id,
+            };
+            const cosmos = new cosmos_db_1.CosmosDbAccount(stack, "TestCosmos", props);
+            expect(cosmos).toBeInstanceOf(cosmos_db_1.CosmosDbAccount);
+            expect(cosmos.props).toBe(props);
+        });
+        it("should create a cosmos db account with all properties", () => {
+            const rg = new azure_resourcegroup_1.ResourceGroup(stack, "TestRG", {
+                name: "test-rg",
+                location: "eastus",
+            });
+            const props = {
+                name: "testcosmosaccount",
+                location: "eastus",
+                resourceGroupId: rg.id,
+                kind: "GlobalDocumentDB",
+                consistencyPolicy: {
+                    defaultConsistencyLevel: "Strong",
+                },
+                capabilities: [{ name: "EnableServerless" }],
+                publicNetworkAccess: "Enabled",
+                enableAutomaticFailover: false,
+                minimalTlsVersion: "Tls12",
+                tags: {
+                    environment: "test",
+                    project: "cdktf-constructs",
+                },
+                identity: {
+                    type: "SystemAssigned",
+                },
+            };
+            const cosmos = new cosmos_db_1.CosmosDbAccount(stack, "TestCosmos", props);
+            expect(cosmos.props).toBe(props);
+            expect(cosmos.tags).toEqual(props.tags);
+        });
+        it("should use default values for optional properties", () => {
+            const rg = new azure_resourcegroup_1.ResourceGroup(stack, "TestRG", {
+                name: "test-rg",
+                location: "eastus",
+            });
+            const props = {
+                name: "testcosmosaccount",
+                location: "eastus",
+                resourceGroupId: rg.id,
+            };
+            const cosmos = new cosmos_db_1.CosmosDbAccount(stack, "TestCosmos", props);
+            expect(cosmos).toBeInstanceOf(cosmos_db_1.CosmosDbAccount);
+        });
+        it("should create terraform outputs", () => {
+            const rg = new azure_resourcegroup_1.ResourceGroup(stack, "TestRG", {
+                name: "test-rg",
+                location: "eastus",
+            });
+            const props = {
+                name: "testcosmosaccount",
+                location: "eastus",
+                resourceGroupId: rg.id,
+            };
+            const cosmos = new cosmos_db_1.CosmosDbAccount(stack, "TestCosmos", props);
+            expect(cosmos.idOutput).toBeInstanceOf(cdktf.TerraformOutput);
+            expect(cosmos.locationOutput).toBeInstanceOf(cdktf.TerraformOutput);
+            expect(cosmos.nameOutput).toBeInstanceOf(cdktf.TerraformOutput);
+            expect(cosmos.tagsOutput).toBeInstanceOf(cdktf.TerraformOutput);
+            expect(cosmos.documentEndpointOutput).toBeInstanceOf(cdktf.TerraformOutput);
+        });
+    });
+    describe("kind configuration", () => {
+        it("should accept GlobalDocumentDB kind", () => {
+            const rg = new azure_resourcegroup_1.ResourceGroup(stack, "TestRG", {
+                name: "test-rg",
+                location: "eastus",
+            });
+            const props = {
+                name: "testcosmosaccount",
+                location: "eastus",
+                resourceGroupId: rg.id,
+                kind: "GlobalDocumentDB",
+            };
+            const cosmos = new cosmos_db_1.CosmosDbAccount(stack, "TestCosmos", props);
+            expect(cosmos.props.kind).toBe("GlobalDocumentDB");
+        });
+        it("should accept MongoDB kind", () => {
+            const rg = new azure_resourcegroup_1.ResourceGroup(stack, "TestRG", {
+                name: "test-rg",
+                location: "eastus",
+            });
+            const props = {
+                name: "testcosmosmongo",
+                location: "eastus",
+                resourceGroupId: rg.id,
+                kind: "MongoDB",
+                capabilities: [{ name: "EnableMongo" }],
+            };
+            const cosmos = new cosmos_db_1.CosmosDbAccount(stack, "TestCosmos", props);
+            expect(cosmos.props.kind).toBe("MongoDB");
+        });
+    });
+    describe("consistency policy", () => {
+        it("should configure Session consistency by default when none provided", () => {
+            const rg = new azure_resourcegroup_1.ResourceGroup(stack, "TestRG", {
+                name: "test-rg",
+                location: "eastus",
+            });
+            const props = {
+                name: "testcosmosconsistency",
+                location: "eastus",
+                resourceGroupId: rg.id,
+            };
+            const cosmos = new cosmos_db_1.CosmosDbAccount(stack, "TestCosmos", props);
+            expect(cosmos).toBeInstanceOf(cosmos_db_1.CosmosDbAccount);
+        });
+        it("should configure Strong consistency when specified", () => {
+            const rg = new azure_resourcegroup_1.ResourceGroup(stack, "TestRG", {
+                name: "test-rg",
+                location: "eastus",
+            });
+            const props = {
+                name: "testcosmosstrong",
+                location: "eastus",
+                resourceGroupId: rg.id,
+                consistencyPolicy: {
+                    defaultConsistencyLevel: "Strong",
+                },
+            };
+            const cosmos = new cosmos_db_1.CosmosDbAccount(stack, "TestCosmos", props);
+            expect(cosmos.props.consistencyPolicy?.defaultConsistencyLevel).toBe("Strong");
+        });
+        it("should configure BoundedStaleness consistency", () => {
+            const rg = new azure_resourcegroup_1.ResourceGroup(stack, "TestRG", {
+                name: "test-rg",
+                location: "eastus",
+            });
+            const props = {
+                name: "testcosmosbounded",
+                location: "eastus",
+                resourceGroupId: rg.id,
+                consistencyPolicy: {
+                    defaultConsistencyLevel: "BoundedStaleness",
+                    maxIntervalInSeconds: 86400,
+                    maxStalenessPrefix: 1000000,
+                },
+            };
+            const cosmos = new cosmos_db_1.CosmosDbAccount(stack, "TestCosmos", props);
+            expect(cosmos.props.consistencyPolicy?.defaultConsistencyLevel).toBe("BoundedStaleness");
+            expect(cosmos.props.consistencyPolicy?.maxIntervalInSeconds).toBe(86400);
+        });
+    });
+    describe("multi-region configuration", () => {
+        it("should configure multiple geo locations with failover", () => {
+            const rg = new azure_resourcegroup_1.ResourceGroup(stack, "TestRG", {
+                name: "test-rg",
+                location: "eastus",
+            });
+            const props = {
+                name: "testcosmosgeo",
+                location: "eastus",
+                resourceGroupId: rg.id,
+                enableAutomaticFailover: true,
+                geoLocations: [
+                    {
+                        locationName: "eastus",
+                        failoverPriority: 0,
+                        isZoneRedundant: true,
+                    },
+                    { locationName: "westus", failoverPriority: 1 },
+                ],
+            };
+            const cosmos = new cosmos_db_1.CosmosDbAccount(stack, "TestCosmos", props);
+            expect(cosmos.props.enableAutomaticFailover).toBe(true);
+            expect(cosmos.props.geoLocations).toHaveLength(2);
+        });
+    });
+    describe("capabilities", () => {
+        it("should configure serverless capability", () => {
+            const rg = new azure_resourcegroup_1.ResourceGroup(stack, "TestRG", {
+                name: "test-rg",
+                location: "eastus",
+            });
+            const props = {
+                name: "testcosmosserverless",
+                location: "eastus",
+                resourceGroupId: rg.id,
+                capabilities: [{ name: "EnableServerless" }],
+            };
+            const cosmos = new cosmos_db_1.CosmosDbAccount(stack, "TestCosmos", props);
+            expect(cosmos.props.capabilities).toEqual([{ name: "EnableServerless" }]);
+        });
+    });
+    describe("tag management", () => {
+        let cosmos;
+        beforeEach(() => {
+            const rg = new azure_resourcegroup_1.ResourceGroup(stack, "TestRG", {
+                name: "test-rg",
+                location: "eastus",
+            });
+            const props = {
+                name: "testcosmostags",
+                location: "eastus",
+                resourceGroupId: rg.id,
+                tags: {
+                    environment: "test",
+                },
+            };
+            cosmos = new cosmos_db_1.CosmosDbAccount(stack, "TestCosmos", props);
+        });
+        it("should add a tag", () => {
+            cosmos.addTag("newTag", "newValue");
+            expect(cosmos.props.tags.newTag).toBe("newValue");
+            expect(cosmos.props.tags.environment).toBe("test");
+        });
+        it("should remove an existing tag", () => {
+            cosmos.removeTag("environment");
+            expect(cosmos.props.tags.environment).toBeUndefined();
+        });
+        it("should add a tag when no tags exist", () => {
+            const rg = new azure_resourcegroup_1.ResourceGroup(stack, "TestRG2", {
+                name: "test-rg2",
+                location: "eastus",
+            });
+            const props = {
+                name: "testcosmosnotags",
+                location: "eastus",
+                resourceGroupId: rg.id,
+            };
+            const c = new cosmos_db_1.CosmosDbAccount(stack, "TestCosmosNoTags", props);
+            c.addTag("firstTag", "firstValue");
+            expect(c.props.tags.firstTag).toBe("firstValue");
+        });
+    });
+    describe("API versioning", () => {
+        it("should use default version when not specified", () => {
+            const rg = new azure_resourcegroup_1.ResourceGroup(stack, "TestRG", {
+                name: "test-rg",
+                location: "eastus",
+            });
+            const props = {
+                name: "testcosmosdefault",
+                location: "eastus",
+                resourceGroupId: rg.id,
+            };
+            const cosmos = new cosmos_db_1.CosmosDbAccount(stack, "TestCosmos", props);
+            expect(cosmos).toBeInstanceOf(cosmos_db_1.CosmosDbAccount);
+        });
+        it("should accept specific API version", () => {
+            const rg = new azure_resourcegroup_1.ResourceGroup(stack, "TestRG", {
+                name: "test-rg",
+                location: "eastus",
+            });
+            const props = {
+                name: "testcosmosversioned",
+                location: "eastus",
+                resourceGroupId: rg.id,
+                apiVersion: "2024-05-15",
+            };
+            const cosmos = new cosmos_db_1.CosmosDbAccount(stack, "TestCosmos", props);
+            expect(cosmos.props.apiVersion).toBe("2024-05-15");
+        });
+    });
+    describe("CDK Terraform integration", () => {
+        it("should synthesize to valid Terraform", () => {
+            const rg = new azure_resourcegroup_1.ResourceGroup(stack, "TestRG", {
+                name: "test-rg",
+                location: "eastus",
+            });
+            const props = {
+                name: "testcosmossynth",
+                location: "eastus",
+                resourceGroupId: rg.id,
+                tags: {
+                    environment: "test",
+                },
+            };
+            new cosmos_db_1.CosmosDbAccount(stack, "TestCosmos", props);
+            const synthesized = cdktf_1.Testing.synth(stack);
+            expect(synthesized).toBeDefined();
+            const stackConfig = JSON.parse(synthesized);
+            expect(stackConfig.resource).toBeDefined();
+        });
+        it("should have correct logical IDs for outputs", () => {
+            const rg = new azure_resourcegroup_1.ResourceGroup(stack, "TestRG", {
+                name: "test-rg",
+                location: "eastus",
+            });
+            const props = {
+                name: "testcosmoslogical",
+                location: "eastus",
+                resourceGroupId: rg.id,
+            };
+            const cosmos = new cosmos_db_1.CosmosDbAccount(stack, "TestCosmos", props);
+            expect(cosmos.idOutput).toBeDefined();
+            expect(cosmos.locationOutput).toBeDefined();
+            expect(cosmos.nameOutput).toBeDefined();
+            expect(cosmos.tagsOutput).toBeDefined();
+            expect(cosmos.documentEndpointOutput).toBeDefined();
+        });
+    });
+    describe("endpoint properties", () => {
+        it("should provide document endpoint", () => {
+            const rg = new azure_resourcegroup_1.ResourceGroup(stack, "TestRG", {
+                name: "test-rg",
+                location: "eastus",
+            });
+            const props = {
+                name: "testcosmosendpoint",
+                location: "eastus",
+                resourceGroupId: rg.id,
+            };
+            const cosmos = new cosmos_db_1.CosmosDbAccount(stack, "TestCosmos", props);
+            expect(cosmos.documentEndpoint).toBeDefined();
+            expect(cosmos.documentEndpoint).toContain("documentEndpoint");
+        });
+    });
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"cosmos-db.spec.js","sourceRoot":"","sources":["../../../src/azure-cosmosdb/test/cosmos-db.spec.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Unit tests for Azure Cosmos DB Account using VersionedAzapiResource framework\n */\n\nimport { Testing } from \"cdktf\";\nimport * as cdktf from \"cdktf\";\nimport { ResourceGroup } from \"../../azure-resourcegroup\";\nimport { CosmosDbAccount, CosmosDbAccountProps } from \"../lib/cosmos-db\";\n\ndescribe(\"CosmosDbAccount\", () => {\n  let app: cdktf.App;\n  let stack: cdktf.TerraformStack;\n\n  beforeEach(() => {\n    app = Testing.app();\n    stack = new cdktf.TerraformStack(app, \"TestStack\");\n  });\n\n  describe(\"constructor\", () => {\n    it(\"should create a cosmos db account with required properties\", () => {\n      const rg = new ResourceGroup(stack, \"TestRG\", {\n        name: \"test-rg\",\n        location: \"eastus\",\n      });\n\n      const props: CosmosDbAccountProps = {\n        name: \"testcosmosaccount\",\n        location: \"eastus\",\n        resourceGroupId: rg.id,\n      };\n\n      const cosmos = new CosmosDbAccount(stack, \"TestCosmos\", props);\n\n      expect(cosmos).toBeInstanceOf(CosmosDbAccount);\n      expect(cosmos.props).toBe(props);\n    });\n\n    it(\"should create a cosmos db account with all properties\", () => {\n      const rg = new ResourceGroup(stack, \"TestRG\", {\n        name: \"test-rg\",\n        location: \"eastus\",\n      });\n\n      const props: CosmosDbAccountProps = {\n        name: \"testcosmosaccount\",\n        location: \"eastus\",\n        resourceGroupId: rg.id,\n        kind: \"GlobalDocumentDB\",\n        consistencyPolicy: {\n          defaultConsistencyLevel: \"Strong\",\n        },\n        capabilities: [{ name: \"EnableServerless\" }],\n        publicNetworkAccess: \"Enabled\",\n        enableAutomaticFailover: false,\n        minimalTlsVersion: \"Tls12\",\n        tags: {\n          environment: \"test\",\n          project: \"cdktf-constructs\",\n        },\n        identity: {\n          type: \"SystemAssigned\",\n        },\n      };\n\n      const cosmos = new CosmosDbAccount(stack, \"TestCosmos\", props);\n\n      expect(cosmos.props).toBe(props);\n      expect(cosmos.tags).toEqual(props.tags);\n    });\n\n    it(\"should use default values for optional properties\", () => {\n      const rg = new ResourceGroup(stack, \"TestRG\", {\n        name: \"test-rg\",\n        location: \"eastus\",\n      });\n\n      const props: CosmosDbAccountProps = {\n        name: \"testcosmosaccount\",\n        location: \"eastus\",\n        resourceGroupId: rg.id,\n      };\n\n      const cosmos = new CosmosDbAccount(stack, \"TestCosmos\", props);\n\n      expect(cosmos).toBeInstanceOf(CosmosDbAccount);\n    });\n\n    it(\"should create terraform outputs\", () => {\n      const rg = new ResourceGroup(stack, \"TestRG\", {\n        name: \"test-rg\",\n        location: \"eastus\",\n      });\n\n      const props: CosmosDbAccountProps = {\n        name: \"testcosmosaccount\",\n        location: \"eastus\",\n        resourceGroupId: rg.id,\n      };\n\n      const cosmos = new CosmosDbAccount(stack, \"TestCosmos\", props);\n\n      expect(cosmos.idOutput).toBeInstanceOf(cdktf.TerraformOutput);\n      expect(cosmos.locationOutput).toBeInstanceOf(cdktf.TerraformOutput);\n      expect(cosmos.nameOutput).toBeInstanceOf(cdktf.TerraformOutput);\n      expect(cosmos.tagsOutput).toBeInstanceOf(cdktf.TerraformOutput);\n      expect(cosmos.documentEndpointOutput).toBeInstanceOf(\n        cdktf.TerraformOutput,\n      );\n    });\n  });\n\n  describe(\"kind configuration\", () => {\n    it(\"should accept GlobalDocumentDB kind\", () => {\n      const rg = new ResourceGroup(stack, \"TestRG\", {\n        name: \"test-rg\",\n        location: \"eastus\",\n      });\n\n      const props: CosmosDbAccountProps = {\n        name: \"testcosmosaccount\",\n        location: \"eastus\",\n        resourceGroupId: rg.id,\n        kind: \"GlobalDocumentDB\",\n      };\n\n      const cosmos = new CosmosDbAccount(stack, \"TestCosmos\", props);\n\n      expect(cosmos.props.kind).toBe(\"GlobalDocumentDB\");\n    });\n\n    it(\"should accept MongoDB kind\", () => {\n      const rg = new ResourceGroup(stack, \"TestRG\", {\n        name: \"test-rg\",\n        location: \"eastus\",\n      });\n\n      const props: CosmosDbAccountProps = {\n        name: \"testcosmosmongo\",\n        location: \"eastus\",\n        resourceGroupId: rg.id,\n        kind: \"MongoDB\",\n        capabilities: [{ name: \"EnableMongo\" }],\n      };\n\n      const cosmos = new CosmosDbAccount(stack, \"TestCosmos\", props);\n\n      expect(cosmos.props.kind).toBe(\"MongoDB\");\n    });\n  });\n\n  describe(\"consistency policy\", () => {\n    it(\"should configure Session consistency by default when none provided\", () => {\n      const rg = new ResourceGroup(stack, \"TestRG\", {\n        name: \"test-rg\",\n        location: \"eastus\",\n      });\n\n      const props: CosmosDbAccountProps = {\n        name: \"testcosmosconsistency\",\n        location: \"eastus\",\n        resourceGroupId: rg.id,\n      };\n\n      const cosmos = new CosmosDbAccount(stack, \"TestCosmos\", props);\n\n      expect(cosmos).toBeInstanceOf(CosmosDbAccount);\n    });\n\n    it(\"should configure Strong consistency when specified\", () => {\n      const rg = new ResourceGroup(stack, \"TestRG\", {\n        name: \"test-rg\",\n        location: \"eastus\",\n      });\n\n      const props: CosmosDbAccountProps = {\n        name: \"testcosmosstrong\",\n        location: \"eastus\",\n        resourceGroupId: rg.id,\n        consistencyPolicy: {\n          defaultConsistencyLevel: \"Strong\",\n        },\n      };\n\n      const cosmos = new CosmosDbAccount(stack, \"TestCosmos\", props);\n\n      expect(cosmos.props.consistencyPolicy?.defaultConsistencyLevel).toBe(\n        \"Strong\",\n      );\n    });\n\n    it(\"should configure BoundedStaleness consistency\", () => {\n      const rg = new ResourceGroup(stack, \"TestRG\", {\n        name: \"test-rg\",\n        location: \"eastus\",\n      });\n\n      const props: CosmosDbAccountProps = {\n        name: \"testcosmosbounded\",\n        location: \"eastus\",\n        resourceGroupId: rg.id,\n        consistencyPolicy: {\n          defaultConsistencyLevel: \"BoundedStaleness\",\n          maxIntervalInSeconds: 86400,\n          maxStalenessPrefix: 1000000,\n        },\n      };\n\n      const cosmos = new CosmosDbAccount(stack, \"TestCosmos\", props);\n\n      expect(cosmos.props.consistencyPolicy?.defaultConsistencyLevel).toBe(\n        \"BoundedStaleness\",\n      );\n      expect(cosmos.props.consistencyPolicy?.maxIntervalInSeconds).toBe(86400);\n    });\n  });\n\n  describe(\"multi-region configuration\", () => {\n    it(\"should configure multiple geo locations with failover\", () => {\n      const rg = new ResourceGroup(stack, \"TestRG\", {\n        name: \"test-rg\",\n        location: \"eastus\",\n      });\n\n      const props: CosmosDbAccountProps = {\n        name: \"testcosmosgeo\",\n        location: \"eastus\",\n        resourceGroupId: rg.id,\n        enableAutomaticFailover: true,\n        geoLocations: [\n          {\n            locationName: \"eastus\",\n            failoverPriority: 0,\n            isZoneRedundant: true,\n          },\n          { locationName: \"westus\", failoverPriority: 1 },\n        ],\n      };\n\n      const cosmos = new CosmosDbAccount(stack, \"TestCosmos\", props);\n\n      expect(cosmos.props.enableAutomaticFailover).toBe(true);\n      expect(cosmos.props.geoLocations).toHaveLength(2);\n    });\n  });\n\n  describe(\"capabilities\", () => {\n    it(\"should configure serverless capability\", () => {\n      const rg = new ResourceGroup(stack, \"TestRG\", {\n        name: \"test-rg\",\n        location: \"eastus\",\n      });\n\n      const props: CosmosDbAccountProps = {\n        name: \"testcosmosserverless\",\n        location: \"eastus\",\n        resourceGroupId: rg.id,\n        capabilities: [{ name: \"EnableServerless\" }],\n      };\n\n      const cosmos = new CosmosDbAccount(stack, \"TestCosmos\", props);\n\n      expect(cosmos.props.capabilities).toEqual([{ name: \"EnableServerless\" }]);\n    });\n  });\n\n  describe(\"tag management\", () => {\n    let cosmos: CosmosDbAccount;\n\n    beforeEach(() => {\n      const rg = new ResourceGroup(stack, \"TestRG\", {\n        name: \"test-rg\",\n        location: \"eastus\",\n      });\n\n      const props: CosmosDbAccountProps = {\n        name: \"testcosmostags\",\n        location: \"eastus\",\n        resourceGroupId: rg.id,\n        tags: {\n          environment: \"test\",\n        },\n      };\n\n      cosmos = new CosmosDbAccount(stack, \"TestCosmos\", props);\n    });\n\n    it(\"should add a tag\", () => {\n      cosmos.addTag(\"newTag\", \"newValue\");\n\n      expect(cosmos.props.tags!.newTag).toBe(\"newValue\");\n      expect(cosmos.props.tags!.environment).toBe(\"test\");\n    });\n\n    it(\"should remove an existing tag\", () => {\n      cosmos.removeTag(\"environment\");\n\n      expect(cosmos.props.tags!.environment).toBeUndefined();\n    });\n\n    it(\"should add a tag when no tags exist\", () => {\n      const rg = new ResourceGroup(stack, \"TestRG2\", {\n        name: \"test-rg2\",\n        location: \"eastus\",\n      });\n\n      const props: CosmosDbAccountProps = {\n        name: \"testcosmosnotags\",\n        location: \"eastus\",\n        resourceGroupId: rg.id,\n      };\n\n      const c = new CosmosDbAccount(stack, \"TestCosmosNoTags\", props);\n      c.addTag(\"firstTag\", \"firstValue\");\n\n      expect(c.props.tags!.firstTag).toBe(\"firstValue\");\n    });\n  });\n\n  describe(\"API versioning\", () => {\n    it(\"should use default version when not specified\", () => {\n      const rg = new ResourceGroup(stack, \"TestRG\", {\n        name: \"test-rg\",\n        location: \"eastus\",\n      });\n\n      const props: CosmosDbAccountProps = {\n        name: \"testcosmosdefault\",\n        location: \"eastus\",\n        resourceGroupId: rg.id,\n      };\n\n      const cosmos = new CosmosDbAccount(stack, \"TestCosmos\", props);\n\n      expect(cosmos).toBeInstanceOf(CosmosDbAccount);\n    });\n\n    it(\"should accept specific API version\", () => {\n      const rg = new ResourceGroup(stack, \"TestRG\", {\n        name: \"test-rg\",\n        location: \"eastus\",\n      });\n\n      const props: CosmosDbAccountProps = {\n        name: \"testcosmosversioned\",\n        location: \"eastus\",\n        resourceGroupId: rg.id,\n        apiVersion: \"2024-05-15\",\n      };\n\n      const cosmos = new CosmosDbAccount(stack, \"TestCosmos\", props);\n\n      expect(cosmos.props.apiVersion).toBe(\"2024-05-15\");\n    });\n  });\n\n  describe(\"CDK Terraform integration\", () => {\n    it(\"should synthesize to valid Terraform\", () => {\n      const rg = new ResourceGroup(stack, \"TestRG\", {\n        name: \"test-rg\",\n        location: \"eastus\",\n      });\n\n      const props: CosmosDbAccountProps = {\n        name: \"testcosmossynth\",\n        location: \"eastus\",\n        resourceGroupId: rg.id,\n        tags: {\n          environment: \"test\",\n        },\n      };\n\n      new CosmosDbAccount(stack, \"TestCosmos\", props);\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 have correct logical IDs for outputs\", () => {\n      const rg = new ResourceGroup(stack, \"TestRG\", {\n        name: \"test-rg\",\n        location: \"eastus\",\n      });\n\n      const props: CosmosDbAccountProps = {\n        name: \"testcosmoslogical\",\n        location: \"eastus\",\n        resourceGroupId: rg.id,\n      };\n\n      const cosmos = new CosmosDbAccount(stack, \"TestCosmos\", props);\n\n      expect(cosmos.idOutput).toBeDefined();\n      expect(cosmos.locationOutput).toBeDefined();\n      expect(cosmos.nameOutput).toBeDefined();\n      expect(cosmos.tagsOutput).toBeDefined();\n      expect(cosmos.documentEndpointOutput).toBeDefined();\n    });\n  });\n\n  describe(\"endpoint properties\", () => {\n    it(\"should provide document endpoint\", () => {\n      const rg = new ResourceGroup(stack, \"TestRG\", {\n        name: \"test-rg\",\n        location: \"eastus\",\n      });\n\n      const props: CosmosDbAccountProps = {\n        name: \"testcosmosendpoint\",\n        location: \"eastus\",\n        resourceGroupId: rg.id,\n      };\n\n      const cosmos = new CosmosDbAccount(stack, \"TestCosmos\", props);\n\n      expect(cosmos.documentEndpoint).toBeDefined();\n      expect(cosmos.documentEndpoint).toContain(\"documentEndpoint\");\n    });\n  });\n});\n"]}

package/lib/azure-diagnosticsettings/lib/diagnostic-settings.js

@@ -167,7 +167,7 @@ class DiagnosticSettings extends azapi_resource_1.AzapiResource {
 }
 exports.DiagnosticSettings = DiagnosticSettings;
 _a = JSII_RTTI_SYMBOL_1;
-DiagnosticSettings[_a] = { fqn: "@microsoft/terraform-cdk-constructs.DiagnosticSettings", version: "1.9.0" };
+DiagnosticSettings[_a] = { fqn: "@microsoft/terraform-cdk-constructs.DiagnosticSettings", version: "1.10.0" };
 (() => {
     azapi_resource_1.AzapiResource.registerSchemas(diagnostic_settings_schemas_1.DIAGNOSTIC_SETTINGS_TYPE, diagnostic_settings_schemas_1.ALL_DIAGNOSTIC_SETTINGS_VERSIONS);
 })();

package/lib/azure-dnsforwardingruleset/lib/dns-forwarding-ruleset.js

@@ -207,7 +207,7 @@ class DnsForwardingRuleset extends azapi_resource_1.AzapiResource {
 }
 exports.DnsForwardingRuleset = DnsForwardingRuleset;
 _a = JSII_RTTI_SYMBOL_1;
-DnsForwardingRuleset[_a] = { fqn: "@microsoft/terraform-cdk-constructs.DnsForwardingRuleset", version: "1.9.0" };
+DnsForwardingRuleset[_a] = { fqn: "@microsoft/terraform-cdk-constructs.DnsForwardingRuleset", version: "1.10.0" };
 (() => {
     azapi_resource_1.AzapiResource.registerSchemas(dns_forwarding_ruleset_schemas_1.DNS_FORWARDING_RULESET_TYPE, dns_forwarding_ruleset_schemas_1.ALL_DNS_FORWARDING_RULESET_VERSIONS);
 })();

package/lib/azure-dnsforwardingruleset/lib/forwarding-rule.js

@@ -186,7 +186,7 @@ class ForwardingRule extends azapi_resource_1.AzapiResource {
 }
 exports.ForwardingRule = ForwardingRule;
 _a = JSII_RTTI_SYMBOL_1;
-ForwardingRule[_a] = { fqn: "@microsoft/terraform-cdk-constructs.ForwardingRule", version: "1.9.0" };
+ForwardingRule[_a] = { fqn: "@microsoft/terraform-cdk-constructs.ForwardingRule", version: "1.10.0" };
 (() => {
     azapi_resource_1.AzapiResource.registerSchemas(forwarding_rule_schemas_1.FORWARDING_RULE_TYPE, forwarding_rule_schemas_1.ALL_FORWARDING_RULE_VERSIONS);
 })();

package/lib/azure-dnsforwardingruleset/lib/virtual-network-link.js

@@ -171,7 +171,7 @@ class DnsForwardingRulesetVirtualNetworkLink extends azapi_resource_1.AzapiResou
 }
 exports.DnsForwardingRulesetVirtualNetworkLink = DnsForwardingRulesetVirtualNetworkLink;
 _a = JSII_RTTI_SYMBOL_1;
-DnsForwardingRulesetVirtualNetworkLink[_a] = { fqn: "@microsoft/terraform-cdk-constructs.DnsForwardingRulesetVirtualNetworkLink", version: "1.9.0" };
+DnsForwardingRulesetVirtualNetworkLink[_a] = { fqn: "@microsoft/terraform-cdk-constructs.DnsForwardingRulesetVirtualNetworkLink", version: "1.10.0" };
 (() => {
     azapi_resource_1.AzapiResource.registerSchemas(virtual_network_link_schemas_1.VIRTUAL_NETWORK_LINK_TYPE, virtual_network_link_schemas_1.ALL_VIRTUAL_NETWORK_LINK_VERSIONS);
 })();

package/lib/azure-dnsresolver/lib/dns-resolver.js

@@ -229,7 +229,7 @@ class DnsResolver extends azapi_resource_1.AzapiResource {
 }
 exports.DnsResolver = DnsResolver;
 _a = JSII_RTTI_SYMBOL_1;
-DnsResolver[_a] = { fqn: "@microsoft/terraform-cdk-constructs.DnsResolver", version: "1.9.0" };
+DnsResolver[_a] = { fqn: "@microsoft/terraform-cdk-constructs.DnsResolver", version: "1.10.0" };
 (() => {
     azapi_resource_1.AzapiResource.registerSchemas(dns_resolver_schemas_1.DNS_RESOLVER_TYPE, dns_resolver_schemas_1.ALL_DNS_RESOLVER_VERSIONS);
 })();

package/lib/azure-dnsresolver/lib/inbound-endpoint.js

@@ -236,7 +236,7 @@ class DnsResolverInboundEndpoint extends azapi_resource_1.AzapiResource {
 }
 exports.DnsResolverInboundEndpoint = DnsResolverInboundEndpoint;
 _a = JSII_RTTI_SYMBOL_1;
-DnsResolverInboundEndpoint[_a] = { fqn: "@microsoft/terraform-cdk-constructs.DnsResolverInboundEndpoint", version: "1.9.0" };
+DnsResolverInboundEndpoint[_a] = { fqn: "@microsoft/terraform-cdk-constructs.DnsResolverInboundEndpoint", version: "1.10.0" };
 (() => {
     azapi_resource_1.AzapiResource.registerSchemas(inbound_endpoint_schemas_1.DNS_RESOLVER_INBOUND_ENDPOINT_TYPE, inbound_endpoint_schemas_1.ALL_DNS_RESOLVER_INBOUND_ENDPOINT_VERSIONS);
 })();

package/lib/azure-dnsresolver/lib/outbound-endpoint.js

@@ -227,7 +227,7 @@ class DnsResolverOutboundEndpoint extends azapi_resource_1.AzapiResource {
 }
 exports.DnsResolverOutboundEndpoint = DnsResolverOutboundEndpoint;
 _a = JSII_RTTI_SYMBOL_1;
-DnsResolverOutboundEndpoint[_a] = { fqn: "@microsoft/terraform-cdk-constructs.DnsResolverOutboundEndpoint", version: "1.9.0" };
+DnsResolverOutboundEndpoint[_a] = { fqn: "@microsoft/terraform-cdk-constructs.DnsResolverOutboundEndpoint", version: "1.10.0" };
 (() => {
     azapi_resource_1.AzapiResource.registerSchemas(outbound_endpoint_schemas_1.DNS_RESOLVER_OUTBOUND_ENDPOINT_TYPE, outbound_endpoint_schemas_1.ALL_DNS_RESOLVER_OUTBOUND_ENDPOINT_VERSIONS);
 })();

package/lib/azure-dnszone/lib/dns-zone.js

@@ -221,7 +221,7 @@ class DnsZone extends azapi_resource_1.AzapiResource {
 }
 exports.DnsZone = DnsZone;
 _a = JSII_RTTI_SYMBOL_1;
-DnsZone[_a] = { fqn: "@microsoft/terraform-cdk-constructs.DnsZone", version: "1.9.0" };
+DnsZone[_a] = { fqn: "@microsoft/terraform-cdk-constructs.DnsZone", version: "1.10.0" };
 (() => {
     azapi_resource_1.AzapiResource.registerSchemas(dns_zone_schemas_1.DNS_ZONE_TYPE, dns_zone_schemas_1.ALL_DNS_ZONE_VERSIONS);
 })();