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

package/lib/azure-virtualnetwork/test/virtual-network.spec.js

@@ -0,0 +1,398 @@
+"use strict";
+/**
+ * Comprehensive tests for the Virtual Network implementation
+ *
+ * This test suite validates the VirtualNetwork class using the AzapiResource framework.
+ * Tests cover automatic version resolution, explicit version pinning, schema validation,
+ * property transformation, and resource creation.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const cdktf_1 = require("cdktf");
+const cdktf = require("cdktf");
+const virtual_network_1 = require("../lib/virtual-network");
+describe("VirtualNetwork - Implementation", () => {
+    let app;
+    let stack;
+    beforeEach(() => {
+        app = cdktf_1.Testing.app();
+        stack = new cdktf.TerraformStack(app, "TestStack");
+    });
+    describe("Constructor and Basic Properties", () => {
+        it("should create virtual network with automatic latest version resolution", () => {
+            const props = {
+                name: "test-vnet",
+                location: "eastus",
+                addressSpace: {
+                    addressPrefixes: ["10.0.0.0/16"],
+                },
+            };
+            const vnet = new virtual_network_1.VirtualNetwork(stack, "TestVNet", props);
+            expect(vnet).toBeInstanceOf(virtual_network_1.VirtualNetwork);
+            expect(vnet.props).toBe(props);
+            expect(vnet.name).toBe("test-vnet");
+            expect(vnet.location).toBe("eastus");
+        });
+        it("should create virtual network with explicit version pinning", () => {
+            const props = {
+                name: "test-vnet-pinned",
+                location: "westus",
+                apiVersion: "2024-07-01",
+                addressSpace: {
+                    addressPrefixes: ["10.0.0.0/16"],
+                },
+                tags: { environment: "test" },
+            };
+            const vnet = new virtual_network_1.VirtualNetwork(stack, "TestVNet", props);
+            expect(vnet.resolvedApiVersion).toBe("2024-07-01");
+            expect(vnet.tags).toEqual({ environment: "test" });
+        });
+        it("should create virtual network with all optional properties", () => {
+            const props = {
+                name: "test-vnet-full",
+                location: "centralus",
+                addressSpace: {
+                    addressPrefixes: ["10.0.0.0/16", "10.1.0.0/16"],
+                },
+                dhcpOptions: {
+                    dnsServers: ["10.0.0.4", "10.0.0.5"],
+                },
+                enableDdosProtection: false,
+                enableVmProtection: false,
+                flowTimeoutInMinutes: 20,
+                tags: {
+                    environment: "production",
+                    project: "networking",
+                    owner: "team@company.com",
+                },
+                ignoreChanges: ["tags"],
+            };
+            const vnet = new virtual_network_1.VirtualNetwork(stack, "TestVNet", props);
+            expect(vnet.props.addressSpace).toEqual(props.addressSpace);
+            expect(vnet.props.dhcpOptions).toEqual(props.dhcpOptions);
+            expect(vnet.props.tags).toEqual(props.tags);
+        });
+        it("should use default name when name is not provided", () => {
+            const props = {
+                location: "eastus",
+                addressSpace: {
+                    addressPrefixes: ["10.0.0.0/16"],
+                },
+            };
+            const vnet = new virtual_network_1.VirtualNetwork(stack, "TestVNet", props);
+            expect(vnet.name).toBe("TestVNet");
+        });
+    });
+    describe("Resource Type and API Versions", () => {
+        it("should have correct resource type", () => {
+            const vnet = new virtual_network_1.VirtualNetwork(stack, "TestVNet", {
+                name: "test-vnet",
+                location: "eastus",
+                addressSpace: {
+                    addressPrefixes: ["10.0.0.0/16"],
+                },
+            });
+            // VirtualNetwork should be an instance of VirtualNetwork
+            expect(vnet).toBeInstanceOf(virtual_network_1.VirtualNetwork);
+        });
+        it("should support all registered API versions", () => {
+            const versions = ["2024-07-01", "2024-10-01"];
+            versions.forEach((version) => {
+                const vnet = new virtual_network_1.VirtualNetwork(stack, `VNet-${version.replace(/-/g, "")}`, {
+                    name: `vnet-${version}`,
+                    location: "eastus",
+                    apiVersion: version,
+                    addressSpace: {
+                        addressPrefixes: ["10.0.0.0/16"],
+                    },
+                });
+                expect(vnet.resolvedApiVersion).toBe(version);
+            });
+        });
+        it("should use latest version as default", () => {
+            const vnet = new virtual_network_1.VirtualNetwork(stack, "TestVNet", {
+                name: "test-vnet",
+                location: "eastus",
+                addressSpace: {
+                    addressPrefixes: ["10.0.0.0/16"],
+                },
+            });
+            expect(vnet.resolvedApiVersion).toBe("2024-10-01");
+        });
+    });
+    describe("Address Space Configuration", () => {
+        it("should create VNet with single address prefix", () => {
+            const vnet = new virtual_network_1.VirtualNetwork(stack, "SinglePrefix", {
+                name: "vnet-single",
+                location: "eastus",
+                addressSpace: {
+                    addressPrefixes: ["10.0.0.0/16"],
+                },
+            });
+            expect(vnet.props.addressSpace.addressPrefixes).toHaveLength(1);
+            expect(vnet.props.addressSpace.addressPrefixes[0]).toBe("10.0.0.0/16");
+        });
+        it("should create VNet with multiple address prefixes", () => {
+            const vnet = new virtual_network_1.VirtualNetwork(stack, "MultiPrefix", {
+                name: "vnet-multi",
+                location: "eastus",
+                addressSpace: {
+                    addressPrefixes: ["10.0.0.0/16", "10.1.0.0/16", "10.2.0.0/16"],
+                },
+            });
+            expect(vnet.props.addressSpace.addressPrefixes).toHaveLength(3);
+        });
+    });
+    describe("DHCP Options Configuration", () => {
+        it("should create VNet with custom DNS servers", () => {
+            const vnet = new virtual_network_1.VirtualNetwork(stack, "CustomDNS", {
+                name: "vnet-dns",
+                location: "eastus",
+                addressSpace: {
+                    addressPrefixes: ["10.0.0.0/16"],
+                },
+                dhcpOptions: {
+                    dnsServers: ["8.8.8.8", "8.8.4.4"],
+                },
+            });
+            expect(vnet.props.dhcpOptions).toBeDefined();
+            expect(vnet.props.dhcpOptions?.dnsServers).toEqual([
+                "8.8.8.8",
+                "8.8.4.4",
+            ]);
+        });
+        it("should create VNet without DHCP options", () => {
+            const vnet = new virtual_network_1.VirtualNetwork(stack, "NoDHCP", {
+                name: "vnet-no-dhcp",
+                location: "eastus",
+                addressSpace: {
+                    addressPrefixes: ["10.0.0.0/16"],
+                },
+            });
+            expect(vnet.props.dhcpOptions).toBeUndefined();
+        });
+    });
+    describe("Protection Features", () => {
+        it("should create VNet with DDoS protection enabled", () => {
+            const vnet = new virtual_network_1.VirtualNetwork(stack, "DDoSProtection", {
+                name: "vnet-ddos",
+                location: "eastus",
+                addressSpace: {
+                    addressPrefixes: ["10.0.0.0/16"],
+                },
+                enableDdosProtection: true,
+            });
+            expect(vnet.props.enableDdosProtection).toBe(true);
+        });
+        it("should create VNet with VM protection enabled", () => {
+            const vnet = new virtual_network_1.VirtualNetwork(stack, "VMProtection", {
+                name: "vnet-vm-protection",
+                location: "eastus",
+                addressSpace: {
+                    addressPrefixes: ["10.0.0.0/16"],
+                },
+                enableVmProtection: true,
+            });
+            expect(vnet.props.enableVmProtection).toBe(true);
+        });
+        it("should default protection features to false", () => {
+            const vnet = new virtual_network_1.VirtualNetwork(stack, "DefaultProtection", {
+                name: "vnet-default",
+                location: "eastus",
+                addressSpace: {
+                    addressPrefixes: ["10.0.0.0/16"],
+                },
+            });
+            expect(vnet.props.enableDdosProtection).toBeUndefined();
+            expect(vnet.props.enableVmProtection).toBeUndefined();
+        });
+    });
+    describe("Tags Management", () => {
+        it("should create VNet with tags", () => {
+            const vnet = new virtual_network_1.VirtualNetwork(stack, "TaggedVNet", {
+                name: "vnet-tagged",
+                location: "eastus",
+                addressSpace: {
+                    addressPrefixes: ["10.0.0.0/16"],
+                },
+                tags: {
+                    environment: "production",
+                    cost_center: "engineering",
+                },
+            });
+            expect(vnet.props.tags).toEqual({
+                environment: "production",
+                cost_center: "engineering",
+            });
+        });
+        it("should support adding tags", () => {
+            const vnet = new virtual_network_1.VirtualNetwork(stack, "AddTag", {
+                name: "vnet-add-tag",
+                location: "eastus",
+                addressSpace: {
+                    addressPrefixes: ["10.0.0.0/16"],
+                },
+                tags: { environment: "test" },
+            });
+            vnet.addTag("newTag", "newValue");
+            expect(vnet.props.tags.newTag).toBe("newValue");
+            expect(vnet.props.tags.environment).toBe("test");
+        });
+        it("should support removing tags", () => {
+            const vnet = new virtual_network_1.VirtualNetwork(stack, "RemoveTag", {
+                name: "vnet-remove-tag",
+                location: "eastus",
+                addressSpace: {
+                    addressPrefixes: ["10.0.0.0/16"],
+                },
+                tags: {
+                    environment: "test",
+                    temporary: "true",
+                },
+            });
+            vnet.removeTag("temporary");
+            expect(vnet.props.tags.temporary).toBeUndefined();
+            expect(vnet.props.tags.environment).toBe("test");
+        });
+    });
+    describe("Terraform Outputs", () => {
+        it("should create Terraform outputs", () => {
+            const vnet = new virtual_network_1.VirtualNetwork(stack, "OutputTest", {
+                name: "vnet-outputs",
+                location: "eastus",
+                addressSpace: {
+                    addressPrefixes: ["10.0.0.0/16"],
+                },
+            });
+            expect(vnet.idOutput).toBeInstanceOf(cdktf.TerraformOutput);
+            expect(vnet.nameOutput).toBeInstanceOf(cdktf.TerraformOutput);
+            expect(vnet.locationOutput).toBeInstanceOf(cdktf.TerraformOutput);
+            expect(vnet.addressSpaceOutput).toBeInstanceOf(cdktf.TerraformOutput);
+            expect(vnet.tagsOutput).toBeInstanceOf(cdktf.TerraformOutput);
+        });
+        it("should have correct id format", () => {
+            const vnet = new virtual_network_1.VirtualNetwork(stack, "IdFormat", {
+                name: "vnet-id",
+                location: "eastus",
+                addressSpace: {
+                    addressPrefixes: ["10.0.0.0/16"],
+                },
+            });
+            expect(vnet.id).toMatch(/^\$\{.*\.id\}$/);
+            expect(vnet.resourceId).toBe(vnet.id);
+        });
+    });
+    describe("Version Compatibility", () => {
+        it("should work with all supported API versions", () => {
+            const versions = ["2024-07-01", "2024-10-01"];
+            versions.forEach((version) => {
+                const vnet = new virtual_network_1.VirtualNetwork(stack, `VNet-${version.replace(/-/g, "")}`, {
+                    name: `vnet-${version}`,
+                    location: "eastus",
+                    apiVersion: version,
+                    addressSpace: {
+                        addressPrefixes: ["10.0.0.0/16"],
+                    },
+                });
+                expect(vnet.resolvedApiVersion).toBe(version);
+            });
+        });
+    });
+    describe("Ignore Changes Configuration", () => {
+        it("should apply ignore changes lifecycle rules", () => {
+            const vnet = new virtual_network_1.VirtualNetwork(stack, "IgnoreChanges", {
+                name: "vnet-ignore",
+                location: "eastus",
+                addressSpace: {
+                    addressPrefixes: ["10.0.0.0/16"],
+                },
+                ignoreChanges: ["tags", "dhcpOptions"],
+            });
+            expect(vnet).toBeInstanceOf(virtual_network_1.VirtualNetwork);
+            expect(vnet.props.ignoreChanges).toEqual(["tags", "dhcpOptions"]);
+        });
+        it("should handle empty ignore changes array", () => {
+            const vnet = new virtual_network_1.VirtualNetwork(stack, "EmptyIgnore", {
+                name: "vnet-empty-ignore",
+                location: "eastus",
+                addressSpace: {
+                    addressPrefixes: ["10.0.0.0/16"],
+                },
+                ignoreChanges: [],
+            });
+            expect(vnet).toBeInstanceOf(virtual_network_1.VirtualNetwork);
+        });
+    });
+    describe("CDK Terraform Integration", () => {
+        it("should synthesize to valid Terraform configuration", () => {
+            new virtual_network_1.VirtualNetwork(stack, "SynthTest", {
+                name: "vnet-synth",
+                location: "eastus",
+                addressSpace: {
+                    addressPrefixes: ["10.0.0.0/16"],
+                },
+                tags: { test: "synthesis" },
+            });
+            const synthesized = cdktf_1.Testing.synth(stack);
+            expect(synthesized).toBeDefined();
+            const stackConfig = JSON.parse(synthesized);
+            expect(stackConfig.resource).toBeDefined();
+        });
+        it("should handle multiple VNets in the same stack", () => {
+            const vnet1 = new virtual_network_1.VirtualNetwork(stack, "VNet1", {
+                name: "vnet-1",
+                location: "eastus",
+                addressSpace: {
+                    addressPrefixes: ["10.0.0.0/16"],
+                },
+            });
+            const vnet2 = new virtual_network_1.VirtualNetwork(stack, "VNet2", {
+                name: "vnet-2",
+                location: "westus",
+                apiVersion: "2024-07-01",
+                addressSpace: {
+                    addressPrefixes: ["10.1.0.0/16"],
+                },
+            });
+            expect(vnet1.resolvedApiVersion).toBe("2024-10-01");
+            expect(vnet2.resolvedApiVersion).toBe("2024-07-01");
+            const synthesized = cdktf_1.Testing.synth(stack);
+            expect(synthesized).toBeDefined();
+        });
+    });
+    describe("Flow Timeout Configuration", () => {
+        it("should create VNet with flow timeout", () => {
+            const vnet = new virtual_network_1.VirtualNetwork(stack, "FlowTimeout", {
+                name: "vnet-flow-timeout",
+                location: "eastus",
+                addressSpace: {
+                    addressPrefixes: ["10.0.0.0/16"],
+                },
+                flowTimeoutInMinutes: 20,
+            });
+            expect(vnet.props.flowTimeoutInMinutes).toBe(20);
+        });
+    });
+    describe("Subnet Configuration", () => {
+        it("should create VNet with inline subnets", () => {
+            const vnet = new virtual_network_1.VirtualNetwork(stack, "WithSubnets", {
+                name: "vnet-with-subnets",
+                location: "eastus",
+                addressSpace: {
+                    addressPrefixes: ["10.0.0.0/16"],
+                },
+                subnets: [
+                    {
+                        name: "subnet-1",
+                        addressPrefix: "10.0.1.0/24",
+                    },
+                    {
+                        name: "subnet-2",
+                        addressPrefix: "10.0.2.0/24",
+                    },
+                ],
+            });
+            expect(vnet.props.subnets).toHaveLength(2);
+        });
+    });
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"virtual-network.spec.js","sourceRoot":"","sources":["../../../src/azure-virtualnetwork/test/virtual-network.spec.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Comprehensive tests for the Virtual Network implementation\n *\n * This test suite validates the VirtualNetwork class using the AzapiResource framework.\n * Tests cover automatic version resolution, explicit version pinning, schema validation,\n * property transformation, and resource creation.\n */\n\nimport { Testing } from \"cdktf\";\nimport * as cdktf from \"cdktf\";\nimport { VirtualNetwork, VirtualNetworkProps } from \"../lib/virtual-network\";\n\ndescribe(\"VirtualNetwork - Implementation\", () => {\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 and Basic Properties\", () => {\n    it(\"should create virtual network with automatic latest version resolution\", () => {\n      const props: VirtualNetworkProps = {\n        name: \"test-vnet\",\n        location: \"eastus\",\n        addressSpace: {\n          addressPrefixes: [\"10.0.0.0/16\"],\n        },\n      };\n\n      const vnet = new VirtualNetwork(stack, \"TestVNet\", props);\n\n      expect(vnet).toBeInstanceOf(VirtualNetwork);\n      expect(vnet.props).toBe(props);\n      expect(vnet.name).toBe(\"test-vnet\");\n      expect(vnet.location).toBe(\"eastus\");\n    });\n\n    it(\"should create virtual network with explicit version pinning\", () => {\n      const props: VirtualNetworkProps = {\n        name: \"test-vnet-pinned\",\n        location: \"westus\",\n        apiVersion: \"2024-07-01\",\n        addressSpace: {\n          addressPrefixes: [\"10.0.0.0/16\"],\n        },\n        tags: { environment: \"test\" },\n      };\n\n      const vnet = new VirtualNetwork(stack, \"TestVNet\", props);\n\n      expect(vnet.resolvedApiVersion).toBe(\"2024-07-01\");\n      expect(vnet.tags).toEqual({ environment: \"test\" });\n    });\n\n    it(\"should create virtual network with all optional properties\", () => {\n      const props: VirtualNetworkProps = {\n        name: \"test-vnet-full\",\n        location: \"centralus\",\n        addressSpace: {\n          addressPrefixes: [\"10.0.0.0/16\", \"10.1.0.0/16\"],\n        },\n        dhcpOptions: {\n          dnsServers: [\"10.0.0.4\", \"10.0.0.5\"],\n        },\n        enableDdosProtection: false,\n        enableVmProtection: false,\n        flowTimeoutInMinutes: 20,\n        tags: {\n          environment: \"production\",\n          project: \"networking\",\n          owner: \"team@company.com\",\n        },\n        ignoreChanges: [\"tags\"],\n      };\n\n      const vnet = new VirtualNetwork(stack, \"TestVNet\", props);\n\n      expect(vnet.props.addressSpace).toEqual(props.addressSpace);\n      expect(vnet.props.dhcpOptions).toEqual(props.dhcpOptions);\n      expect(vnet.props.tags).toEqual(props.tags);\n    });\n\n    it(\"should use default name when name is not provided\", () => {\n      const props: VirtualNetworkProps = {\n        location: \"eastus\",\n        addressSpace: {\n          addressPrefixes: [\"10.0.0.0/16\"],\n        },\n      };\n\n      const vnet = new VirtualNetwork(stack, \"TestVNet\", props);\n\n      expect(vnet.name).toBe(\"TestVNet\");\n    });\n  });\n\n  describe(\"Resource Type and API Versions\", () => {\n    it(\"should have correct resource type\", () => {\n      const vnet = new VirtualNetwork(stack, \"TestVNet\", {\n        name: \"test-vnet\",\n        location: \"eastus\",\n        addressSpace: {\n          addressPrefixes: [\"10.0.0.0/16\"],\n        },\n      });\n\n      // VirtualNetwork should be an instance of VirtualNetwork\n      expect(vnet).toBeInstanceOf(VirtualNetwork);\n    });\n\n    it(\"should support all registered API versions\", () => {\n      const versions = [\"2024-07-01\", \"2024-10-01\"];\n\n      versions.forEach((version) => {\n        const vnet = new VirtualNetwork(\n          stack,\n          `VNet-${version.replace(/-/g, \"\")}`,\n          {\n            name: `vnet-${version}`,\n            location: \"eastus\",\n            apiVersion: version,\n            addressSpace: {\n              addressPrefixes: [\"10.0.0.0/16\"],\n            },\n          },\n        );\n\n        expect(vnet.resolvedApiVersion).toBe(version);\n      });\n    });\n\n    it(\"should use latest version as default\", () => {\n      const vnet = new VirtualNetwork(stack, \"TestVNet\", {\n        name: \"test-vnet\",\n        location: \"eastus\",\n        addressSpace: {\n          addressPrefixes: [\"10.0.0.0/16\"],\n        },\n      });\n\n      expect(vnet.resolvedApiVersion).toBe(\"2024-10-01\");\n    });\n  });\n\n  describe(\"Address Space Configuration\", () => {\n    it(\"should create VNet with single address prefix\", () => {\n      const vnet = new VirtualNetwork(stack, \"SinglePrefix\", {\n        name: \"vnet-single\",\n        location: \"eastus\",\n        addressSpace: {\n          addressPrefixes: [\"10.0.0.0/16\"],\n        },\n      });\n\n      expect(vnet.props.addressSpace.addressPrefixes).toHaveLength(1);\n      expect(vnet.props.addressSpace.addressPrefixes[0]).toBe(\"10.0.0.0/16\");\n    });\n\n    it(\"should create VNet with multiple address prefixes\", () => {\n      const vnet = new VirtualNetwork(stack, \"MultiPrefix\", {\n        name: \"vnet-multi\",\n        location: \"eastus\",\n        addressSpace: {\n          addressPrefixes: [\"10.0.0.0/16\", \"10.1.0.0/16\", \"10.2.0.0/16\"],\n        },\n      });\n\n      expect(vnet.props.addressSpace.addressPrefixes).toHaveLength(3);\n    });\n  });\n\n  describe(\"DHCP Options Configuration\", () => {\n    it(\"should create VNet with custom DNS servers\", () => {\n      const vnet = new VirtualNetwork(stack, \"CustomDNS\", {\n        name: \"vnet-dns\",\n        location: \"eastus\",\n        addressSpace: {\n          addressPrefixes: [\"10.0.0.0/16\"],\n        },\n        dhcpOptions: {\n          dnsServers: [\"8.8.8.8\", \"8.8.4.4\"],\n        },\n      });\n\n      expect(vnet.props.dhcpOptions).toBeDefined();\n      expect(vnet.props.dhcpOptions?.dnsServers).toEqual([\n        \"8.8.8.8\",\n        \"8.8.4.4\",\n      ]);\n    });\n\n    it(\"should create VNet without DHCP options\", () => {\n      const vnet = new VirtualNetwork(stack, \"NoDHCP\", {\n        name: \"vnet-no-dhcp\",\n        location: \"eastus\",\n        addressSpace: {\n          addressPrefixes: [\"10.0.0.0/16\"],\n        },\n      });\n\n      expect(vnet.props.dhcpOptions).toBeUndefined();\n    });\n  });\n\n  describe(\"Protection Features\", () => {\n    it(\"should create VNet with DDoS protection enabled\", () => {\n      const vnet = new VirtualNetwork(stack, \"DDoSProtection\", {\n        name: \"vnet-ddos\",\n        location: \"eastus\",\n        addressSpace: {\n          addressPrefixes: [\"10.0.0.0/16\"],\n        },\n        enableDdosProtection: true,\n      });\n\n      expect(vnet.props.enableDdosProtection).toBe(true);\n    });\n\n    it(\"should create VNet with VM protection enabled\", () => {\n      const vnet = new VirtualNetwork(stack, \"VMProtection\", {\n        name: \"vnet-vm-protection\",\n        location: \"eastus\",\n        addressSpace: {\n          addressPrefixes: [\"10.0.0.0/16\"],\n        },\n        enableVmProtection: true,\n      });\n\n      expect(vnet.props.enableVmProtection).toBe(true);\n    });\n\n    it(\"should default protection features to false\", () => {\n      const vnet = new VirtualNetwork(stack, \"DefaultProtection\", {\n        name: \"vnet-default\",\n        location: \"eastus\",\n        addressSpace: {\n          addressPrefixes: [\"10.0.0.0/16\"],\n        },\n      });\n\n      expect(vnet.props.enableDdosProtection).toBeUndefined();\n      expect(vnet.props.enableVmProtection).toBeUndefined();\n    });\n  });\n\n  describe(\"Tags Management\", () => {\n    it(\"should create VNet with tags\", () => {\n      const vnet = new VirtualNetwork(stack, \"TaggedVNet\", {\n        name: \"vnet-tagged\",\n        location: \"eastus\",\n        addressSpace: {\n          addressPrefixes: [\"10.0.0.0/16\"],\n        },\n        tags: {\n          environment: \"production\",\n          cost_center: \"engineering\",\n        },\n      });\n\n      expect(vnet.props.tags).toEqual({\n        environment: \"production\",\n        cost_center: \"engineering\",\n      });\n    });\n\n    it(\"should support adding tags\", () => {\n      const vnet = new VirtualNetwork(stack, \"AddTag\", {\n        name: \"vnet-add-tag\",\n        location: \"eastus\",\n        addressSpace: {\n          addressPrefixes: [\"10.0.0.0/16\"],\n        },\n        tags: { environment: \"test\" },\n      });\n\n      vnet.addTag(\"newTag\", \"newValue\");\n      expect(vnet.props.tags!.newTag).toBe(\"newValue\");\n      expect(vnet.props.tags!.environment).toBe(\"test\");\n    });\n\n    it(\"should support removing tags\", () => {\n      const vnet = new VirtualNetwork(stack, \"RemoveTag\", {\n        name: \"vnet-remove-tag\",\n        location: \"eastus\",\n        addressSpace: {\n          addressPrefixes: [\"10.0.0.0/16\"],\n        },\n        tags: {\n          environment: \"test\",\n          temporary: \"true\",\n        },\n      });\n\n      vnet.removeTag(\"temporary\");\n      expect(vnet.props.tags!.temporary).toBeUndefined();\n      expect(vnet.props.tags!.environment).toBe(\"test\");\n    });\n  });\n\n  describe(\"Terraform Outputs\", () => {\n    it(\"should create Terraform outputs\", () => {\n      const vnet = new VirtualNetwork(stack, \"OutputTest\", {\n        name: \"vnet-outputs\",\n        location: \"eastus\",\n        addressSpace: {\n          addressPrefixes: [\"10.0.0.0/16\"],\n        },\n      });\n\n      expect(vnet.idOutput).toBeInstanceOf(cdktf.TerraformOutput);\n      expect(vnet.nameOutput).toBeInstanceOf(cdktf.TerraformOutput);\n      expect(vnet.locationOutput).toBeInstanceOf(cdktf.TerraformOutput);\n      expect(vnet.addressSpaceOutput).toBeInstanceOf(cdktf.TerraformOutput);\n      expect(vnet.tagsOutput).toBeInstanceOf(cdktf.TerraformOutput);\n    });\n\n    it(\"should have correct id format\", () => {\n      const vnet = new VirtualNetwork(stack, \"IdFormat\", {\n        name: \"vnet-id\",\n        location: \"eastus\",\n        addressSpace: {\n          addressPrefixes: [\"10.0.0.0/16\"],\n        },\n      });\n\n      expect(vnet.id).toMatch(/^\\$\\{.*\\.id\\}$/);\n      expect(vnet.resourceId).toBe(vnet.id);\n    });\n  });\n\n  describe(\"Version Compatibility\", () => {\n    it(\"should work with all supported API versions\", () => {\n      const versions = [\"2024-07-01\", \"2024-10-01\"];\n\n      versions.forEach((version) => {\n        const vnet = new VirtualNetwork(\n          stack,\n          `VNet-${version.replace(/-/g, \"\")}`,\n          {\n            name: `vnet-${version}`,\n            location: \"eastus\",\n            apiVersion: version,\n            addressSpace: {\n              addressPrefixes: [\"10.0.0.0/16\"],\n            },\n          },\n        );\n\n        expect(vnet.resolvedApiVersion).toBe(version);\n      });\n    });\n  });\n\n  describe(\"Ignore Changes Configuration\", () => {\n    it(\"should apply ignore changes lifecycle rules\", () => {\n      const vnet = new VirtualNetwork(stack, \"IgnoreChanges\", {\n        name: \"vnet-ignore\",\n        location: \"eastus\",\n        addressSpace: {\n          addressPrefixes: [\"10.0.0.0/16\"],\n        },\n        ignoreChanges: [\"tags\", \"dhcpOptions\"],\n      });\n\n      expect(vnet).toBeInstanceOf(VirtualNetwork);\n      expect(vnet.props.ignoreChanges).toEqual([\"tags\", \"dhcpOptions\"]);\n    });\n\n    it(\"should handle empty ignore changes array\", () => {\n      const vnet = new VirtualNetwork(stack, \"EmptyIgnore\", {\n        name: \"vnet-empty-ignore\",\n        location: \"eastus\",\n        addressSpace: {\n          addressPrefixes: [\"10.0.0.0/16\"],\n        },\n        ignoreChanges: [],\n      });\n\n      expect(vnet).toBeInstanceOf(VirtualNetwork);\n    });\n  });\n\n  describe(\"CDK Terraform Integration\", () => {\n    it(\"should synthesize to valid Terraform configuration\", () => {\n      new VirtualNetwork(stack, \"SynthTest\", {\n        name: \"vnet-synth\",\n        location: \"eastus\",\n        addressSpace: {\n          addressPrefixes: [\"10.0.0.0/16\"],\n        },\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 handle multiple VNets in the same stack\", () => {\n      const vnet1 = new VirtualNetwork(stack, \"VNet1\", {\n        name: \"vnet-1\",\n        location: \"eastus\",\n        addressSpace: {\n          addressPrefixes: [\"10.0.0.0/16\"],\n        },\n      });\n\n      const vnet2 = new VirtualNetwork(stack, \"VNet2\", {\n        name: \"vnet-2\",\n        location: \"westus\",\n        apiVersion: \"2024-07-01\",\n        addressSpace: {\n          addressPrefixes: [\"10.1.0.0/16\"],\n        },\n      });\n\n      expect(vnet1.resolvedApiVersion).toBe(\"2024-10-01\");\n      expect(vnet2.resolvedApiVersion).toBe(\"2024-07-01\");\n\n      const synthesized = Testing.synth(stack);\n      expect(synthesized).toBeDefined();\n    });\n  });\n\n  describe(\"Flow Timeout Configuration\", () => {\n    it(\"should create VNet with flow timeout\", () => {\n      const vnet = new VirtualNetwork(stack, \"FlowTimeout\", {\n        name: \"vnet-flow-timeout\",\n        location: \"eastus\",\n        addressSpace: {\n          addressPrefixes: [\"10.0.0.0/16\"],\n        },\n        flowTimeoutInMinutes: 20,\n      });\n\n      expect(vnet.props.flowTimeoutInMinutes).toBe(20);\n    });\n  });\n\n  describe(\"Subnet Configuration\", () => {\n    it(\"should create VNet with inline subnets\", () => {\n      const vnet = new VirtualNetwork(stack, \"WithSubnets\", {\n        name: \"vnet-with-subnets\",\n        location: \"eastus\",\n        addressSpace: {\n          addressPrefixes: [\"10.0.0.0/16\"],\n        },\n        subnets: [\n          {\n            name: \"subnet-1\",\n            addressPrefix: \"10.0.1.0/24\",\n          },\n          {\n            name: \"subnet-2\",\n            addressPrefix: \"10.0.2.0/24\",\n          },\n        ],\n      });\n\n      expect(vnet.props.subnets).toHaveLength(2);\n    });\n  });\n});\n"]}

package/lib/azure-vmss/index.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Azure Virtual Machine Scale Set Module
+ *
+ * Re-exports all public APIs from the lib directory
+ */
+export * from "./lib";

package/lib/azure-vmss/index.js

@@ -0,0 +1,23 @@
+"use strict";
+/**
+ * Azure Virtual Machine Scale Set Module
+ *
+ * Re-exports all public APIs from the lib directory
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./lib"), exports);
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvYXp1cmUtdm1zcy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiO0FBQUE7Ozs7R0FJRzs7Ozs7Ozs7Ozs7Ozs7OztBQUVILHdDQUFzQiIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogQXp1cmUgVmlydHVhbCBNYWNoaW5lIFNjYWxlIFNldCBNb2R1bGVcbiAqXG4gKiBSZS1leHBvcnRzIGFsbCBwdWJsaWMgQVBJcyBmcm9tIHRoZSBsaWIgZGlyZWN0b3J5XG4gKi9cblxuZXhwb3J0ICogZnJvbSBcIi4vbGliXCI7XG4iXX0=

package/lib/azure-vmss/lib/index.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Azure Virtual Machine Scale Set Constructs using AzapiResource Framework
+ */
+export * from "./virtual-machine-scale-set";
+export * from "./vmss-schemas";
+export { VirtualMachineScaleSet } from "./virtual-machine-scale-set";
+export { VMSS_TYPE, ALL_VMSS_VERSIONS, VMSS_SCHEMA_2025_01_02, VMSS_SCHEMA_2025_02_01, VMSS_SCHEMA_2025_04_01, VMSS_VERSION_2025_01_02, VMSS_VERSION_2025_02_01, VMSS_VERSION_2025_04_01, COMMON_VMSS_PROPERTIES, } from "./vmss-schemas";
+export type { VirtualMachineScaleSetSku, UpgradePolicyMode, RollingUpgradePolicy, AutomaticOSUpgradePolicy, VirtualMachineScaleSetUpgradePolicy, IPConfiguration, NetworkInterfaceConfiguration, VirtualMachineScaleSetNetworkProfile, VirtualMachineScaleSetVMProfile, AutomaticRepairsPolicy, VirtualMachineScaleSetScaleInPolicy, OrchestrationMode, VirtualMachineScaleSetScalingConfiguration, VirtualMachineScaleSetProps, VirtualMachineScaleSetBody, VirtualMachineScaleSetBodyProperties, } from "./vmss-schemas";
+export type { VirtualMachineHardwareProfile, VirtualMachineStorageProfile, VirtualMachineOSProfile, VirtualMachineIdentity, VirtualMachinePlan, VirtualMachineDiagnosticsProfile, VirtualMachineSecurityProfile, VirtualMachineBillingProfile, VirtualMachineImageReference, VirtualMachineOSDisk, VirtualMachineDataDisk, VirtualMachineLinuxConfiguration, VirtualMachineWindowsConfiguration, VirtualMachineBootDiagnostics, VirtualMachineUefiSettings, } from "../../azure-virtualmachine/lib/virtual-machine-schemas";

package/lib/azure-vmss/lib/index.js

@@ -0,0 +1,39 @@
+"use strict";
+/**
+ * Azure Virtual Machine Scale Set Constructs using AzapiResource Framework
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.COMMON_VMSS_PROPERTIES = exports.VMSS_VERSION_2025_04_01 = exports.VMSS_VERSION_2025_02_01 = exports.VMSS_VERSION_2025_01_02 = exports.VMSS_SCHEMA_2025_04_01 = exports.VMSS_SCHEMA_2025_02_01 = exports.VMSS_SCHEMA_2025_01_02 = exports.ALL_VMSS_VERSIONS = exports.VMSS_TYPE = exports.VirtualMachineScaleSet = void 0;
+// Export the unified implementation
+__exportStar(require("./virtual-machine-scale-set"), exports);
+// Export schemas for advanced usage
+__exportStar(require("./vmss-schemas"), exports);
+// Explicit exports for main class and interfaces
+var virtual_machine_scale_set_1 = require("./virtual-machine-scale-set");
+Object.defineProperty(exports, "VirtualMachineScaleSet", { enumerable: true, get: function () { return virtual_machine_scale_set_1.VirtualMachineScaleSet; } });
+// Schema exports
+var vmss_schemas_1 = require("./vmss-schemas");
+Object.defineProperty(exports, "VMSS_TYPE", { enumerable: true, get: function () { return vmss_schemas_1.VMSS_TYPE; } });
+Object.defineProperty(exports, "ALL_VMSS_VERSIONS", { enumerable: true, get: function () { return vmss_schemas_1.ALL_VMSS_VERSIONS; } });
+Object.defineProperty(exports, "VMSS_SCHEMA_2025_01_02", { enumerable: true, get: function () { return vmss_schemas_1.VMSS_SCHEMA_2025_01_02; } });
+Object.defineProperty(exports, "VMSS_SCHEMA_2025_02_01", { enumerable: true, get: function () { return vmss_schemas_1.VMSS_SCHEMA_2025_02_01; } });
+Object.defineProperty(exports, "VMSS_SCHEMA_2025_04_01", { enumerable: true, get: function () { return vmss_schemas_1.VMSS_SCHEMA_2025_04_01; } });
+Object.defineProperty(exports, "VMSS_VERSION_2025_01_02", { enumerable: true, get: function () { return vmss_schemas_1.VMSS_VERSION_2025_01_02; } });
+Object.defineProperty(exports, "VMSS_VERSION_2025_02_01", { enumerable: true, get: function () { return vmss_schemas_1.VMSS_VERSION_2025_02_01; } });
+Object.defineProperty(exports, "VMSS_VERSION_2025_04_01", { enumerable: true, get: function () { return vmss_schemas_1.VMSS_VERSION_2025_04_01; } });
+Object.defineProperty(exports, "COMMON_VMSS_PROPERTIES", { enumerable: true, get: function () { return vmss_schemas_1.COMMON_VMSS_PROPERTIES; } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvYXp1cmUtdm1zcy9saWIvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IjtBQUFBOztHQUVHOzs7Ozs7Ozs7Ozs7Ozs7OztBQUVILG9DQUFvQztBQUNwQyw4REFBNEM7QUFFNUMsb0NBQW9DO0FBQ3BDLGlEQUErQjtBQUUvQixpREFBaUQ7QUFDakQseUVBQXFFO0FBQTVELG1JQUFBLHNCQUFzQixPQUFBO0FBRS9CLGlCQUFpQjtBQUNqQiwrQ0FVd0I7QUFUdEIseUdBQUEsU0FBUyxPQUFBO0FBQ1QsaUhBQUEsaUJBQWlCLE9BQUE7QUFDakIsc0hBQUEsc0JBQXNCLE9BQUE7QUFDdEIsc0hBQUEsc0JBQXNCLE9BQUE7QUFDdEIsc0hBQUEsc0JBQXNCLE9BQUE7QUFDdEIsdUhBQUEsdUJBQXVCLE9BQUE7QUFDdkIsdUhBQUEsdUJBQXVCLE9BQUE7QUFDdkIsdUhBQUEsdUJBQXVCLE9BQUE7QUFDdkIsc0hBQUEsc0JBQXNCLE9BQUEiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIEF6dXJlIFZpcnR1YWwgTWFjaGluZSBTY2FsZSBTZXQgQ29uc3RydWN0cyB1c2luZyBBemFwaVJlc291cmNlIEZyYW1ld29ya1xuICovXG5cbi8vIEV4cG9ydCB0aGUgdW5pZmllZCBpbXBsZW1lbnRhdGlvblxuZXhwb3J0ICogZnJvbSBcIi4vdmlydHVhbC1tYWNoaW5lLXNjYWxlLXNldFwiO1xuXG4vLyBFeHBvcnQgc2NoZW1hcyBmb3IgYWR2YW5jZWQgdXNhZ2VcbmV4cG9ydCAqIGZyb20gXCIuL3Ztc3Mtc2NoZW1hc1wiO1xuXG4vLyBFeHBsaWNpdCBleHBvcnRzIGZvciBtYWluIGNsYXNzIGFuZCBpbnRlcmZhY2VzXG5leHBvcnQgeyBWaXJ0dWFsTWFjaGluZVNjYWxlU2V0IH0gZnJvbSBcIi4vdmlydHVhbC1tYWNoaW5lLXNjYWxlLXNldFwiO1xuXG4vLyBTY2hlbWEgZXhwb3J0c1xuZXhwb3J0IHtcbiAgVk1TU19UWVBFLFxuICBBTExfVk1TU19WRVJTSU9OUyxcbiAgVk1TU19TQ0hFTUFfMjAyNV8wMV8wMixcbiAgVk1TU19TQ0hFTUFfMjAyNV8wMl8wMSxcbiAgVk1TU19TQ0hFTUFfMjAyNV8wNF8wMSxcbiAgVk1TU19WRVJTSU9OXzIwMjVfMDFfMDIsXG4gIFZNU1NfVkVSU0lPTl8yMDI1XzAyXzAxLFxuICBWTVNTX1ZFUlNJT05fMjAyNV8wNF8wMSxcbiAgQ09NTU9OX1ZNU1NfUFJPUEVSVElFUyxcbn0gZnJvbSBcIi4vdm1zcy1zY2hlbWFzXCI7XG5cbi8vIEV4cG9ydCBhbGwgVHlwZVNjcmlwdCBpbnRlcmZhY2VzIGZvciBuZXN0ZWQgb2JqZWN0c1xuZXhwb3J0IHR5cGUge1xuICBWaXJ0dWFsTWFjaGluZVNjYWxlU2V0U2t1LFxuICBVcGdyYWRlUG9saWN5TW9kZSxcbiAgUm9sbGluZ1VwZ3JhZGVQb2xpY3ksXG4gIEF1dG9tYXRpY09TVXBncmFkZVBvbGljeSxcbiAgVmlydHVhbE1hY2hpbmVTY2FsZVNldFVwZ3JhZGVQb2xpY3ksXG4gIElQQ29uZmlndXJhdGlvbixcbiAgTmV0d29ya0ludGVyZmFjZUNvbmZpZ3VyYXRpb24sXG4gIFZpcnR1YWxNYWNoaW5lU2NhbGVTZXROZXR3b3JrUHJvZmlsZSxcbiAgVmlydHVhbE1hY2hpbmVTY2FsZVNldFZNUHJvZmlsZSxcbiAgQXV0b21hdGljUmVwYWlyc1BvbGljeSxcbiAgVmlydHVhbE1hY2hpbmVTY2FsZVNldFNjYWxlSW5Qb2xpY3ksXG4gIE9yY2hlc3RyYXRpb25Nb2RlLFxuICBWaXJ0dWFsTWFjaGluZVNjYWxlU2V0U2NhbGluZ0NvbmZpZ3VyYXRpb24sXG4gIFZpcnR1YWxNYWNoaW5lU2NhbGVTZXRQcm9wcyxcbiAgVmlydHVhbE1hY2hpbmVTY2FsZVNldEJvZHksXG4gIFZpcnR1YWxNYWNoaW5lU2NhbGVTZXRCb2R5UHJvcGVydGllcyxcbn0gZnJvbSBcIi4vdm1zcy1zY2hlbWFzXCI7XG5cbi8vIFJlLWV4cG9ydCBWTSB0eXBlcyB0aGF0IGFyZSByZXVzZWQgaW4gVk1TUyBmb3IgY29udmVuaWVuY2VcbmV4cG9ydCB0eXBlIHtcbiAgVmlydHVhbE1hY2hpbmVIYXJkd2FyZVByb2ZpbGUsXG4gIFZpcnR1YWxNYWNoaW5lU3RvcmFnZVByb2ZpbGUsXG4gIFZpcnR1YWxNYWNoaW5lT1NQcm9maWxlLFxuICBWaXJ0dWFsTWFjaGluZUlkZW50aXR5LFxuICBWaXJ0dWFsTWFjaGluZVBsYW4sXG4gIFZpcnR1YWxNYWNoaW5lRGlhZ25vc3RpY3NQcm9maWxlLFxuICBWaXJ0dWFsTWFjaGluZVNlY3VyaXR5UHJvZmlsZSxcbiAgVmlydHVhbE1hY2hpbmVCaWxsaW5nUHJvZmlsZSxcbiAgVmlydHVhbE1hY2hpbmVJbWFnZVJlZmVyZW5jZSxcbiAgVmlydHVhbE1hY2hpbmVPU0Rpc2ssXG4gIFZpcnR1YWxNYWNoaW5lRGF0YURpc2ssXG4gIFZpcnR1YWxNYWNoaW5lTGludXhDb25maWd1cmF0aW9uLFxuICBWaXJ0dWFsTWFjaGluZVdpbmRvd3NDb25maWd1cmF0aW9uLFxuICBWaXJ0dWFsTWFjaGluZUJvb3REaWFnbm9zdGljcyxcbiAgVmlydHVhbE1hY2hpbmVVZWZpU2V0dGluZ3MsXG59IGZyb20gXCIuLi8uLi9henVyZS12aXJ0dWFsbWFjaGluZS9saWIvdmlydHVhbC1tYWNoaW5lLXNjaGVtYXNcIjtcbiJdfQ==