@microsoft/terraform-cdk-constructs 1.2.0 → 1.3.1

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

@@ -0,0 +1,285 @@
+"use strict";
+/**
+ * Comprehensive tests for the DnsForwardingRulesetVirtualNetworkLink implementation
+ *
+ * This test suite validates the DnsForwardingRulesetVirtualNetworkLink class using the
+ * AzapiResource framework. Tests cover automatic version resolution,
+ * explicit version pinning, schema validation, property transformation,
+ * parent-child resource relationships, and full backward compatibility.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const cdktf_1 = require("cdktf");
+const cdktf = require("cdktf");
+const api_version_manager_1 = require("../../core-azure/lib/version-manager/api-version-manager");
+const version_interfaces_1 = require("../../core-azure/lib/version-manager/interfaces/version-interfaces");
+const virtual_network_link_1 = require("../lib/virtual-network-link");
+const virtual_network_link_schemas_1 = require("../lib/virtual-network-link-schemas");
+describe("DnsForwardingRulesetVirtualNetworkLink - Implementation", () => {
+    let app;
+    let stack;
+    let manager;
+    const mockRulesetId = "/subscriptions/12345678-1234-1234-1234-123456789012/resourceGroups/test-rg/providers/Microsoft.Network/dnsForwardingRulesets/test-ruleset";
+    const mockVirtualNetworkId = "/subscriptions/12345678-1234-1234-1234-123456789012/resourceGroups/test-rg/providers/Microsoft.Network/virtualNetworks/test-vnet";
+    beforeEach(() => {
+        app = cdktf_1.Testing.app();
+        stack = new cdktf.TerraformStack(app, "TestStack");
+        manager = api_version_manager_1.ApiVersionManager.instance();
+        // Ensure schemas are registered
+        try {
+            manager.registerResourceType(virtual_network_link_schemas_1.VIRTUAL_NETWORK_LINK_TYPE, virtual_network_link_schemas_1.ALL_VIRTUAL_NETWORK_LINK_VERSIONS);
+        }
+        catch (error) {
+            // Ignore if already registered
+        }
+    });
+    describe("Constructor and Basic Properties", () => {
+        it("should create Virtual Network Link with automatic latest version resolution", () => {
+            const props = {
+                name: "my-vnet-link",
+                dnsForwardingRulesetId: mockRulesetId,
+                virtualNetworkId: mockVirtualNetworkId,
+            };
+            const link = new virtual_network_link_1.DnsForwardingRulesetVirtualNetworkLink(stack, "TestLink", props);
+            expect(link).toBeInstanceOf(virtual_network_link_1.DnsForwardingRulesetVirtualNetworkLink);
+            expect(link.resolvedApiVersion).toBe("2022-07-01");
+            expect(link.props).toBe(props);
+        });
+        it("should create Virtual Network Link with explicit version pinning", () => {
+            const props = {
+                name: "my-vnet-link",
+                dnsForwardingRulesetId: mockRulesetId,
+                virtualNetworkId: mockVirtualNetworkId,
+                apiVersion: "2022-07-01",
+            };
+            const link = new virtual_network_link_1.DnsForwardingRulesetVirtualNetworkLink(stack, "TestLink", props);
+            expect(link.resolvedApiVersion).toBe("2022-07-01");
+        });
+        it("should create Virtual Network Link with metadata", () => {
+            const props = {
+                name: "my-vnet-link",
+                dnsForwardingRulesetId: mockRulesetId,
+                virtualNetworkId: mockVirtualNetworkId,
+                metadata: {
+                    environment: "production",
+                    team: "platform",
+                },
+            };
+            const link = new virtual_network_link_1.DnsForwardingRulesetVirtualNetworkLink(stack, "TestLink", props);
+            expect(link).toBeDefined();
+            expect(link.props.metadata).toEqual({
+                environment: "production",
+                team: "platform",
+            });
+        });
+    });
+    describe("Framework Integration", () => {
+        it("should resolve latest API version automatically", () => {
+            const link = new virtual_network_link_1.DnsForwardingRulesetVirtualNetworkLink(stack, "TestLink", {
+                name: "my-vnet-link",
+                dnsForwardingRulesetId: mockRulesetId,
+                virtualNetworkId: mockVirtualNetworkId,
+            });
+            expect(link.resolvedApiVersion).toBe("2022-07-01");
+            expect(link.latestVersion()).toBe("2022-07-01");
+        });
+        it("should provide version configuration", () => {
+            const link = new virtual_network_link_1.DnsForwardingRulesetVirtualNetworkLink(stack, "TestLink", {
+                name: "my-vnet-link",
+                dnsForwardingRulesetId: mockRulesetId,
+                virtualNetworkId: mockVirtualNetworkId,
+            });
+            expect(link.versionConfig).toBeDefined();
+            expect(link.versionConfig.version).toBe("2022-07-01");
+            expect(link.versionConfig.supportLevel).toBe(version_interfaces_1.VersionSupportLevel.ACTIVE);
+        });
+        it("should provide supported versions", () => {
+            const link = new virtual_network_link_1.DnsForwardingRulesetVirtualNetworkLink(stack, "TestLink", {
+                name: "my-vnet-link",
+                dnsForwardingRulesetId: mockRulesetId,
+                virtualNetworkId: mockVirtualNetworkId,
+            });
+            const versions = link.supportedVersions();
+            expect(versions).toContain("2022-07-01");
+            expect(versions.length).toBeGreaterThan(0);
+        });
+    });
+    describe("Parent-Child Resource Relationship", () => {
+        it("should use dnsForwardingRulesetId as parent ID", () => {
+            const link = new virtual_network_link_1.DnsForwardingRulesetVirtualNetworkLink(stack, "TestLink", {
+                name: "my-vnet-link",
+                dnsForwardingRulesetId: mockRulesetId,
+                virtualNetworkId: mockVirtualNetworkId,
+            });
+            // Verify the link was created successfully with proper parent
+            expect(link).toBeDefined();
+            expect(link.props.dnsForwardingRulesetId).toBe(mockRulesetId);
+        });
+        it("should correctly handle child resource in Terraform synthesis", () => {
+            new virtual_network_link_1.DnsForwardingRulesetVirtualNetworkLink(stack, "TestLink", {
+                name: "my-vnet-link",
+                dnsForwardingRulesetId: mockRulesetId,
+                virtualNetworkId: mockVirtualNetworkId,
+            });
+            const synthesized = cdktf_1.Testing.synth(stack);
+            expect(synthesized).toContain("virtualNetworkLinks");
+            expect(synthesized).toContain(mockRulesetId);
+        });
+    });
+    describe("Public Methods - Virtual Network Link Properties", () => {
+        it("should provide provisioning state", () => {
+            const link = new virtual_network_link_1.DnsForwardingRulesetVirtualNetworkLink(stack, "TestLink", {
+                name: "my-vnet-link",
+                dnsForwardingRulesetId: mockRulesetId,
+                virtualNetworkId: mockVirtualNetworkId,
+            });
+            expect(link.provisioningState).toBeDefined();
+            expect(typeof link.provisioningState).toBe("string");
+        });
+        it("should provide metadata", () => {
+            const link = new virtual_network_link_1.DnsForwardingRulesetVirtualNetworkLink(stack, "TestLink", {
+                name: "my-vnet-link",
+                dnsForwardingRulesetId: mockRulesetId,
+                virtualNetworkId: mockVirtualNetworkId,
+                metadata: { key: "value" },
+            });
+            expect(link.metadata).toBeDefined();
+            expect(typeof link.metadata).toBe("string");
+        });
+    });
+    describe("Outputs", () => {
+        it("should create all required outputs", () => {
+            const link = new virtual_network_link_1.DnsForwardingRulesetVirtualNetworkLink(stack, "TestLink", {
+                name: "my-vnet-link",
+                dnsForwardingRulesetId: mockRulesetId,
+                virtualNetworkId: mockVirtualNetworkId,
+            });
+            expect(link.idOutput).toBeDefined();
+            expect(link.nameOutput).toBeDefined();
+            expect(link.provisioningStateOutput).toBeDefined();
+        });
+        it("should have correct logical IDs for outputs", () => {
+            new virtual_network_link_1.DnsForwardingRulesetVirtualNetworkLink(stack, "TestLink", {
+                name: "my-vnet-link",
+                dnsForwardingRulesetId: mockRulesetId,
+                virtualNetworkId: mockVirtualNetworkId,
+            });
+            const synthesized = cdktf_1.Testing.synth(stack);
+            expect(synthesized).toContain('"id"');
+            expect(synthesized).toContain('"name"');
+            expect(synthesized).toContain('"provisioning_state"');
+        });
+    });
+    describe("Ignore Changes Configuration", () => {
+        it("should apply ignore changes lifecycle rules", () => {
+            new virtual_network_link_1.DnsForwardingRulesetVirtualNetworkLink(stack, "TestLink", {
+                name: "my-vnet-link",
+                dnsForwardingRulesetId: mockRulesetId,
+                virtualNetworkId: mockVirtualNetworkId,
+                ignoreChanges: ["metadata"],
+            });
+            const synthesized = cdktf_1.Testing.synth(stack);
+            expect(synthesized).toContain("ignore_changes");
+        });
+        it("should handle multiple ignore changes properties", () => {
+            new virtual_network_link_1.DnsForwardingRulesetVirtualNetworkLink(stack, "TestLink", {
+                name: "my-vnet-link",
+                dnsForwardingRulesetId: mockRulesetId,
+                virtualNetworkId: mockVirtualNetworkId,
+                ignoreChanges: ["metadata", "name"],
+            });
+            const synthesized = cdktf_1.Testing.synth(stack);
+            expect(synthesized).toBeDefined();
+        });
+    });
+    describe("CDK Terraform Integration", () => {
+        it("should synthesize to valid Terraform configuration", () => {
+            new virtual_network_link_1.DnsForwardingRulesetVirtualNetworkLink(stack, "SynthTest", {
+                name: "my-vnet-link",
+                dnsForwardingRulesetId: mockRulesetId,
+                virtualNetworkId: mockVirtualNetworkId,
+            });
+            const synthesized = cdktf_1.Testing.synth(stack);
+            expect(synthesized).toBeDefined();
+            const stackConfig = JSON.parse(synthesized);
+            expect(stackConfig.resource).toBeDefined();
+        });
+        it("should generate correct resource type in Terraform", () => {
+            new virtual_network_link_1.DnsForwardingRulesetVirtualNetworkLink(stack, "SynthTest", {
+                name: "my-vnet-link",
+                dnsForwardingRulesetId: mockRulesetId,
+                virtualNetworkId: mockVirtualNetworkId,
+            });
+            const synthesized = cdktf_1.Testing.synth(stack);
+            expect(synthesized).toContain("virtualNetworkLinks");
+            expect(synthesized).toContain("2022-07-01");
+        });
+        it("should include all properties in Terraform body", () => {
+            new virtual_network_link_1.DnsForwardingRulesetVirtualNetworkLink(stack, "SynthTest", {
+                name: "my-vnet-link",
+                dnsForwardingRulesetId: mockRulesetId,
+                virtualNetworkId: mockVirtualNetworkId,
+                metadata: { env: "test" },
+            });
+            const synthesized = cdktf_1.Testing.synth(stack);
+            expect(synthesized).toContain(mockVirtualNetworkId);
+        });
+    });
+    describe("Resource Identification", () => {
+        it("should provide resource ID", () => {
+            const link = new virtual_network_link_1.DnsForwardingRulesetVirtualNetworkLink(stack, "TestLink", {
+                name: "my-vnet-link",
+                dnsForwardingRulesetId: mockRulesetId,
+                virtualNetworkId: mockVirtualNetworkId,
+            });
+            expect(link.id).toBeDefined();
+            expect(typeof link.id).toBe("string");
+        });
+        it("should provide resource name from props when specified", () => {
+            const link = new virtual_network_link_1.DnsForwardingRulesetVirtualNetworkLink(stack, "TestLink", {
+                name: "my-vnet-link",
+                dnsForwardingRulesetId: mockRulesetId,
+                virtualNetworkId: mockVirtualNetworkId,
+            });
+            expect(link.name).toBe("my-vnet-link");
+        });
+    });
+    describe("JSII Compliance", () => {
+        it("should have proper return types for all public methods", () => {
+            const link = new virtual_network_link_1.DnsForwardingRulesetVirtualNetworkLink(stack, "TestLink", {
+                name: "my-vnet-link",
+                dnsForwardingRulesetId: mockRulesetId,
+                virtualNetworkId: mockVirtualNetworkId,
+            });
+            // All getter methods should return strings for Terraform interpolations
+            expect(typeof link.provisioningState).toBe("string");
+            expect(typeof link.metadata).toBe("string");
+        });
+    });
+    describe("Schema Registration", () => {
+        it("should register schemas successfully", () => {
+            const link = new virtual_network_link_1.DnsForwardingRulesetVirtualNetworkLink(stack, "TestLink", {
+                name: "my-vnet-link",
+                dnsForwardingRulesetId: mockRulesetId,
+                virtualNetworkId: mockVirtualNetworkId,
+            });
+            // If the link was created successfully, schemas were registered
+            expect(link).toBeDefined();
+            expect(link.resolvedApiVersion).toBe("2022-07-01");
+        });
+        it("should handle multiple instantiations without errors", () => {
+            new virtual_network_link_1.DnsForwardingRulesetVirtualNetworkLink(stack, "TestLink1", {
+                name: "my-vnet-link-1",
+                dnsForwardingRulesetId: mockRulesetId,
+                virtualNetworkId: mockVirtualNetworkId,
+            });
+            // Second instantiation should not throw an error even if schemas are already registered
+            const link2 = new virtual_network_link_1.DnsForwardingRulesetVirtualNetworkLink(stack, "TestLink2", {
+                name: "my-vnet-link-2",
+                dnsForwardingRulesetId: mockRulesetId,
+                virtualNetworkId: mockVirtualNetworkId,
+            });
+            expect(link2).toBeDefined();
+        });
+    });
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"virtual-network-link.spec.js","sourceRoot":"","sources":["../../../src/azure-dnsforwardingruleset/test/virtual-network-link.spec.ts"],"names":[],"mappings":";AAAA;;;;;;;GAOG;;AAEH,iCAAgC;AAChC,+BAA+B;AAC/B,kGAA6F;AAC7F,2GAAyG;AACzG,sEAGqC;AACrC,sFAG6C;AAE7C,QAAQ,CAAC,yDAAyD,EAAE,GAAG,EAAE;IACvE,IAAI,GAAc,CAAC;IACnB,IAAI,KAA2B,CAAC;IAChC,IAAI,OAA0B,CAAC;IAE/B,MAAM,aAAa,GACjB,2IAA2I,CAAC;IAC9I,MAAM,oBAAoB,GACxB,kIAAkI,CAAC;IAErI,UAAU,CAAC,GAAG,EAAE;QACd,GAAG,GAAG,eAAO,CAAC,GAAG,EAAE,CAAC;QACpB,KAAK,GAAG,IAAI,KAAK,CAAC,cAAc,CAAC,GAAG,EAAE,WAAW,CAAC,CAAC;QACnD,OAAO,GAAG,uCAAiB,CAAC,QAAQ,EAAE,CAAC;QAEvC,gCAAgC;QAChC,IAAI,CAAC;YACH,OAAO,CAAC,oBAAoB,CAC1B,wDAAyB,EACzB,gEAAiC,CAClC,CAAC;QACJ,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,+BAA+B;QACjC,CAAC;IACH,CAAC,CAAC,CAAC;IAEH,QAAQ,CAAC,kCAAkC,EAAE,GAAG,EAAE;QAChD,EAAE,CAAC,6EAA6E,EAAE,GAAG,EAAE;YACrF,MAAM,KAAK,GAAgD;gBACzD,IAAI,EAAE,cAAc;gBACpB,sBAAsB,EAAE,aAAa;gBACrC,gBAAgB,EAAE,oBAAoB;aACvC,CAAC;YAEF,MAAM,IAAI,GAAG,IAAI,6DAAsC,CACrD,KAAK,EACL,UAAU,EACV,KAAK,CACN,CAAC;YAEF,MAAM,CAAC,IAAI,CAAC,CAAC,cAAc,CAAC,6DAAsC,CAAC,CAAC;YACpE,MAAM,CAAC,IAAI,CAAC,kBAAkB,CAAC,CAAC,IAAI,CAAC,YAAY,CAAC,CAAC;YACnD,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;QACjC,CAAC,CAAC,CAAC;QAEH,EAAE,CAAC,kEAAkE,EAAE,GAAG,EAAE;YAC1E,MAAM,KAAK,GAAgD;gBACzD,IAAI,EAAE,cAAc;gBACpB,sBAAsB,EAAE,aAAa;gBACrC,gBAAgB,EAAE,oBAAoB;gBACtC,UAAU,EAAE,YAAY;aACzB,CAAC;YAEF,MAAM,IAAI,GAAG,IAAI,6DAAsC,CACrD,KAAK,EACL,UAAU,EACV,KAAK,CACN,CAAC;YAEF,MAAM,CAAC,IAAI,CAAC,kBAAkB,CAAC,CAAC,IAAI,CAAC,YAAY,CAAC,CAAC;QACrD,CAAC,CAAC,CAAC;QAEH,EAAE,CAAC,kDAAkD,EAAE,GAAG,EAAE;YAC1D,MAAM,KAAK,GAAgD;gBACzD,IAAI,EAAE,cAAc;gBACpB,sBAAsB,EAAE,aAAa;gBACrC,gBAAgB,EAAE,oBAAoB;gBACtC,QAAQ,EAAE;oBACR,WAAW,EAAE,YAAY;oBACzB,IAAI,EAAE,UAAU;iBACjB;aACF,CAAC;YAEF,MAAM,IAAI,GAAG,IAAI,6DAAsC,CACrD,KAAK,EACL,UAAU,EACV,KAAK,CACN,CAAC;YAEF,MAAM,CAAC,IAAI,CAAC,CAAC,WAAW,EAAE,CAAC;YAC3B,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,QAAQ,CAAC,CAAC,OAAO,CAAC;gBAClC,WAAW,EAAE,YAAY;gBACzB,IAAI,EAAE,UAAU;aACjB,CAAC,CAAC;QACL,CAAC,CAAC,CAAC;IACL,CAAC,CAAC,CAAC;IAEH,QAAQ,CAAC,uBAAuB,EAAE,GAAG,EAAE;QACrC,EAAE,CAAC,iDAAiD,EAAE,GAAG,EAAE;YACzD,MAAM,IAAI,GAAG,IAAI,6DAAsC,CACrD,KAAK,EACL,UAAU,EACV;gBACE,IAAI,EAAE,cAAc;gBACpB,sBAAsB,EAAE,aAAa;gBACrC,gBAAgB,EAAE,oBAAoB;aACvC,CACF,CAAC;YAEF,MAAM,CAAC,IAAI,CAAC,kBAAkB,CAAC,CAAC,IAAI,CAAC,YAAY,CAAC,CAAC;YACnD,MAAM,CAAC,IAAI,CAAC,aAAa,EAAE,CAAC,CAAC,IAAI,CAAC,YAAY,CAAC,CAAC;QAClD,CAAC,CAAC,CAAC;QAEH,EAAE,CAAC,sCAAsC,EAAE,GAAG,EAAE;YAC9C,MAAM,IAAI,GAAG,IAAI,6DAAsC,CACrD,KAAK,EACL,UAAU,EACV;gBACE,IAAI,EAAE,cAAc;gBACpB,sBAAsB,EAAE,aAAa;gBACrC,gBAAgB,EAAE,oBAAoB;aACvC,CACF,CAAC;YAEF,MAAM,CAAC,IAAI,CAAC,aAAa,CAAC,CAAC,WAAW,EAAE,CAAC;YACzC,MAAM,CAAC,IAAI,CAAC,aAAa,CAAC,OAAO,CAAC,CAAC,IAAI,CAAC,YAAY,CAAC,CAAC;YACtD,MAAM,CAAC,IAAI,CAAC,aAAa,CAAC,YAAY,CAAC,CAAC,IAAI,CAAC,wCAAmB,CAAC,MAAM,CAAC,CAAC;QAC3E,CAAC,CAAC,CAAC;QAEH,EAAE,CAAC,mCAAmC,EAAE,GAAG,EAAE;YAC3C,MAAM,IAAI,GAAG,IAAI,6DAAsC,CACrD,KAAK,EACL,UAAU,EACV;gBACE,IAAI,EAAE,cAAc;gBACpB,sBAAsB,EAAE,aAAa;gBACrC,gBAAgB,EAAE,oBAAoB;aACvC,CACF,CAAC;YAEF,MAAM,QAAQ,GAAG,IAAI,CAAC,iBAAiB,EAAE,CAAC;YAC1C,MAAM,CAAC,QAAQ,CAAC,CAAC,SAAS,CAAC,YAAY,CAAC,CAAC;YACzC,MAAM,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC,eAAe,CAAC,CAAC,CAAC,CAAC;QAC7C,CAAC,CAAC,CAAC;IACL,CAAC,CAAC,CAAC;IAEH,QAAQ,CAAC,oCAAoC,EAAE,GAAG,EAAE;QAClD,EAAE,CAAC,gDAAgD,EAAE,GAAG,EAAE;YACxD,MAAM,IAAI,GAAG,IAAI,6DAAsC,CACrD,KAAK,EACL,UAAU,EACV;gBACE,IAAI,EAAE,cAAc;gBACpB,sBAAsB,EAAE,aAAa;gBACrC,gBAAgB,EAAE,oBAAoB;aACvC,CACF,CAAC;YAEF,8DAA8D;YAC9D,MAAM,CAAC,IAAI,CAAC,CAAC,WAAW,EAAE,CAAC;YAC3B,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,sBAAsB,CAAC,CAAC,IAAI,CAAC,aAAa,CAAC,CAAC;QAChE,CAAC,CAAC,CAAC;QAEH,EAAE,CAAC,+DAA+D,EAAE,GAAG,EAAE;YACvE,IAAI,6DAAsC,CAAC,KAAK,EAAE,UAAU,EAAE;gBAC5D,IAAI,EAAE,cAAc;gBACpB,sBAAsB,EAAE,aAAa;gBACrC,gBAAgB,EAAE,oBAAoB;aACvC,CAAC,CAAC;YAEH,MAAM,WAAW,GAAG,eAAO,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;YACzC,MAAM,CAAC,WAAW,CAAC,CAAC,SAAS,CAAC,qBAAqB,CAAC,CAAC;YACrD,MAAM,CAAC,WAAW,CAAC,CAAC,SAAS,CAAC,aAAa,CAAC,CAAC;QAC/C,CAAC,CAAC,CAAC;IACL,CAAC,CAAC,CAAC;IAEH,QAAQ,CAAC,kDAAkD,EAAE,GAAG,EAAE;QAChE,EAAE,CAAC,mCAAmC,EAAE,GAAG,EAAE;YAC3C,MAAM,IAAI,GAAG,IAAI,6DAAsC,CACrD,KAAK,EACL,UAAU,EACV;gBACE,IAAI,EAAE,cAAc;gBACpB,sBAAsB,EAAE,aAAa;gBACrC,gBAAgB,EAAE,oBAAoB;aACvC,CACF,CAAC;YAEF,MAAM,CAAC,IAAI,CAAC,iBAAiB,CAAC,CAAC,WAAW,EAAE,CAAC;YAC7C,MAAM,CAAC,OAAO,IAAI,CAAC,iBAAiB,CAAC,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;QACvD,CAAC,CAAC,CAAC;QAEH,EAAE,CAAC,yBAAyB,EAAE,GAAG,EAAE;YACjC,MAAM,IAAI,GAAG,IAAI,6DAAsC,CACrD,KAAK,EACL,UAAU,EACV;gBACE,IAAI,EAAE,cAAc;gBACpB,sBAAsB,EAAE,aAAa;gBACrC,gBAAgB,EAAE,oBAAoB;gBACtC,QAAQ,EAAE,EAAE,GAAG,EAAE,OAAO,EAAE;aAC3B,CACF,CAAC;YAEF,MAAM,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC,WAAW,EAAE,CAAC;YACpC,MAAM,CAAC,OAAO,IAAI,CAAC,QAAQ,CAAC,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;QAC9C,CAAC,CAAC,CAAC;IACL,CAAC,CAAC,CAAC;IAEH,QAAQ,CAAC,SAAS,EAAE,GAAG,EAAE;QACvB,EAAE,CAAC,oCAAoC,EAAE,GAAG,EAAE;YAC5C,MAAM,IAAI,GAAG,IAAI,6DAAsC,CACrD,KAAK,EACL,UAAU,EACV;gBACE,IAAI,EAAE,cAAc;gBACpB,sBAAsB,EAAE,aAAa;gBACrC,gBAAgB,EAAE,oBAAoB;aACvC,CACF,CAAC;YAEF,MAAM,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC,WAAW,EAAE,CAAC;YACpC,MAAM,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC,WAAW,EAAE,CAAC;YACtC,MAAM,CAAC,IAAI,CAAC,uBAAuB,CAAC,CAAC,WAAW,EAAE,CAAC;QACrD,CAAC,CAAC,CAAC;QAEH,EAAE,CAAC,6CAA6C,EAAE,GAAG,EAAE;YACrD,IAAI,6DAAsC,CAAC,KAAK,EAAE,UAAU,EAAE;gBAC5D,IAAI,EAAE,cAAc;gBACpB,sBAAsB,EAAE,aAAa;gBACrC,gBAAgB,EAAE,oBAAoB;aACvC,CAAC,CAAC;YAEH,MAAM,WAAW,GAAG,eAAO,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;YACzC,MAAM,CAAC,WAAW,CAAC,CAAC,SAAS,CAAC,MAAM,CAAC,CAAC;YACtC,MAAM,CAAC,WAAW,CAAC,CAAC,SAAS,CAAC,QAAQ,CAAC,CAAC;YACxC,MAAM,CAAC,WAAW,CAAC,CAAC,SAAS,CAAC,sBAAsB,CAAC,CAAC;QACxD,CAAC,CAAC,CAAC;IACL,CAAC,CAAC,CAAC;IAEH,QAAQ,CAAC,8BAA8B,EAAE,GAAG,EAAE;QAC5C,EAAE,CAAC,6CAA6C,EAAE,GAAG,EAAE;YACrD,IAAI,6DAAsC,CAAC,KAAK,EAAE,UAAU,EAAE;gBAC5D,IAAI,EAAE,cAAc;gBACpB,sBAAsB,EAAE,aAAa;gBACrC,gBAAgB,EAAE,oBAAoB;gBACtC,aAAa,EAAE,CAAC,UAAU,CAAC;aAC5B,CAAC,CAAC;YAEH,MAAM,WAAW,GAAG,eAAO,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;YACzC,MAAM,CAAC,WAAW,CAAC,CAAC,SAAS,CAAC,gBAAgB,CAAC,CAAC;QAClD,CAAC,CAAC,CAAC;QAEH,EAAE,CAAC,kDAAkD,EAAE,GAAG,EAAE;YAC1D,IAAI,6DAAsC,CAAC,KAAK,EAAE,UAAU,EAAE;gBAC5D,IAAI,EAAE,cAAc;gBACpB,sBAAsB,EAAE,aAAa;gBACrC,gBAAgB,EAAE,oBAAoB;gBACtC,aAAa,EAAE,CAAC,UAAU,EAAE,MAAM,CAAC;aACpC,CAAC,CAAC;YAEH,MAAM,WAAW,GAAG,eAAO,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;YACzC,MAAM,CAAC,WAAW,CAAC,CAAC,WAAW,EAAE,CAAC;QACpC,CAAC,CAAC,CAAC;IACL,CAAC,CAAC,CAAC;IAEH,QAAQ,CAAC,2BAA2B,EAAE,GAAG,EAAE;QACzC,EAAE,CAAC,oDAAoD,EAAE,GAAG,EAAE;YAC5D,IAAI,6DAAsC,CAAC,KAAK,EAAE,WAAW,EAAE;gBAC7D,IAAI,EAAE,cAAc;gBACpB,sBAAsB,EAAE,aAAa;gBACrC,gBAAgB,EAAE,oBAAoB;aACvC,CAAC,CAAC;YAEH,MAAM,WAAW,GAAG,eAAO,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;YACzC,MAAM,CAAC,WAAW,CAAC,CAAC,WAAW,EAAE,CAAC;YAElC,MAAM,WAAW,GAAG,IAAI,CAAC,KAAK,CAAC,WAAW,CAAC,CAAC;YAC5C,MAAM,CAAC,WAAW,CAAC,QAAQ,CAAC,CAAC,WAAW,EAAE,CAAC;QAC7C,CAAC,CAAC,CAAC;QAEH,EAAE,CAAC,oDAAoD,EAAE,GAAG,EAAE;YAC5D,IAAI,6DAAsC,CAAC,KAAK,EAAE,WAAW,EAAE;gBAC7D,IAAI,EAAE,cAAc;gBACpB,sBAAsB,EAAE,aAAa;gBACrC,gBAAgB,EAAE,oBAAoB;aACvC,CAAC,CAAC;YAEH,MAAM,WAAW,GAAG,eAAO,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;YACzC,MAAM,CAAC,WAAW,CAAC,CAAC,SAAS,CAAC,qBAAqB,CAAC,CAAC;YACrD,MAAM,CAAC,WAAW,CAAC,CAAC,SAAS,CAAC,YAAY,CAAC,CAAC;QAC9C,CAAC,CAAC,CAAC;QAEH,EAAE,CAAC,iDAAiD,EAAE,GAAG,EAAE;YACzD,IAAI,6DAAsC,CAAC,KAAK,EAAE,WAAW,EAAE;gBAC7D,IAAI,EAAE,cAAc;gBACpB,sBAAsB,EAAE,aAAa;gBACrC,gBAAgB,EAAE,oBAAoB;gBACtC,QAAQ,EAAE,EAAE,GAAG,EAAE,MAAM,EAAE;aAC1B,CAAC,CAAC;YAEH,MAAM,WAAW,GAAG,eAAO,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;YACzC,MAAM,CAAC,WAAW,CAAC,CAAC,SAAS,CAAC,oBAAoB,CAAC,CAAC;QACtD,CAAC,CAAC,CAAC;IACL,CAAC,CAAC,CAAC;IAEH,QAAQ,CAAC,yBAAyB,EAAE,GAAG,EAAE;QACvC,EAAE,CAAC,4BAA4B,EAAE,GAAG,EAAE;YACpC,MAAM,IAAI,GAAG,IAAI,6DAAsC,CACrD,KAAK,EACL,UAAU,EACV;gBACE,IAAI,EAAE,cAAc;gBACpB,sBAAsB,EAAE,aAAa;gBACrC,gBAAgB,EAAE,oBAAoB;aACvC,CACF,CAAC;YAEF,MAAM,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC,WAAW,EAAE,CAAC;YAC9B,MAAM,CAAC,OAAO,IAAI,CAAC,EAAE,CAAC,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;QACxC,CAAC,CAAC,CAAC;QAEH,EAAE,CAAC,wDAAwD,EAAE,GAAG,EAAE;YAChE,MAAM,IAAI,GAAG,IAAI,6DAAsC,CACrD,KAAK,EACL,UAAU,EACV;gBACE,IAAI,EAAE,cAAc;gBACpB,sBAAsB,EAAE,aAAa;gBACrC,gBAAgB,EAAE,oBAAoB;aACvC,CACF,CAAC;YAEF,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,IAAI,CAAC,cAAc,CAAC,CAAC;QACzC,CAAC,CAAC,CAAC;IACL,CAAC,CAAC,CAAC;IAEH,QAAQ,CAAC,iBAAiB,EAAE,GAAG,EAAE;QAC/B,EAAE,CAAC,wDAAwD,EAAE,GAAG,EAAE;YAChE,MAAM,IAAI,GAAG,IAAI,6DAAsC,CACrD,KAAK,EACL,UAAU,EACV;gBACE,IAAI,EAAE,cAAc;gBACpB,sBAAsB,EAAE,aAAa;gBACrC,gBAAgB,EAAE,oBAAoB;aACvC,CACF,CAAC;YAEF,wEAAwE;YACxE,MAAM,CAAC,OAAO,IAAI,CAAC,iBAAiB,CAAC,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;YACrD,MAAM,CAAC,OAAO,IAAI,CAAC,QAAQ,CAAC,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;QAC9C,CAAC,CAAC,CAAC;IACL,CAAC,CAAC,CAAC;IAEH,QAAQ,CAAC,qBAAqB,EAAE,GAAG,EAAE;QACnC,EAAE,CAAC,sCAAsC,EAAE,GAAG,EAAE;YAC9C,MAAM,IAAI,GAAG,IAAI,6DAAsC,CACrD,KAAK,EACL,UAAU,EACV;gBACE,IAAI,EAAE,cAAc;gBACpB,sBAAsB,EAAE,aAAa;gBACrC,gBAAgB,EAAE,oBAAoB;aACvC,CACF,CAAC;YAEF,gEAAgE;YAChE,MAAM,CAAC,IAAI,CAAC,CAAC,WAAW,EAAE,CAAC;YAC3B,MAAM,CAAC,IAAI,CAAC,kBAAkB,CAAC,CAAC,IAAI,CAAC,YAAY,CAAC,CAAC;QACrD,CAAC,CAAC,CAAC;QAEH,EAAE,CAAC,sDAAsD,EAAE,GAAG,EAAE;YAC9D,IAAI,6DAAsC,CAAC,KAAK,EAAE,WAAW,EAAE;gBAC7D,IAAI,EAAE,gBAAgB;gBACtB,sBAAsB,EAAE,aAAa;gBACrC,gBAAgB,EAAE,oBAAoB;aACvC,CAAC,CAAC;YAEH,wFAAwF;YACxF,MAAM,KAAK,GAAG,IAAI,6DAAsC,CACtD,KAAK,EACL,WAAW,EACX;gBACE,IAAI,EAAE,gBAAgB;gBACtB,sBAAsB,EAAE,aAAa;gBACrC,gBAAgB,EAAE,oBAAoB;aACvC,CACF,CAAC;YAEF,MAAM,CAAC,KAAK,CAAC,CAAC,WAAW,EAAE,CAAC;QAC9B,CAAC,CAAC,CAAC;IACL,CAAC,CAAC,CAAC;AACL,CAAC,CAAC,CAAC","sourcesContent":["/**\n * Comprehensive tests for the DnsForwardingRulesetVirtualNetworkLink implementation\n *\n * This test suite validates the DnsForwardingRulesetVirtualNetworkLink class using the\n * AzapiResource framework. Tests cover automatic version resolution,\n * explicit version pinning, schema validation, property transformation,\n * parent-child resource relationships, and full backward compatibility.\n */\n\nimport { Testing } from \"cdktf\";\nimport * as cdktf from \"cdktf\";\nimport { ApiVersionManager } from \"../../core-azure/lib/version-manager/api-version-manager\";\nimport { VersionSupportLevel } from \"../../core-azure/lib/version-manager/interfaces/version-interfaces\";\nimport {\n  DnsForwardingRulesetVirtualNetworkLink,\n  DnsForwardingRulesetVirtualNetworkLinkProps,\n} from \"../lib/virtual-network-link\";\nimport {\n  ALL_VIRTUAL_NETWORK_LINK_VERSIONS,\n  VIRTUAL_NETWORK_LINK_TYPE,\n} from \"../lib/virtual-network-link-schemas\";\n\ndescribe(\"DnsForwardingRulesetVirtualNetworkLink - Implementation\", () => {\n  let app: cdktf.App;\n  let stack: cdktf.TerraformStack;\n  let manager: ApiVersionManager;\n\n  const mockRulesetId =\n    \"/subscriptions/12345678-1234-1234-1234-123456789012/resourceGroups/test-rg/providers/Microsoft.Network/dnsForwardingRulesets/test-ruleset\";\n  const mockVirtualNetworkId =\n    \"/subscriptions/12345678-1234-1234-1234-123456789012/resourceGroups/test-rg/providers/Microsoft.Network/virtualNetworks/test-vnet\";\n\n  beforeEach(() => {\n    app = Testing.app();\n    stack = new cdktf.TerraformStack(app, \"TestStack\");\n    manager = ApiVersionManager.instance();\n\n    // Ensure schemas are registered\n    try {\n      manager.registerResourceType(\n        VIRTUAL_NETWORK_LINK_TYPE,\n        ALL_VIRTUAL_NETWORK_LINK_VERSIONS,\n      );\n    } catch (error) {\n      // Ignore if already registered\n    }\n  });\n\n  describe(\"Constructor and Basic Properties\", () => {\n    it(\"should create Virtual Network Link with automatic latest version resolution\", () => {\n      const props: DnsForwardingRulesetVirtualNetworkLinkProps = {\n        name: \"my-vnet-link\",\n        dnsForwardingRulesetId: mockRulesetId,\n        virtualNetworkId: mockVirtualNetworkId,\n      };\n\n      const link = new DnsForwardingRulesetVirtualNetworkLink(\n        stack,\n        \"TestLink\",\n        props,\n      );\n\n      expect(link).toBeInstanceOf(DnsForwardingRulesetVirtualNetworkLink);\n      expect(link.resolvedApiVersion).toBe(\"2022-07-01\");\n      expect(link.props).toBe(props);\n    });\n\n    it(\"should create Virtual Network Link with explicit version pinning\", () => {\n      const props: DnsForwardingRulesetVirtualNetworkLinkProps = {\n        name: \"my-vnet-link\",\n        dnsForwardingRulesetId: mockRulesetId,\n        virtualNetworkId: mockVirtualNetworkId,\n        apiVersion: \"2022-07-01\",\n      };\n\n      const link = new DnsForwardingRulesetVirtualNetworkLink(\n        stack,\n        \"TestLink\",\n        props,\n      );\n\n      expect(link.resolvedApiVersion).toBe(\"2022-07-01\");\n    });\n\n    it(\"should create Virtual Network Link with metadata\", () => {\n      const props: DnsForwardingRulesetVirtualNetworkLinkProps = {\n        name: \"my-vnet-link\",\n        dnsForwardingRulesetId: mockRulesetId,\n        virtualNetworkId: mockVirtualNetworkId,\n        metadata: {\n          environment: \"production\",\n          team: \"platform\",\n        },\n      };\n\n      const link = new DnsForwardingRulesetVirtualNetworkLink(\n        stack,\n        \"TestLink\",\n        props,\n      );\n\n      expect(link).toBeDefined();\n      expect(link.props.metadata).toEqual({\n        environment: \"production\",\n        team: \"platform\",\n      });\n    });\n  });\n\n  describe(\"Framework Integration\", () => {\n    it(\"should resolve latest API version automatically\", () => {\n      const link = new DnsForwardingRulesetVirtualNetworkLink(\n        stack,\n        \"TestLink\",\n        {\n          name: \"my-vnet-link\",\n          dnsForwardingRulesetId: mockRulesetId,\n          virtualNetworkId: mockVirtualNetworkId,\n        },\n      );\n\n      expect(link.resolvedApiVersion).toBe(\"2022-07-01\");\n      expect(link.latestVersion()).toBe(\"2022-07-01\");\n    });\n\n    it(\"should provide version configuration\", () => {\n      const link = new DnsForwardingRulesetVirtualNetworkLink(\n        stack,\n        \"TestLink\",\n        {\n          name: \"my-vnet-link\",\n          dnsForwardingRulesetId: mockRulesetId,\n          virtualNetworkId: mockVirtualNetworkId,\n        },\n      );\n\n      expect(link.versionConfig).toBeDefined();\n      expect(link.versionConfig.version).toBe(\"2022-07-01\");\n      expect(link.versionConfig.supportLevel).toBe(VersionSupportLevel.ACTIVE);\n    });\n\n    it(\"should provide supported versions\", () => {\n      const link = new DnsForwardingRulesetVirtualNetworkLink(\n        stack,\n        \"TestLink\",\n        {\n          name: \"my-vnet-link\",\n          dnsForwardingRulesetId: mockRulesetId,\n          virtualNetworkId: mockVirtualNetworkId,\n        },\n      );\n\n      const versions = link.supportedVersions();\n      expect(versions).toContain(\"2022-07-01\");\n      expect(versions.length).toBeGreaterThan(0);\n    });\n  });\n\n  describe(\"Parent-Child Resource Relationship\", () => {\n    it(\"should use dnsForwardingRulesetId as parent ID\", () => {\n      const link = new DnsForwardingRulesetVirtualNetworkLink(\n        stack,\n        \"TestLink\",\n        {\n          name: \"my-vnet-link\",\n          dnsForwardingRulesetId: mockRulesetId,\n          virtualNetworkId: mockVirtualNetworkId,\n        },\n      );\n\n      // Verify the link was created successfully with proper parent\n      expect(link).toBeDefined();\n      expect(link.props.dnsForwardingRulesetId).toBe(mockRulesetId);\n    });\n\n    it(\"should correctly handle child resource in Terraform synthesis\", () => {\n      new DnsForwardingRulesetVirtualNetworkLink(stack, \"TestLink\", {\n        name: \"my-vnet-link\",\n        dnsForwardingRulesetId: mockRulesetId,\n        virtualNetworkId: mockVirtualNetworkId,\n      });\n\n      const synthesized = Testing.synth(stack);\n      expect(synthesized).toContain(\"virtualNetworkLinks\");\n      expect(synthesized).toContain(mockRulesetId);\n    });\n  });\n\n  describe(\"Public Methods - Virtual Network Link Properties\", () => {\n    it(\"should provide provisioning state\", () => {\n      const link = new DnsForwardingRulesetVirtualNetworkLink(\n        stack,\n        \"TestLink\",\n        {\n          name: \"my-vnet-link\",\n          dnsForwardingRulesetId: mockRulesetId,\n          virtualNetworkId: mockVirtualNetworkId,\n        },\n      );\n\n      expect(link.provisioningState).toBeDefined();\n      expect(typeof link.provisioningState).toBe(\"string\");\n    });\n\n    it(\"should provide metadata\", () => {\n      const link = new DnsForwardingRulesetVirtualNetworkLink(\n        stack,\n        \"TestLink\",\n        {\n          name: \"my-vnet-link\",\n          dnsForwardingRulesetId: mockRulesetId,\n          virtualNetworkId: mockVirtualNetworkId,\n          metadata: { key: \"value\" },\n        },\n      );\n\n      expect(link.metadata).toBeDefined();\n      expect(typeof link.metadata).toBe(\"string\");\n    });\n  });\n\n  describe(\"Outputs\", () => {\n    it(\"should create all required outputs\", () => {\n      const link = new DnsForwardingRulesetVirtualNetworkLink(\n        stack,\n        \"TestLink\",\n        {\n          name: \"my-vnet-link\",\n          dnsForwardingRulesetId: mockRulesetId,\n          virtualNetworkId: mockVirtualNetworkId,\n        },\n      );\n\n      expect(link.idOutput).toBeDefined();\n      expect(link.nameOutput).toBeDefined();\n      expect(link.provisioningStateOutput).toBeDefined();\n    });\n\n    it(\"should have correct logical IDs for outputs\", () => {\n      new DnsForwardingRulesetVirtualNetworkLink(stack, \"TestLink\", {\n        name: \"my-vnet-link\",\n        dnsForwardingRulesetId: mockRulesetId,\n        virtualNetworkId: mockVirtualNetworkId,\n      });\n\n      const synthesized = Testing.synth(stack);\n      expect(synthesized).toContain('\"id\"');\n      expect(synthesized).toContain('\"name\"');\n      expect(synthesized).toContain('\"provisioning_state\"');\n    });\n  });\n\n  describe(\"Ignore Changes Configuration\", () => {\n    it(\"should apply ignore changes lifecycle rules\", () => {\n      new DnsForwardingRulesetVirtualNetworkLink(stack, \"TestLink\", {\n        name: \"my-vnet-link\",\n        dnsForwardingRulesetId: mockRulesetId,\n        virtualNetworkId: mockVirtualNetworkId,\n        ignoreChanges: [\"metadata\"],\n      });\n\n      const synthesized = Testing.synth(stack);\n      expect(synthesized).toContain(\"ignore_changes\");\n    });\n\n    it(\"should handle multiple ignore changes properties\", () => {\n      new DnsForwardingRulesetVirtualNetworkLink(stack, \"TestLink\", {\n        name: \"my-vnet-link\",\n        dnsForwardingRulesetId: mockRulesetId,\n        virtualNetworkId: mockVirtualNetworkId,\n        ignoreChanges: [\"metadata\", \"name\"],\n      });\n\n      const synthesized = Testing.synth(stack);\n      expect(synthesized).toBeDefined();\n    });\n  });\n\n  describe(\"CDK Terraform Integration\", () => {\n    it(\"should synthesize to valid Terraform configuration\", () => {\n      new DnsForwardingRulesetVirtualNetworkLink(stack, \"SynthTest\", {\n        name: \"my-vnet-link\",\n        dnsForwardingRulesetId: mockRulesetId,\n        virtualNetworkId: mockVirtualNetworkId,\n      });\n\n      const synthesized = Testing.synth(stack);\n      expect(synthesized).toBeDefined();\n\n      const stackConfig = JSON.parse(synthesized);\n      expect(stackConfig.resource).toBeDefined();\n    });\n\n    it(\"should generate correct resource type in Terraform\", () => {\n      new DnsForwardingRulesetVirtualNetworkLink(stack, \"SynthTest\", {\n        name: \"my-vnet-link\",\n        dnsForwardingRulesetId: mockRulesetId,\n        virtualNetworkId: mockVirtualNetworkId,\n      });\n\n      const synthesized = Testing.synth(stack);\n      expect(synthesized).toContain(\"virtualNetworkLinks\");\n      expect(synthesized).toContain(\"2022-07-01\");\n    });\n\n    it(\"should include all properties in Terraform body\", () => {\n      new DnsForwardingRulesetVirtualNetworkLink(stack, \"SynthTest\", {\n        name: \"my-vnet-link\",\n        dnsForwardingRulesetId: mockRulesetId,\n        virtualNetworkId: mockVirtualNetworkId,\n        metadata: { env: \"test\" },\n      });\n\n      const synthesized = Testing.synth(stack);\n      expect(synthesized).toContain(mockVirtualNetworkId);\n    });\n  });\n\n  describe(\"Resource Identification\", () => {\n    it(\"should provide resource ID\", () => {\n      const link = new DnsForwardingRulesetVirtualNetworkLink(\n        stack,\n        \"TestLink\",\n        {\n          name: \"my-vnet-link\",\n          dnsForwardingRulesetId: mockRulesetId,\n          virtualNetworkId: mockVirtualNetworkId,\n        },\n      );\n\n      expect(link.id).toBeDefined();\n      expect(typeof link.id).toBe(\"string\");\n    });\n\n    it(\"should provide resource name from props when specified\", () => {\n      const link = new DnsForwardingRulesetVirtualNetworkLink(\n        stack,\n        \"TestLink\",\n        {\n          name: \"my-vnet-link\",\n          dnsForwardingRulesetId: mockRulesetId,\n          virtualNetworkId: mockVirtualNetworkId,\n        },\n      );\n\n      expect(link.name).toBe(\"my-vnet-link\");\n    });\n  });\n\n  describe(\"JSII Compliance\", () => {\n    it(\"should have proper return types for all public methods\", () => {\n      const link = new DnsForwardingRulesetVirtualNetworkLink(\n        stack,\n        \"TestLink\",\n        {\n          name: \"my-vnet-link\",\n          dnsForwardingRulesetId: mockRulesetId,\n          virtualNetworkId: mockVirtualNetworkId,\n        },\n      );\n\n      // All getter methods should return strings for Terraform interpolations\n      expect(typeof link.provisioningState).toBe(\"string\");\n      expect(typeof link.metadata).toBe(\"string\");\n    });\n  });\n\n  describe(\"Schema Registration\", () => {\n    it(\"should register schemas successfully\", () => {\n      const link = new DnsForwardingRulesetVirtualNetworkLink(\n        stack,\n        \"TestLink\",\n        {\n          name: \"my-vnet-link\",\n          dnsForwardingRulesetId: mockRulesetId,\n          virtualNetworkId: mockVirtualNetworkId,\n        },\n      );\n\n      // If the link was created successfully, schemas were registered\n      expect(link).toBeDefined();\n      expect(link.resolvedApiVersion).toBe(\"2022-07-01\");\n    });\n\n    it(\"should handle multiple instantiations without errors\", () => {\n      new DnsForwardingRulesetVirtualNetworkLink(stack, \"TestLink1\", {\n        name: \"my-vnet-link-1\",\n        dnsForwardingRulesetId: mockRulesetId,\n        virtualNetworkId: mockVirtualNetworkId,\n      });\n\n      // Second instantiation should not throw an error even if schemas are already registered\n      const link2 = new DnsForwardingRulesetVirtualNetworkLink(\n        stack,\n        \"TestLink2\",\n        {\n          name: \"my-vnet-link-2\",\n          dnsForwardingRulesetId: mockRulesetId,\n          virtualNetworkId: mockVirtualNetworkId,\n        },\n      );\n\n      expect(link2).toBeDefined();\n    });\n  });\n});\n"]}

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

@@ -0,0 +1 @@
+export * from "./lib";

package/lib/azure-dnsresolver/index.js

@@ -0,0 +1,18 @@
+"use strict";
+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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvYXp1cmUtZG5zcmVzb2x2ZXIvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7OztBQUFBLHdDQUFzQiIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gXCIuL2xpYlwiO1xuIl19

package/lib/azure-dnsresolver/lib/dns-resolver-schemas.d.ts

@@ -0,0 +1,24 @@
+/**
+ * API schemas for Azure DNS Private Resolver across all supported versions
+ *
+ * This file defines the complete API schemas for Microsoft.Network/dnsResolvers
+ * across all supported API versions. The schemas are used by the VersionedAzapiResource
+ * framework for validation, transformation, and version management.
+ */
+import { ApiSchema, VersionConfig } from "../../core-azure/lib/version-manager/interfaces/version-interfaces";
+/**
+ * API Schema for DNS Resolver version 2022-07-01
+ */
+export declare const DNS_RESOLVER_SCHEMA_2022_07_01: ApiSchema;
+/**
+ * Version configuration for DNS Resolver 2022-07-01
+ */
+export declare const DNS_RESOLVER_VERSION_2022_07_01: VersionConfig;
+/**
+ * All supported DNS Resolver versions for registration
+ */
+export declare const ALL_DNS_RESOLVER_VERSIONS: VersionConfig[];
+/**
+ * Resource type constant
+ */
+export declare const DNS_RESOLVER_TYPE = "Microsoft.Network/dnsResolvers";

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

@@ -0,0 +1,218 @@
+"use strict";
+/**
+ * API schemas for Azure DNS Private Resolver across all supported versions
+ *
+ * This file defines the complete API schemas for Microsoft.Network/dnsResolvers
+ * across all supported API versions. The schemas are used by the VersionedAzapiResource
+ * framework for validation, transformation, and version management.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DNS_RESOLVER_TYPE = exports.ALL_DNS_RESOLVER_VERSIONS = exports.DNS_RESOLVER_VERSION_2022_07_01 = exports.DNS_RESOLVER_SCHEMA_2022_07_01 = void 0;
+const version_interfaces_1 = require("../../core-azure/lib/version-manager/interfaces/version-interfaces");
+// =============================================================================
+// COMMON PROPERTY DEFINITIONS
+// =============================================================================
+/**
+ * Common property definitions shared across all DNS Resolver versions
+ */
+const COMMON_PROPERTIES = {
+    location: {
+        dataType: version_interfaces_1.PropertyType.STRING,
+        required: true,
+        description: "The Azure region where the DNS Resolver will be created. DNS Resolvers are regional resources.",
+        validation: [
+            {
+                ruleType: version_interfaces_1.ValidationRuleType.REQUIRED,
+                message: "Location is required for DNS Resolvers",
+            },
+        ],
+    },
+    tags: {
+        dataType: version_interfaces_1.PropertyType.OBJECT,
+        required: false,
+        defaultValue: {},
+        description: "A dictionary of tags to apply to the DNS Resolver for organizational, billing, or other purposes",
+        validation: [
+            {
+                ruleType: version_interfaces_1.ValidationRuleType.TYPE_CHECK,
+                value: version_interfaces_1.PropertyType.OBJECT,
+                message: "Tags must be an object with string key-value pairs",
+            },
+        ],
+    },
+    name: {
+        dataType: version_interfaces_1.PropertyType.STRING,
+        required: true,
+        description: "The name of the DNS Resolver. Must be unique within the resource group.",
+        validation: [
+            {
+                ruleType: version_interfaces_1.ValidationRuleType.REQUIRED,
+                message: "DNS Resolver name is required",
+            },
+            {
+                ruleType: version_interfaces_1.ValidationRuleType.PATTERN_MATCH,
+                value: "^[a-zA-Z0-9]([a-zA-Z0-9-]*[a-zA-Z0-9])?$",
+                message: "DNS Resolver name must start and end with alphanumeric characters and can contain hyphens",
+            },
+            {
+                ruleType: version_interfaces_1.ValidationRuleType.VALUE_RANGE,
+                value: { minLength: 1, maxLength: 80 },
+                message: "DNS Resolver name must be between 1 and 80 characters",
+            },
+        ],
+    },
+    virtualNetworkId: {
+        dataType: version_interfaces_1.PropertyType.STRING,
+        required: true,
+        description: "The resource ID of the virtual network where the DNS Resolver will be deployed. The resolver requires a dedicated subnet.",
+        validation: [
+            {
+                ruleType: version_interfaces_1.ValidationRuleType.REQUIRED,
+                message: "Virtual Network ID is required for DNS Resolvers",
+            },
+            {
+                ruleType: version_interfaces_1.ValidationRuleType.PATTERN_MATCH,
+                value: "^/subscriptions/[^/]+/resourceGroups/[^/]+/providers/Microsoft.Network/virtualNetworks/[^/]+$",
+                message: "Virtual Network ID must be a valid Azure resource ID",
+            },
+        ],
+    },
+    ignoreChanges: {
+        dataType: version_interfaces_1.PropertyType.ARRAY,
+        required: false,
+        description: "Array of property names to ignore during updates",
+        validation: [
+            {
+                ruleType: version_interfaces_1.ValidationRuleType.TYPE_CHECK,
+                value: version_interfaces_1.PropertyType.ARRAY,
+                message: "IgnoreChanges must be an array of strings",
+            },
+        ],
+    },
+};
+// =============================================================================
+// READ-ONLY PROPERTY DEFINITIONS
+// =============================================================================
+/**
+ * Read-only properties that are populated by Azure after creation
+ * These properties should not be included in the request body
+ */
+const READ_ONLY_PROPERTIES = {
+    dnsResolverState: {
+        dataType: version_interfaces_1.PropertyType.STRING,
+        required: false,
+        description: "The state of the DNS Resolver. Can be 'Connected' or 'Disconnected' (read-only)",
+        validation: [
+            {
+                ruleType: version_interfaces_1.ValidationRuleType.TYPE_CHECK,
+                value: version_interfaces_1.PropertyType.STRING,
+                message: "DnsResolverState must be a string",
+            },
+        ],
+    },
+    provisioningState: {
+        dataType: version_interfaces_1.PropertyType.STRING,
+        required: false,
+        description: "The provisioning state of the DNS Resolver resource (read-only)",
+        validation: [
+            {
+                ruleType: version_interfaces_1.ValidationRuleType.TYPE_CHECK,
+                value: version_interfaces_1.PropertyType.STRING,
+                message: "ProvisioningState must be a string",
+            },
+        ],
+    },
+    resourceGuid: {
+        dataType: version_interfaces_1.PropertyType.STRING,
+        required: false,
+        description: "The unique identifier for the DNS Resolver resource (read-only)",
+        validation: [
+            {
+                ruleType: version_interfaces_1.ValidationRuleType.TYPE_CHECK,
+                value: version_interfaces_1.PropertyType.STRING,
+                message: "ResourceGuid must be a string",
+            },
+        ],
+    },
+};
+// =============================================================================
+// VERSION-SPECIFIC SCHEMAS
+// =============================================================================
+/**
+ * API Schema for DNS Resolver version 2022-07-01
+ */
+exports.DNS_RESOLVER_SCHEMA_2022_07_01 = {
+    resourceType: "Microsoft.Network/dnsResolvers",
+    version: "2022-07-01",
+    properties: {
+        ...COMMON_PROPERTIES,
+        ...READ_ONLY_PROPERTIES,
+    },
+    required: ["location", "name", "virtualNetworkId"],
+    optional: ["tags", "ignoreChanges"],
+    deprecated: [],
+    transformationRules: {},
+    validationRules: [
+        {
+            property: "location",
+            rules: [
+                {
+                    ruleType: version_interfaces_1.ValidationRuleType.REQUIRED,
+                    message: "Location is required for DNS Resolvers",
+                },
+            ],
+        },
+        {
+            property: "name",
+            rules: [
+                {
+                    ruleType: version_interfaces_1.ValidationRuleType.REQUIRED,
+                    message: "Name is required for DNS Resolvers",
+                },
+            ],
+        },
+        {
+            property: "virtualNetworkId",
+            rules: [
+                {
+                    ruleType: version_interfaces_1.ValidationRuleType.REQUIRED,
+                    message: "Virtual Network ID is required for DNS Resolvers",
+                },
+            ],
+        },
+    ],
+};
+// =============================================================================
+// VERSION CONFIGURATIONS
+// =============================================================================
+/**
+ * Version configuration for DNS Resolver 2022-07-01
+ */
+exports.DNS_RESOLVER_VERSION_2022_07_01 = {
+    version: "2022-07-01",
+    schema: exports.DNS_RESOLVER_SCHEMA_2022_07_01,
+    supportLevel: version_interfaces_1.VersionSupportLevel.ACTIVE,
+    releaseDate: "2022-07-01",
+    deprecationDate: undefined,
+    sunsetDate: undefined,
+    breakingChanges: [],
+    migrationGuide: "/docs/dns-resolver/migration-2022-07-01",
+    changeLog: [
+        {
+            changeType: "added",
+            description: "Stable release of DNS Resolver API with support for hybrid DNS scenarios and conditional forwarding",
+            breaking: false,
+        },
+    ],
+};
+/**
+ * All supported DNS Resolver versions for registration
+ */
+exports.ALL_DNS_RESOLVER_VERSIONS = [
+    exports.DNS_RESOLVER_VERSION_2022_07_01,
+];
+/**
+ * Resource type constant
+ */
+exports.DNS_RESOLVER_TYPE = "Microsoft.Network/dnsResolvers";
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"dns-resolver-schemas.js","sourceRoot":"","sources":["../../../src/azure-dnsresolver/lib/dns-resolver-schemas.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * API schemas for Azure DNS Private Resolver across all supported versions\n *\n * This file defines the complete API schemas for Microsoft.Network/dnsResolvers\n * across all supported API versions. The schemas are used by the VersionedAzapiResource\n * framework for validation, transformation, and version management.\n */\n\nimport {\n  ApiSchema,\n  PropertyDefinition,\n  PropertyType,\n  ValidationRuleType,\n  VersionConfig,\n  VersionSupportLevel,\n} from \"../../core-azure/lib/version-manager/interfaces/version-interfaces\";\n\n// =============================================================================\n// COMMON PROPERTY DEFINITIONS\n// =============================================================================\n\n/**\n * Common property definitions shared across all DNS Resolver versions\n */\nconst COMMON_PROPERTIES: { [key: string]: PropertyDefinition } = {\n  location: {\n    dataType: PropertyType.STRING,\n    required: true,\n    description:\n      \"The Azure region where the DNS Resolver will be created. DNS Resolvers are regional resources.\",\n    validation: [\n      {\n        ruleType: ValidationRuleType.REQUIRED,\n        message: \"Location is required for DNS Resolvers\",\n      },\n    ],\n  },\n  tags: {\n    dataType: PropertyType.OBJECT,\n    required: false,\n    defaultValue: {},\n    description:\n      \"A dictionary of tags to apply to the DNS Resolver for organizational, billing, or other purposes\",\n    validation: [\n      {\n        ruleType: ValidationRuleType.TYPE_CHECK,\n        value: PropertyType.OBJECT,\n        message: \"Tags must be an object with string key-value pairs\",\n      },\n    ],\n  },\n  name: {\n    dataType: PropertyType.STRING,\n    required: true,\n    description:\n      \"The name of the DNS Resolver. Must be unique within the resource group.\",\n    validation: [\n      {\n        ruleType: ValidationRuleType.REQUIRED,\n        message: \"DNS Resolver name is required\",\n      },\n      {\n        ruleType: ValidationRuleType.PATTERN_MATCH,\n        value: \"^[a-zA-Z0-9]([a-zA-Z0-9-]*[a-zA-Z0-9])?$\",\n        message:\n          \"DNS Resolver name must start and end with alphanumeric characters and can contain hyphens\",\n      },\n      {\n        ruleType: ValidationRuleType.VALUE_RANGE,\n        value: { minLength: 1, maxLength: 80 },\n        message: \"DNS Resolver name must be between 1 and 80 characters\",\n      },\n    ],\n  },\n  virtualNetworkId: {\n    dataType: PropertyType.STRING,\n    required: true,\n    description:\n      \"The resource ID of the virtual network where the DNS Resolver will be deployed. The resolver requires a dedicated subnet.\",\n    validation: [\n      {\n        ruleType: ValidationRuleType.REQUIRED,\n        message: \"Virtual Network ID is required for DNS Resolvers\",\n      },\n      {\n        ruleType: ValidationRuleType.PATTERN_MATCH,\n        value:\n          \"^/subscriptions/[^/]+/resourceGroups/[^/]+/providers/Microsoft.Network/virtualNetworks/[^/]+$\",\n        message: \"Virtual Network ID must be a valid Azure resource ID\",\n      },\n    ],\n  },\n  ignoreChanges: {\n    dataType: PropertyType.ARRAY,\n    required: false,\n    description: \"Array of property names to ignore during updates\",\n    validation: [\n      {\n        ruleType: ValidationRuleType.TYPE_CHECK,\n        value: PropertyType.ARRAY,\n        message: \"IgnoreChanges must be an array of strings\",\n      },\n    ],\n  },\n};\n\n// =============================================================================\n// READ-ONLY PROPERTY DEFINITIONS\n// =============================================================================\n\n/**\n * Read-only properties that are populated by Azure after creation\n * These properties should not be included in the request body\n */\nconst READ_ONLY_PROPERTIES: { [key: string]: PropertyDefinition } = {\n  dnsResolverState: {\n    dataType: PropertyType.STRING,\n    required: false,\n    description:\n      \"The state of the DNS Resolver. Can be 'Connected' or 'Disconnected' (read-only)\",\n    validation: [\n      {\n        ruleType: ValidationRuleType.TYPE_CHECK,\n        value: PropertyType.STRING,\n        message: \"DnsResolverState must be a string\",\n      },\n    ],\n  },\n  provisioningState: {\n    dataType: PropertyType.STRING,\n    required: false,\n    description:\n      \"The provisioning state of the DNS Resolver resource (read-only)\",\n    validation: [\n      {\n        ruleType: ValidationRuleType.TYPE_CHECK,\n        value: PropertyType.STRING,\n        message: \"ProvisioningState must be a string\",\n      },\n    ],\n  },\n  resourceGuid: {\n    dataType: PropertyType.STRING,\n    required: false,\n    description:\n      \"The unique identifier for the DNS Resolver resource (read-only)\",\n    validation: [\n      {\n        ruleType: ValidationRuleType.TYPE_CHECK,\n        value: PropertyType.STRING,\n        message: \"ResourceGuid must be a string\",\n      },\n    ],\n  },\n};\n\n// =============================================================================\n// VERSION-SPECIFIC SCHEMAS\n// =============================================================================\n\n/**\n * API Schema for DNS Resolver version 2022-07-01\n */\nexport const DNS_RESOLVER_SCHEMA_2022_07_01: ApiSchema = {\n  resourceType: \"Microsoft.Network/dnsResolvers\",\n  version: \"2022-07-01\",\n  properties: {\n    ...COMMON_PROPERTIES,\n    ...READ_ONLY_PROPERTIES,\n  },\n  required: [\"location\", \"name\", \"virtualNetworkId\"],\n  optional: [\"tags\", \"ignoreChanges\"],\n  deprecated: [],\n  transformationRules: {},\n  validationRules: [\n    {\n      property: \"location\",\n      rules: [\n        {\n          ruleType: ValidationRuleType.REQUIRED,\n          message: \"Location is required for DNS Resolvers\",\n        },\n      ],\n    },\n    {\n      property: \"name\",\n      rules: [\n        {\n          ruleType: ValidationRuleType.REQUIRED,\n          message: \"Name is required for DNS Resolvers\",\n        },\n      ],\n    },\n    {\n      property: \"virtualNetworkId\",\n      rules: [\n        {\n          ruleType: ValidationRuleType.REQUIRED,\n          message: \"Virtual Network ID is required for DNS Resolvers\",\n        },\n      ],\n    },\n  ],\n};\n\n// =============================================================================\n// VERSION CONFIGURATIONS\n// =============================================================================\n\n/**\n * Version configuration for DNS Resolver 2022-07-01\n */\nexport const DNS_RESOLVER_VERSION_2022_07_01: VersionConfig = {\n  version: \"2022-07-01\",\n  schema: DNS_RESOLVER_SCHEMA_2022_07_01,\n  supportLevel: VersionSupportLevel.ACTIVE,\n  releaseDate: \"2022-07-01\",\n  deprecationDate: undefined,\n  sunsetDate: undefined,\n  breakingChanges: [],\n  migrationGuide: \"/docs/dns-resolver/migration-2022-07-01\",\n  changeLog: [\n    {\n      changeType: \"added\",\n      description:\n        \"Stable release of DNS Resolver API with support for hybrid DNS scenarios and conditional forwarding\",\n      breaking: false,\n    },\n  ],\n};\n\n/**\n * All supported DNS Resolver versions for registration\n */\nexport const ALL_DNS_RESOLVER_VERSIONS: VersionConfig[] = [\n  DNS_RESOLVER_VERSION_2022_07_01,\n];\n\n/**\n * Resource type constant\n */\nexport const DNS_RESOLVER_TYPE = \"Microsoft.Network/dnsResolvers\";\n"]}