@microsoft/terraform-cdk-constructs 1.3.1 → 1.4.0

package/lib/azure-virtualnetworkmanager/test/ipam-pool.spec.js

@@ -0,0 +1,372 @@
+"use strict";
+/**
+ * IPAM Pool Tests
+ *
+ * Unit tests for the IPAM Pool construct
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const cdktf_1 = require("cdktf");
+const cdktf = require("cdktf");
+const ipam_pool_1 = require("../lib/ipam-pool");
+const virtual_network_manager_1 = require("../lib/virtual-network-manager");
+describe("IpamPool", () => {
+    let app;
+    let stack;
+    let manager;
+    beforeEach(() => {
+        app = cdktf_1.Testing.app();
+        stack = new cdktf.TerraformStack(app, "test-stack");
+        manager = new virtual_network_manager_1.VirtualNetworkManager(stack, "TestManager", {
+            name: "test-manager",
+            location: "eastus",
+            resourceGroupId: "/subscriptions/test/resourceGroups/rg",
+            networkManagerScopes: {
+                subscriptions: ["/subscriptions/test"],
+            },
+            networkManagerScopeAccesses: ["Connectivity"],
+        });
+    });
+    describe("Basic Instantiation", () => {
+        it("should create pool with single address prefix", () => {
+            const pool = new ipam_pool_1.IpamPool(stack, "TestPool", {
+                name: "test-pool",
+                location: "eastus",
+                networkManagerId: manager.id,
+                addressPrefixes: ["10.0.0.0/8"],
+            });
+            expect(pool).toBeInstanceOf(ipam_pool_1.IpamPool);
+            expect(pool.props.addressPrefixes).toEqual(["10.0.0.0/8"]);
+            expect(pool.props.name).toBe("test-pool");
+            expect(pool.props.location).toBe("eastus");
+        });
+        it("should create pool with multiple non-overlapping prefixes", () => {
+            const pool = new ipam_pool_1.IpamPool(stack, "TestPool", {
+                name: "test-pool",
+                location: "eastus",
+                networkManagerId: manager.id,
+                addressPrefixes: ["10.0.0.0/8", "172.16.0.0/12", "192.168.0.0/16"],
+            });
+            expect(pool.props.addressPrefixes).toHaveLength(3);
+            expect(pool.totalAddressCount).toBe(16777216 + 1048576 + 65536);
+        });
+        it("should create pool with description and display name", () => {
+            const pool = new ipam_pool_1.IpamPool(stack, "TestPool", {
+                name: "test-pool",
+                location: "eastus",
+                networkManagerId: manager.id,
+                addressPrefixes: ["10.0.0.0/8"],
+                description: "Test IPAM pool",
+                displayName: "Test Pool",
+            });
+            expect(pool.props.description).toBe("Test IPAM pool");
+            expect(pool.props.displayName).toBe("Test Pool");
+        });
+        it("should create pool with tags", () => {
+            const pool = new ipam_pool_1.IpamPool(stack, "TestPool", {
+                name: "test-pool",
+                location: "eastus",
+                networkManagerId: manager.id,
+                addressPrefixes: ["10.0.0.0/8"],
+                tags: {
+                    environment: "test",
+                    purpose: "ipam",
+                },
+            });
+            expect(pool.props.tags).toEqual({
+                environment: "test",
+                purpose: "ipam",
+            });
+        });
+    });
+    describe("CIDR Validation", () => {
+        it("should throw error for overlapping prefixes", () => {
+            expect(() => {
+                new ipam_pool_1.IpamPool(stack, "TestPool", {
+                    name: "test-pool",
+                    location: "eastus",
+                    networkManagerId: manager.id,
+                    addressPrefixes: ["10.0.0.0/8", "10.1.0.0/16"],
+                });
+            }).toThrow(/overlap/i);
+        });
+        it("should throw error for invalid CIDR format", () => {
+            expect(() => {
+                new ipam_pool_1.IpamPool(stack, "TestPool", {
+                    name: "test-pool",
+                    location: "eastus",
+                    networkManagerId: manager.id,
+                    addressPrefixes: ["10.0.0.0/33"],
+                });
+            }).toThrow(/Invalid CIDR/i);
+        });
+        it("should throw error for missing CIDR prefix", () => {
+            expect(() => {
+                new ipam_pool_1.IpamPool(stack, "TestPool", {
+                    name: "test-pool",
+                    location: "eastus",
+                    networkManagerId: manager.id,
+                    addressPrefixes: ["10.0.0.0"],
+                });
+            }).toThrow(/Invalid CIDR/i);
+        });
+        it("should throw error for empty address prefixes", () => {
+            expect(() => {
+                new ipam_pool_1.IpamPool(stack, "TestPool", {
+                    name: "test-pool",
+                    location: "eastus",
+                    networkManagerId: manager.id,
+                    addressPrefixes: [],
+                });
+            }).toThrow(/At least one address prefix is required/i);
+        });
+        it("should throw error for invalid octets", () => {
+            expect(() => {
+                new ipam_pool_1.IpamPool(stack, "TestPool", {
+                    name: "test-pool",
+                    location: "eastus",
+                    networkManagerId: manager.id,
+                    addressPrefixes: ["256.0.0.0/24"],
+                });
+            }).toThrow(/Invalid CIDR/i);
+        });
+    });
+    describe("Hierarchical Pools", () => {
+        it("should create child pool with parent reference", () => {
+            const parentPool = new ipam_pool_1.IpamPool(stack, "ParentPool", {
+                name: "parent-pool",
+                location: "eastus",
+                networkManagerId: manager.id,
+                addressPrefixes: ["10.0.0.0/8"],
+            });
+            const childPool = new ipam_pool_1.IpamPool(stack, "ChildPool", {
+                name: "child-pool",
+                location: "eastus",
+                networkManagerId: manager.id,
+                addressPrefixes: ["10.1.0.0/16"],
+                parentPoolName: parentPool.props.name,
+            });
+            expect(childPool.props.parentPoolName).toBe("parent-pool");
+        });
+        it("should create multiple child pools under same parent", () => {
+            const parentPool = new ipam_pool_1.IpamPool(stack, "ParentPool", {
+                name: "parent-pool",
+                location: "eastus",
+                networkManagerId: manager.id,
+                addressPrefixes: ["10.0.0.0/8"],
+            });
+            const child1 = new ipam_pool_1.IpamPool(stack, "ChildPool1", {
+                name: "child-pool-1",
+                location: "eastus",
+                networkManagerId: manager.id,
+                addressPrefixes: ["10.1.0.0/16"],
+                parentPoolName: parentPool.props.name,
+            });
+            const child2 = new ipam_pool_1.IpamPool(stack, "ChildPool2", {
+                name: "child-pool-2",
+                location: "eastus",
+                networkManagerId: manager.id,
+                addressPrefixes: ["10.2.0.0/16"],
+                parentPoolName: parentPool.props.name,
+            });
+            expect(child1.props.parentPoolName).toBe("parent-pool");
+            expect(child2.props.parentPoolName).toBe("parent-pool");
+        });
+        it("should create root pool without parent reference", () => {
+            const rootPool = new ipam_pool_1.IpamPool(stack, "RootPool", {
+                name: "root-pool",
+                location: "eastus",
+                networkManagerId: manager.id,
+                addressPrefixes: ["10.0.0.0/8"],
+            });
+            expect(rootPool.props.parentPoolName).toBeUndefined();
+        });
+    });
+    describe("Terraform Outputs", () => {
+        it("should create proper Terraform outputs", () => {
+            const pool = new ipam_pool_1.IpamPool(stack, "TestPool", {
+                name: "test-pool",
+                location: "eastus",
+                networkManagerId: manager.id,
+                addressPrefixes: ["10.0.0.0/8"],
+            });
+            expect(pool.idOutput).toBeInstanceOf(cdktf.TerraformOutput);
+            expect(pool.nameOutput).toBeInstanceOf(cdktf.TerraformOutput);
+            expect(pool.locationOutput).toBeInstanceOf(cdktf.TerraformOutput);
+        });
+        it("should have correct output logical IDs", () => {
+            new ipam_pool_1.IpamPool(stack, "TestPool", {
+                name: "test-pool",
+                location: "eastus",
+                networkManagerId: manager.id,
+                addressPrefixes: ["10.0.0.0/8"],
+            });
+            const synthesized = cdktf_1.Testing.synth(stack);
+            const stackConfig = JSON.parse(synthesized);
+            expect(stackConfig.output).toBeDefined();
+            expect(stackConfig.output.id).toBeDefined();
+            expect(stackConfig.output.name).toBeDefined();
+            expect(stackConfig.output.location).toBeDefined();
+        });
+    });
+    describe("API Version Handling", () => {
+        it("should use default API version", () => {
+            const pool = new ipam_pool_1.IpamPool(stack, "TestPool", {
+                name: "test-pool",
+                location: "eastus",
+                networkManagerId: manager.id,
+                addressPrefixes: ["10.0.0.0/8"],
+            });
+            expect(pool.resolvedApiVersion).toBe("2024-05-01");
+        });
+        it("should use specified API version", () => {
+            const pool = new ipam_pool_1.IpamPool(stack, "TestPool", {
+                name: "test-pool",
+                location: "eastus",
+                networkManagerId: manager.id,
+                addressPrefixes: ["10.0.0.0/8"],
+                apiVersion: "2024-05-01",
+            });
+            expect(pool.resolvedApiVersion).toBe("2024-05-01");
+        });
+        it("should have correct resource type", () => {
+            new ipam_pool_1.IpamPool(stack, "TestPool", {
+                name: "test-pool",
+                location: "eastus",
+                networkManagerId: manager.id,
+                addressPrefixes: ["10.0.0.0/8"],
+            });
+            const manifest = JSON.stringify(cdktf_1.Testing.synth(stack));
+            expect(manifest).toContain("Microsoft.Network/networkManagers/ipamPools@2024-05-01");
+        });
+    });
+    describe("Helper Properties", () => {
+        it("should calculate total address count for single prefix", () => {
+            const pool = new ipam_pool_1.IpamPool(stack, "TestPool", {
+                name: "test-pool",
+                location: "eastus",
+                networkManagerId: manager.id,
+                addressPrefixes: ["10.0.0.0/24"],
+            });
+            expect(pool.totalAddressCount).toBe(256);
+        });
+        it("should calculate total address count for multiple prefixes", () => {
+            const pool = new ipam_pool_1.IpamPool(stack, "TestPool", {
+                name: "test-pool",
+                location: "eastus",
+                networkManagerId: manager.id,
+                addressPrefixes: ["10.0.0.0/24", "172.16.0.0/24"],
+            });
+            expect(pool.totalAddressCount).toBe(512); // 256 + 256
+        });
+        it("should calculate total for large CIDR blocks", () => {
+            const pool = new ipam_pool_1.IpamPool(stack, "TestPool", {
+                name: "test-pool",
+                location: "eastus",
+                networkManagerId: manager.id,
+                addressPrefixes: ["10.0.0.0/8"],
+            });
+            expect(pool.totalAddressCount).toBe(16777216); // 2^24
+        });
+        it("should calculate total for small CIDR blocks", () => {
+            const pool = new ipam_pool_1.IpamPool(stack, "TestPool", {
+                name: "test-pool",
+                location: "eastus",
+                networkManagerId: manager.id,
+                addressPrefixes: ["10.0.0.0/32"],
+            });
+            expect(pool.totalAddressCount).toBe(1);
+        });
+    });
+    describe("Lifecycle Management", () => {
+        it("should apply ignore changes for tags", () => {
+            new ipam_pool_1.IpamPool(stack, "TestPool", {
+                name: "test-pool",
+                location: "eastus",
+                networkManagerId: manager.id,
+                addressPrefixes: ["10.0.0.0/8"],
+                ignoreChanges: ["tags"],
+            });
+            const manifest = JSON.stringify(cdktf_1.Testing.synth(stack));
+            expect(manifest).toContain("ignore_changes");
+        });
+        it("should apply multiple ignore changes", () => {
+            new ipam_pool_1.IpamPool(stack, "TestPool", {
+                name: "test-pool",
+                location: "eastus",
+                networkManagerId: manager.id,
+                addressPrefixes: ["10.0.0.0/8"],
+                ignoreChanges: ["tags", "description"],
+            });
+            const manifest = JSON.stringify(cdktf_1.Testing.synth(stack));
+            expect(manifest).toContain("ignore_changes");
+        });
+    });
+    describe("Terraform Synthesis", () => {
+        it("should synthesize valid Terraform configuration", () => {
+            new ipam_pool_1.IpamPool(stack, "TestPool", {
+                name: "test-pool",
+                location: "eastus",
+                networkManagerId: manager.id,
+                addressPrefixes: ["10.0.0.0/8"],
+                description: "Test pool",
+            });
+            const output = cdktf_1.Testing.synth(stack);
+            expect(output).toBeDefined();
+        });
+        it("should include address prefixes in resource body", () => {
+            new ipam_pool_1.IpamPool(stack, "TestPool", {
+                name: "test-pool",
+                location: "eastus",
+                networkManagerId: manager.id,
+                addressPrefixes: ["10.0.0.0/8", "172.16.0.0/12"],
+            });
+            const manifest = JSON.stringify(cdktf_1.Testing.synth(stack));
+            expect(manifest).toContain("10.0.0.0/8");
+            expect(manifest).toContain("172.16.0.0/12");
+        });
+        it("should include optional properties when specified", () => {
+            new ipam_pool_1.IpamPool(stack, "TestPool", {
+                name: "test-pool",
+                location: "eastus",
+                networkManagerId: manager.id,
+                addressPrefixes: ["10.0.0.0/8"],
+                description: "Test description",
+                displayName: "Test Display Name",
+            });
+            const manifest = JSON.stringify(cdktf_1.Testing.synth(stack));
+            expect(manifest).toContain("Test description");
+            expect(manifest).toContain("Test Display Name");
+        });
+    });
+    describe("Edge Cases", () => {
+        it("should handle /0 prefix (entire IPv4 space)", () => {
+            const pool = new ipam_pool_1.IpamPool(stack, "TestPool", {
+                name: "test-pool",
+                location: "eastus",
+                networkManagerId: manager.id,
+                addressPrefixes: ["0.0.0.0/0"],
+            });
+            expect(pool.totalAddressCount).toBe(4294967296); // 2^32
+        });
+        it("should handle /32 prefix (single IP)", () => {
+            const pool = new ipam_pool_1.IpamPool(stack, "TestPool", {
+                name: "test-pool",
+                location: "eastus",
+                networkManagerId: manager.id,
+                addressPrefixes: ["192.168.1.1/32"],
+            });
+            expect(pool.totalAddressCount).toBe(1);
+        });
+        it("should handle maximum valid name length", () => {
+            const longName = "a".repeat(64);
+            const pool = new ipam_pool_1.IpamPool(stack, "TestPool", {
+                name: longName,
+                location: "eastus",
+                networkManagerId: manager.id,
+                addressPrefixes: ["10.0.0.0/8"],
+            });
+            expect(pool.props.name).toBe(longName);
+        });
+    });
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ipam-pool.spec.js","sourceRoot":"","sources":["../../../src/azure-virtualnetworkmanager/test/ipam-pool.spec.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * IPAM Pool Tests\n *\n * Unit tests for the IPAM Pool construct\n */\n\nimport { Testing } from \"cdktf\";\nimport * as cdktf from \"cdktf\";\nimport { IpamPool } from \"../lib/ipam-pool\";\nimport { VirtualNetworkManager } from \"../lib/virtual-network-manager\";\n\ndescribe(\"IpamPool\", () => {\n  let app: cdktf.App;\n  let stack: cdktf.TerraformStack;\n  let manager: VirtualNetworkManager;\n\n  beforeEach(() => {\n    app = Testing.app();\n    stack = new cdktf.TerraformStack(app, \"test-stack\");\n    manager = new VirtualNetworkManager(stack, \"TestManager\", {\n      name: \"test-manager\",\n      location: \"eastus\",\n      resourceGroupId: \"/subscriptions/test/resourceGroups/rg\",\n      networkManagerScopes: {\n        subscriptions: [\"/subscriptions/test\"],\n      },\n      networkManagerScopeAccesses: [\"Connectivity\"],\n    });\n  });\n\n  describe(\"Basic Instantiation\", () => {\n    it(\"should create pool with single address prefix\", () => {\n      const pool = new IpamPool(stack, \"TestPool\", {\n        name: \"test-pool\",\n        location: \"eastus\",\n        networkManagerId: manager.id,\n        addressPrefixes: [\"10.0.0.0/8\"],\n      });\n\n      expect(pool).toBeInstanceOf(IpamPool);\n      expect(pool.props.addressPrefixes).toEqual([\"10.0.0.0/8\"]);\n      expect(pool.props.name).toBe(\"test-pool\");\n      expect(pool.props.location).toBe(\"eastus\");\n    });\n\n    it(\"should create pool with multiple non-overlapping prefixes\", () => {\n      const pool = new IpamPool(stack, \"TestPool\", {\n        name: \"test-pool\",\n        location: \"eastus\",\n        networkManagerId: manager.id,\n        addressPrefixes: [\"10.0.0.0/8\", \"172.16.0.0/12\", \"192.168.0.0/16\"],\n      });\n\n      expect(pool.props.addressPrefixes).toHaveLength(3);\n      expect(pool.totalAddressCount).toBe(16777216 + 1048576 + 65536);\n    });\n\n    it(\"should create pool with description and display name\", () => {\n      const pool = new IpamPool(stack, \"TestPool\", {\n        name: \"test-pool\",\n        location: \"eastus\",\n        networkManagerId: manager.id,\n        addressPrefixes: [\"10.0.0.0/8\"],\n        description: \"Test IPAM pool\",\n        displayName: \"Test Pool\",\n      });\n\n      expect(pool.props.description).toBe(\"Test IPAM pool\");\n      expect(pool.props.displayName).toBe(\"Test Pool\");\n    });\n\n    it(\"should create pool with tags\", () => {\n      const pool = new IpamPool(stack, \"TestPool\", {\n        name: \"test-pool\",\n        location: \"eastus\",\n        networkManagerId: manager.id,\n        addressPrefixes: [\"10.0.0.0/8\"],\n        tags: {\n          environment: \"test\",\n          purpose: \"ipam\",\n        },\n      });\n\n      expect(pool.props.tags).toEqual({\n        environment: \"test\",\n        purpose: \"ipam\",\n      });\n    });\n  });\n\n  describe(\"CIDR Validation\", () => {\n    it(\"should throw error for overlapping prefixes\", () => {\n      expect(() => {\n        new IpamPool(stack, \"TestPool\", {\n          name: \"test-pool\",\n          location: \"eastus\",\n          networkManagerId: manager.id,\n          addressPrefixes: [\"10.0.0.0/8\", \"10.1.0.0/16\"],\n        });\n      }).toThrow(/overlap/i);\n    });\n\n    it(\"should throw error for invalid CIDR format\", () => {\n      expect(() => {\n        new IpamPool(stack, \"TestPool\", {\n          name: \"test-pool\",\n          location: \"eastus\",\n          networkManagerId: manager.id,\n          addressPrefixes: [\"10.0.0.0/33\"],\n        });\n      }).toThrow(/Invalid CIDR/i);\n    });\n\n    it(\"should throw error for missing CIDR prefix\", () => {\n      expect(() => {\n        new IpamPool(stack, \"TestPool\", {\n          name: \"test-pool\",\n          location: \"eastus\",\n          networkManagerId: manager.id,\n          addressPrefixes: [\"10.0.0.0\"],\n        });\n      }).toThrow(/Invalid CIDR/i);\n    });\n\n    it(\"should throw error for empty address prefixes\", () => {\n      expect(() => {\n        new IpamPool(stack, \"TestPool\", {\n          name: \"test-pool\",\n          location: \"eastus\",\n          networkManagerId: manager.id,\n          addressPrefixes: [],\n        });\n      }).toThrow(/At least one address prefix is required/i);\n    });\n\n    it(\"should throw error for invalid octets\", () => {\n      expect(() => {\n        new IpamPool(stack, \"TestPool\", {\n          name: \"test-pool\",\n          location: \"eastus\",\n          networkManagerId: manager.id,\n          addressPrefixes: [\"256.0.0.0/24\"],\n        });\n      }).toThrow(/Invalid CIDR/i);\n    });\n  });\n\n  describe(\"Hierarchical Pools\", () => {\n    it(\"should create child pool with parent reference\", () => {\n      const parentPool = new IpamPool(stack, \"ParentPool\", {\n        name: \"parent-pool\",\n        location: \"eastus\",\n        networkManagerId: manager.id,\n        addressPrefixes: [\"10.0.0.0/8\"],\n      });\n\n      const childPool = new IpamPool(stack, \"ChildPool\", {\n        name: \"child-pool\",\n        location: \"eastus\",\n        networkManagerId: manager.id,\n        addressPrefixes: [\"10.1.0.0/16\"],\n        parentPoolName: parentPool.props.name,\n      });\n\n      expect(childPool.props.parentPoolName).toBe(\"parent-pool\");\n    });\n\n    it(\"should create multiple child pools under same parent\", () => {\n      const parentPool = new IpamPool(stack, \"ParentPool\", {\n        name: \"parent-pool\",\n        location: \"eastus\",\n        networkManagerId: manager.id,\n        addressPrefixes: [\"10.0.0.0/8\"],\n      });\n\n      const child1 = new IpamPool(stack, \"ChildPool1\", {\n        name: \"child-pool-1\",\n        location: \"eastus\",\n        networkManagerId: manager.id,\n        addressPrefixes: [\"10.1.0.0/16\"],\n        parentPoolName: parentPool.props.name,\n      });\n\n      const child2 = new IpamPool(stack, \"ChildPool2\", {\n        name: \"child-pool-2\",\n        location: \"eastus\",\n        networkManagerId: manager.id,\n        addressPrefixes: [\"10.2.0.0/16\"],\n        parentPoolName: parentPool.props.name,\n      });\n\n      expect(child1.props.parentPoolName).toBe(\"parent-pool\");\n      expect(child2.props.parentPoolName).toBe(\"parent-pool\");\n    });\n\n    it(\"should create root pool without parent reference\", () => {\n      const rootPool = new IpamPool(stack, \"RootPool\", {\n        name: \"root-pool\",\n        location: \"eastus\",\n        networkManagerId: manager.id,\n        addressPrefixes: [\"10.0.0.0/8\"],\n      });\n\n      expect(rootPool.props.parentPoolName).toBeUndefined();\n    });\n  });\n\n  describe(\"Terraform Outputs\", () => {\n    it(\"should create proper Terraform outputs\", () => {\n      const pool = new IpamPool(stack, \"TestPool\", {\n        name: \"test-pool\",\n        location: \"eastus\",\n        networkManagerId: manager.id,\n        addressPrefixes: [\"10.0.0.0/8\"],\n      });\n\n      expect(pool.idOutput).toBeInstanceOf(cdktf.TerraformOutput);\n      expect(pool.nameOutput).toBeInstanceOf(cdktf.TerraformOutput);\n      expect(pool.locationOutput).toBeInstanceOf(cdktf.TerraformOutput);\n    });\n\n    it(\"should have correct output logical IDs\", () => {\n      new IpamPool(stack, \"TestPool\", {\n        name: \"test-pool\",\n        location: \"eastus\",\n        networkManagerId: manager.id,\n        addressPrefixes: [\"10.0.0.0/8\"],\n      });\n\n      const synthesized = Testing.synth(stack);\n      const stackConfig = JSON.parse(synthesized);\n      expect(stackConfig.output).toBeDefined();\n      expect(stackConfig.output.id).toBeDefined();\n      expect(stackConfig.output.name).toBeDefined();\n      expect(stackConfig.output.location).toBeDefined();\n    });\n  });\n\n  describe(\"API Version Handling\", () => {\n    it(\"should use default API version\", () => {\n      const pool = new IpamPool(stack, \"TestPool\", {\n        name: \"test-pool\",\n        location: \"eastus\",\n        networkManagerId: manager.id,\n        addressPrefixes: [\"10.0.0.0/8\"],\n      });\n\n      expect(pool.resolvedApiVersion).toBe(\"2024-05-01\");\n    });\n\n    it(\"should use specified API version\", () => {\n      const pool = new IpamPool(stack, \"TestPool\", {\n        name: \"test-pool\",\n        location: \"eastus\",\n        networkManagerId: manager.id,\n        addressPrefixes: [\"10.0.0.0/8\"],\n        apiVersion: \"2024-05-01\",\n      });\n\n      expect(pool.resolvedApiVersion).toBe(\"2024-05-01\");\n    });\n\n    it(\"should have correct resource type\", () => {\n      new IpamPool(stack, \"TestPool\", {\n        name: \"test-pool\",\n        location: \"eastus\",\n        networkManagerId: manager.id,\n        addressPrefixes: [\"10.0.0.0/8\"],\n      });\n\n      const manifest = JSON.stringify(Testing.synth(stack));\n      expect(manifest).toContain(\n        \"Microsoft.Network/networkManagers/ipamPools@2024-05-01\",\n      );\n    });\n  });\n\n  describe(\"Helper Properties\", () => {\n    it(\"should calculate total address count for single prefix\", () => {\n      const pool = new IpamPool(stack, \"TestPool\", {\n        name: \"test-pool\",\n        location: \"eastus\",\n        networkManagerId: manager.id,\n        addressPrefixes: [\"10.0.0.0/24\"],\n      });\n\n      expect(pool.totalAddressCount).toBe(256);\n    });\n\n    it(\"should calculate total address count for multiple prefixes\", () => {\n      const pool = new IpamPool(stack, \"TestPool\", {\n        name: \"test-pool\",\n        location: \"eastus\",\n        networkManagerId: manager.id,\n        addressPrefixes: [\"10.0.0.0/24\", \"172.16.0.0/24\"],\n      });\n\n      expect(pool.totalAddressCount).toBe(512); // 256 + 256\n    });\n\n    it(\"should calculate total for large CIDR blocks\", () => {\n      const pool = new IpamPool(stack, \"TestPool\", {\n        name: \"test-pool\",\n        location: \"eastus\",\n        networkManagerId: manager.id,\n        addressPrefixes: [\"10.0.0.0/8\"],\n      });\n\n      expect(pool.totalAddressCount).toBe(16777216); // 2^24\n    });\n\n    it(\"should calculate total for small CIDR blocks\", () => {\n      const pool = new IpamPool(stack, \"TestPool\", {\n        name: \"test-pool\",\n        location: \"eastus\",\n        networkManagerId: manager.id,\n        addressPrefixes: [\"10.0.0.0/32\"],\n      });\n\n      expect(pool.totalAddressCount).toBe(1);\n    });\n  });\n\n  describe(\"Lifecycle Management\", () => {\n    it(\"should apply ignore changes for tags\", () => {\n      new IpamPool(stack, \"TestPool\", {\n        name: \"test-pool\",\n        location: \"eastus\",\n        networkManagerId: manager.id,\n        addressPrefixes: [\"10.0.0.0/8\"],\n        ignoreChanges: [\"tags\"],\n      });\n\n      const manifest = JSON.stringify(Testing.synth(stack));\n      expect(manifest).toContain(\"ignore_changes\");\n    });\n\n    it(\"should apply multiple ignore changes\", () => {\n      new IpamPool(stack, \"TestPool\", {\n        name: \"test-pool\",\n        location: \"eastus\",\n        networkManagerId: manager.id,\n        addressPrefixes: [\"10.0.0.0/8\"],\n        ignoreChanges: [\"tags\", \"description\"],\n      });\n\n      const manifest = JSON.stringify(Testing.synth(stack));\n      expect(manifest).toContain(\"ignore_changes\");\n    });\n  });\n\n  describe(\"Terraform Synthesis\", () => {\n    it(\"should synthesize valid Terraform configuration\", () => {\n      new IpamPool(stack, \"TestPool\", {\n        name: \"test-pool\",\n        location: \"eastus\",\n        networkManagerId: manager.id,\n        addressPrefixes: [\"10.0.0.0/8\"],\n        description: \"Test pool\",\n      });\n\n      const output = Testing.synth(stack);\n      expect(output).toBeDefined();\n    });\n\n    it(\"should include address prefixes in resource body\", () => {\n      new IpamPool(stack, \"TestPool\", {\n        name: \"test-pool\",\n        location: \"eastus\",\n        networkManagerId: manager.id,\n        addressPrefixes: [\"10.0.0.0/8\", \"172.16.0.0/12\"],\n      });\n\n      const manifest = JSON.stringify(Testing.synth(stack));\n      expect(manifest).toContain(\"10.0.0.0/8\");\n      expect(manifest).toContain(\"172.16.0.0/12\");\n    });\n\n    it(\"should include optional properties when specified\", () => {\n      new IpamPool(stack, \"TestPool\", {\n        name: \"test-pool\",\n        location: \"eastus\",\n        networkManagerId: manager.id,\n        addressPrefixes: [\"10.0.0.0/8\"],\n        description: \"Test description\",\n        displayName: \"Test Display Name\",\n      });\n\n      const manifest = JSON.stringify(Testing.synth(stack));\n      expect(manifest).toContain(\"Test description\");\n      expect(manifest).toContain(\"Test Display Name\");\n    });\n  });\n\n  describe(\"Edge Cases\", () => {\n    it(\"should handle /0 prefix (entire IPv4 space)\", () => {\n      const pool = new IpamPool(stack, \"TestPool\", {\n        name: \"test-pool\",\n        location: \"eastus\",\n        networkManagerId: manager.id,\n        addressPrefixes: [\"0.0.0.0/0\"],\n      });\n\n      expect(pool.totalAddressCount).toBe(4294967296); // 2^32\n    });\n\n    it(\"should handle /32 prefix (single IP)\", () => {\n      const pool = new IpamPool(stack, \"TestPool\", {\n        name: \"test-pool\",\n        location: \"eastus\",\n        networkManagerId: manager.id,\n        addressPrefixes: [\"192.168.1.1/32\"],\n      });\n\n      expect(pool.totalAddressCount).toBe(1);\n    });\n\n    it(\"should handle maximum valid name length\", () => {\n      const longName = \"a\".repeat(64);\n      const pool = new IpamPool(stack, \"TestPool\", {\n        name: longName,\n        location: \"eastus\",\n        networkManagerId: manager.id,\n        addressPrefixes: [\"10.0.0.0/8\"],\n      });\n\n      expect(pool.props.name).toBe(longName);\n    });\n  });\n});\n"]}

package/lib/azure-virtualnetworkmanager/test/virtual-network-manager.integ.d.ts

@@ -3,7 +3,7 @@
  *
  * This test demonstrates comprehensive usage of the VirtualNetworkManager construct
  * including all child resources (NetworkGroup, ConnectivityConfiguration, SecurityAdminConfiguration,
- * SecurityAdminRuleCollection, SecurityAdminRule, and NetworkGroupStaticMember).
+ * SecurityAdminRuleCollection, SecurityAdminRule, NetworkGroupStaticMember, IpamPool, and IpamPoolStaticCidr).
  *
  * It validates:
  * - VirtualNetworkManager deployment
@@ -11,6 +11,7 @@
  * - NetworkGroupStaticMember for adding VNets to groups
  * - ConnectivityConfiguration for both Mesh and Hub-Spoke topologies
  * - SecurityAdminConfiguration, RuleCollections, and Rules (Allow, Deny, AlwaysAllow)
+ * - IpamPool and IpamPoolStaticCidr for IP address management
  * - Parent-child relationships and proper deployment order
  * - Idempotency and cleanup
  *