@microsoft/terraform-cdk-constructs 1.2.0 → 1.3.0

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

@@ -0,0 +1,397 @@
+"use strict";
+/**
+ * Comprehensive tests for the ForwardingRule implementation
+ *
+ * This test suite validates the ForwardingRule 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 forwarding_rule_1 = require("../lib/forwarding-rule");
+const forwarding_rule_schemas_1 = require("../lib/forwarding-rule-schemas");
+describe("ForwardingRule - Implementation", () => {
+    let app;
+    let stack;
+    let manager;
+    const mockRulesetId = "/subscriptions/12345678-1234-1234-1234-123456789012/resourceGroups/test-rg/providers/Microsoft.Network/dnsForwardingRulesets/test-ruleset";
+    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(forwarding_rule_schemas_1.FORWARDING_RULE_TYPE, forwarding_rule_schemas_1.ALL_FORWARDING_RULE_VERSIONS);
+        }
+        catch (error) {
+            // Ignore if already registered
+        }
+    });
+    describe("Constructor and Basic Properties", () => {
+        it("should create Forwarding Rule with automatic latest version resolution", () => {
+            const props = {
+                name: "contoso-rule",
+                dnsForwardingRulesetId: mockRulesetId,
+                domainName: "contoso.com.",
+                targetDnsServers: [{ ipAddress: "10.0.0.4", port: 53 }],
+            };
+            const rule = new forwarding_rule_1.ForwardingRule(stack, "TestRule", props);
+            expect(rule).toBeInstanceOf(forwarding_rule_1.ForwardingRule);
+            expect(rule.resolvedApiVersion).toBe("2022-07-01");
+            expect(rule.props).toBe(props);
+        });
+        it("should create Forwarding Rule with explicit version pinning", () => {
+            const props = {
+                name: "contoso-rule",
+                dnsForwardingRulesetId: mockRulesetId,
+                domainName: "contoso.com.",
+                targetDnsServers: [{ ipAddress: "10.0.0.4" }],
+                apiVersion: "2022-07-01",
+            };
+            const rule = new forwarding_rule_1.ForwardingRule(stack, "TestRule", props);
+            expect(rule.resolvedApiVersion).toBe("2022-07-01");
+        });
+        it("should create Forwarding Rule with multiple target DNS servers", () => {
+            const props = {
+                name: "contoso-rule",
+                dnsForwardingRulesetId: mockRulesetId,
+                domainName: "contoso.com.",
+                targetDnsServers: [
+                    { ipAddress: "10.0.0.4", port: 53 },
+                    { ipAddress: "10.0.0.5", port: 53 },
+                    { ipAddress: "10.0.0.6" },
+                ],
+            };
+            const rule = new forwarding_rule_1.ForwardingRule(stack, "TestRule", props);
+            expect(rule).toBeDefined();
+            expect(rule.props.targetDnsServers).toHaveLength(3);
+        });
+        it("should create Forwarding Rule with forwarding rule state", () => {
+            const props = {
+                name: "disabled-rule",
+                dnsForwardingRulesetId: mockRulesetId,
+                domainName: "test.local.",
+                targetDnsServers: [{ ipAddress: "10.0.0.4" }],
+                forwardingRuleState: "Disabled",
+            };
+            const rule = new forwarding_rule_1.ForwardingRule(stack, "TestRule", props);
+            expect(rule).toBeDefined();
+            expect(rule.props.forwardingRuleState).toBe("Disabled");
+        });
+        it("should create Forwarding Rule with metadata", () => {
+            const props = {
+                name: "contoso-rule",
+                dnsForwardingRulesetId: mockRulesetId,
+                domainName: "contoso.com.",
+                targetDnsServers: [{ ipAddress: "10.0.0.4" }],
+                metadata: {
+                    environment: "production",
+                    owner: "platform-team",
+                },
+            };
+            const rule = new forwarding_rule_1.ForwardingRule(stack, "TestRule", props);
+            expect(rule).toBeDefined();
+            expect(rule.props.metadata).toEqual({
+                environment: "production",
+                owner: "platform-team",
+            });
+        });
+    });
+    describe("Framework Integration", () => {
+        it("should resolve latest API version automatically", () => {
+            const rule = new forwarding_rule_1.ForwardingRule(stack, "TestRule", {
+                name: "contoso-rule",
+                dnsForwardingRulesetId: mockRulesetId,
+                domainName: "contoso.com.",
+                targetDnsServers: [{ ipAddress: "10.0.0.4" }],
+            });
+            expect(rule.resolvedApiVersion).toBe("2022-07-01");
+            expect(rule.latestVersion()).toBe("2022-07-01");
+        });
+        it("should provide version configuration", () => {
+            const rule = new forwarding_rule_1.ForwardingRule(stack, "TestRule", {
+                name: "contoso-rule",
+                dnsForwardingRulesetId: mockRulesetId,
+                domainName: "contoso.com.",
+                targetDnsServers: [{ ipAddress: "10.0.0.4" }],
+            });
+            expect(rule.versionConfig).toBeDefined();
+            expect(rule.versionConfig.version).toBe("2022-07-01");
+            expect(rule.versionConfig.supportLevel).toBe(version_interfaces_1.VersionSupportLevel.ACTIVE);
+        });
+        it("should provide supported versions", () => {
+            const rule = new forwarding_rule_1.ForwardingRule(stack, "TestRule", {
+                name: "contoso-rule",
+                dnsForwardingRulesetId: mockRulesetId,
+                domainName: "contoso.com.",
+                targetDnsServers: [{ ipAddress: "10.0.0.4" }],
+            });
+            const versions = rule.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 rule = new forwarding_rule_1.ForwardingRule(stack, "TestRule", {
+                name: "contoso-rule",
+                dnsForwardingRulesetId: mockRulesetId,
+                domainName: "contoso.com.",
+                targetDnsServers: [{ ipAddress: "10.0.0.4" }],
+            });
+            // Verify the rule was created successfully with proper parent
+            expect(rule).toBeDefined();
+            expect(rule.props.dnsForwardingRulesetId).toBe(mockRulesetId);
+        });
+        it("should correctly handle child resource in Terraform synthesis", () => {
+            new forwarding_rule_1.ForwardingRule(stack, "TestRule", {
+                name: "contoso-rule",
+                dnsForwardingRulesetId: mockRulesetId,
+                domainName: "contoso.com.",
+                targetDnsServers: [{ ipAddress: "10.0.0.4" }],
+            });
+            const synthesized = cdktf_1.Testing.synth(stack);
+            expect(synthesized).toContain("forwardingRules");
+            expect(synthesized).toContain(mockRulesetId);
+        });
+    });
+    describe("Public Methods - Forwarding Rule Properties", () => {
+        it("should provide provisioning state", () => {
+            const rule = new forwarding_rule_1.ForwardingRule(stack, "TestRule", {
+                name: "contoso-rule",
+                dnsForwardingRulesetId: mockRulesetId,
+                domainName: "contoso.com.",
+                targetDnsServers: [{ ipAddress: "10.0.0.4" }],
+            });
+            expect(rule.provisioningState).toBeDefined();
+            expect(typeof rule.provisioningState).toBe("string");
+        });
+        it("should provide target DNS servers", () => {
+            const rule = new forwarding_rule_1.ForwardingRule(stack, "TestRule", {
+                name: "contoso-rule",
+                dnsForwardingRulesetId: mockRulesetId,
+                domainName: "contoso.com.",
+                targetDnsServers: [{ ipAddress: "10.0.0.4" }],
+            });
+            expect(rule.targetDnsServers).toBeDefined();
+            expect(typeof rule.targetDnsServers).toBe("string");
+        });
+        it("should provide metadata", () => {
+            const rule = new forwarding_rule_1.ForwardingRule(stack, "TestRule", {
+                name: "contoso-rule",
+                dnsForwardingRulesetId: mockRulesetId,
+                domainName: "contoso.com.",
+                targetDnsServers: [{ ipAddress: "10.0.0.4" }],
+                metadata: { key: "value" },
+            });
+            expect(rule.metadata).toBeDefined();
+            expect(typeof rule.metadata).toBe("string");
+        });
+    });
+    describe("Outputs", () => {
+        it("should create all required outputs", () => {
+            const rule = new forwarding_rule_1.ForwardingRule(stack, "TestRule", {
+                name: "contoso-rule",
+                dnsForwardingRulesetId: mockRulesetId,
+                domainName: "contoso.com.",
+                targetDnsServers: [{ ipAddress: "10.0.0.4" }],
+            });
+            expect(rule.idOutput).toBeDefined();
+            expect(rule.nameOutput).toBeDefined();
+            expect(rule.provisioningStateOutput).toBeDefined();
+        });
+        it("should have correct logical IDs for outputs", () => {
+            new forwarding_rule_1.ForwardingRule(stack, "TestRule", {
+                name: "contoso-rule",
+                dnsForwardingRulesetId: mockRulesetId,
+                domainName: "contoso.com.",
+                targetDnsServers: [{ ipAddress: "10.0.0.4" }],
+            });
+            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 forwarding_rule_1.ForwardingRule(stack, "TestRule", {
+                name: "contoso-rule",
+                dnsForwardingRulesetId: mockRulesetId,
+                domainName: "contoso.com.",
+                targetDnsServers: [{ ipAddress: "10.0.0.4" }],
+                ignoreChanges: ["metadata"],
+            });
+            const synthesized = cdktf_1.Testing.synth(stack);
+            expect(synthesized).toContain("ignore_changes");
+        });
+        it("should handle multiple ignore changes properties", () => {
+            new forwarding_rule_1.ForwardingRule(stack, "TestRule", {
+                name: "contoso-rule",
+                dnsForwardingRulesetId: mockRulesetId,
+                domainName: "contoso.com.",
+                targetDnsServers: [{ ipAddress: "10.0.0.4" }],
+                ignoreChanges: ["metadata", "forwardingRuleState"],
+            });
+            const synthesized = cdktf_1.Testing.synth(stack);
+            expect(synthesized).toBeDefined();
+        });
+    });
+    describe("CDK Terraform Integration", () => {
+        it("should synthesize to valid Terraform configuration", () => {
+            new forwarding_rule_1.ForwardingRule(stack, "SynthTest", {
+                name: "contoso-rule",
+                dnsForwardingRulesetId: mockRulesetId,
+                domainName: "contoso.com.",
+                targetDnsServers: [{ ipAddress: "10.0.0.4", port: 53 }],
+            });
+            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 forwarding_rule_1.ForwardingRule(stack, "SynthTest", {
+                name: "contoso-rule",
+                dnsForwardingRulesetId: mockRulesetId,
+                domainName: "contoso.com.",
+                targetDnsServers: [{ ipAddress: "10.0.0.4" }],
+            });
+            const synthesized = cdktf_1.Testing.synth(stack);
+            expect(synthesized).toContain("forwardingRules");
+            expect(synthesized).toContain("2022-07-01");
+        });
+        it("should include all properties in Terraform body", () => {
+            new forwarding_rule_1.ForwardingRule(stack, "SynthTest", {
+                name: "contoso-rule",
+                dnsForwardingRulesetId: mockRulesetId,
+                domainName: "contoso.com.",
+                targetDnsServers: [
+                    { ipAddress: "10.0.0.4", port: 53 },
+                    { ipAddress: "10.0.0.5" },
+                ],
+                forwardingRuleState: "Enabled",
+                metadata: { env: "test" },
+            });
+            const synthesized = cdktf_1.Testing.synth(stack);
+            expect(synthesized).toContain("contoso.com.");
+            expect(synthesized).toContain("10.0.0.4");
+            expect(synthesized).toContain("10.0.0.5");
+        });
+    });
+    describe("Resource Identification", () => {
+        it("should provide resource ID", () => {
+            const rule = new forwarding_rule_1.ForwardingRule(stack, "TestRule", {
+                name: "contoso-rule",
+                dnsForwardingRulesetId: mockRulesetId,
+                domainName: "contoso.com.",
+                targetDnsServers: [{ ipAddress: "10.0.0.4" }],
+            });
+            expect(rule.id).toBeDefined();
+            expect(typeof rule.id).toBe("string");
+        });
+        it("should provide resource name from props when specified", () => {
+            const rule = new forwarding_rule_1.ForwardingRule(stack, "TestRule", {
+                name: "contoso-rule",
+                dnsForwardingRulesetId: mockRulesetId,
+                domainName: "contoso.com.",
+                targetDnsServers: [{ ipAddress: "10.0.0.4" }],
+            });
+            expect(rule.name).toBe("contoso-rule");
+        });
+    });
+    describe("JSII Compliance", () => {
+        it("should have proper return types for all public methods", () => {
+            const rule = new forwarding_rule_1.ForwardingRule(stack, "TestRule", {
+                name: "contoso-rule",
+                dnsForwardingRulesetId: mockRulesetId,
+                domainName: "contoso.com.",
+                targetDnsServers: [{ ipAddress: "10.0.0.4" }],
+            });
+            // All getter methods should return strings for Terraform interpolations
+            expect(typeof rule.provisioningState).toBe("string");
+            expect(typeof rule.targetDnsServers).toBe("string");
+            expect(typeof rule.metadata).toBe("string");
+        });
+    });
+    describe("Schema Registration", () => {
+        it("should register schemas successfully", () => {
+            const rule = new forwarding_rule_1.ForwardingRule(stack, "TestRule", {
+                name: "contoso-rule",
+                dnsForwardingRulesetId: mockRulesetId,
+                domainName: "contoso.com.",
+                targetDnsServers: [{ ipAddress: "10.0.0.4" }],
+            });
+            // If the rule was created successfully, schemas were registered
+            expect(rule).toBeDefined();
+            expect(rule.resolvedApiVersion).toBe("2022-07-01");
+        });
+        it("should handle multiple instantiations without errors", () => {
+            new forwarding_rule_1.ForwardingRule(stack, "TestRule1", {
+                name: "contoso-rule-1",
+                dnsForwardingRulesetId: mockRulesetId,
+                domainName: "contoso.com.",
+                targetDnsServers: [{ ipAddress: "10.0.0.4" }],
+            });
+            // Second instantiation should not throw an error even if schemas are already registered
+            const rule2 = new forwarding_rule_1.ForwardingRule(stack, "TestRule2", {
+                name: "contoso-rule-2",
+                dnsForwardingRulesetId: mockRulesetId,
+                domainName: "internal.com.",
+                targetDnsServers: [{ ipAddress: "10.0.0.5" }],
+            });
+            expect(rule2).toBeDefined();
+        });
+    });
+    describe("Target DNS Server Configuration", () => {
+        it("should handle default port when not specified", () => {
+            new forwarding_rule_1.ForwardingRule(stack, "TestRule", {
+                name: "contoso-rule",
+                dnsForwardingRulesetId: mockRulesetId,
+                domainName: "contoso.com.",
+                targetDnsServers: [{ ipAddress: "10.0.0.4" }],
+            });
+            const synthesized = cdktf_1.Testing.synth(stack);
+            expect(synthesized).toContain("10.0.0.4");
+            expect(synthesized).toContain("53"); // Default port
+        });
+        it("should handle custom port when specified", () => {
+            new forwarding_rule_1.ForwardingRule(stack, "TestRule", {
+                name: "contoso-rule",
+                dnsForwardingRulesetId: mockRulesetId,
+                domainName: "contoso.com.",
+                targetDnsServers: [{ ipAddress: "10.0.0.4", port: 5353 }],
+            });
+            const synthesized = cdktf_1.Testing.synth(stack);
+            expect(synthesized).toContain("10.0.0.4");
+            expect(synthesized).toContain("5353");
+        });
+    });
+    describe("Forwarding Rule State", () => {
+        it("should handle enabled state", () => {
+            const rule = new forwarding_rule_1.ForwardingRule(stack, "TestRule", {
+                name: "enabled-rule",
+                dnsForwardingRulesetId: mockRulesetId,
+                domainName: "contoso.com.",
+                targetDnsServers: [{ ipAddress: "10.0.0.4" }],
+                forwardingRuleState: "Enabled",
+            });
+            expect(rule.props.forwardingRuleState).toBe("Enabled");
+        });
+        it("should handle disabled state", () => {
+            const rule = new forwarding_rule_1.ForwardingRule(stack, "TestRule", {
+                name: "disabled-rule",
+                dnsForwardingRulesetId: mockRulesetId,
+                domainName: "contoso.com.",
+                targetDnsServers: [{ ipAddress: "10.0.0.4" }],
+                forwardingRuleState: "Disabled",
+            });
+            expect(rule.props.forwardingRuleState).toBe("Disabled");
+        });
+    });
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"forwarding-rule.spec.js","sourceRoot":"","sources":["../../../src/azure-dnsforwardingruleset/test/forwarding-rule.spec.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Comprehensive tests for the ForwardingRule implementation\n *\n * This test suite validates the ForwardingRule 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 { ForwardingRule, ForwardingRuleProps } from \"../lib/forwarding-rule\";\nimport {\n  ALL_FORWARDING_RULE_VERSIONS,\n  FORWARDING_RULE_TYPE,\n} from \"../lib/forwarding-rule-schemas\";\n\ndescribe(\"ForwardingRule - 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\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        FORWARDING_RULE_TYPE,\n        ALL_FORWARDING_RULE_VERSIONS,\n      );\n    } catch (error) {\n      // Ignore if already registered\n    }\n  });\n\n  describe(\"Constructor and Basic Properties\", () => {\n    it(\"should create Forwarding Rule with automatic latest version resolution\", () => {\n      const props: ForwardingRuleProps = {\n        name: \"contoso-rule\",\n        dnsForwardingRulesetId: mockRulesetId,\n        domainName: \"contoso.com.\",\n        targetDnsServers: [{ ipAddress: \"10.0.0.4\", port: 53 }],\n      };\n\n      const rule = new ForwardingRule(stack, \"TestRule\", props);\n\n      expect(rule).toBeInstanceOf(ForwardingRule);\n      expect(rule.resolvedApiVersion).toBe(\"2022-07-01\");\n      expect(rule.props).toBe(props);\n    });\n\n    it(\"should create Forwarding Rule with explicit version pinning\", () => {\n      const props: ForwardingRuleProps = {\n        name: \"contoso-rule\",\n        dnsForwardingRulesetId: mockRulesetId,\n        domainName: \"contoso.com.\",\n        targetDnsServers: [{ ipAddress: \"10.0.0.4\" }],\n        apiVersion: \"2022-07-01\",\n      };\n\n      const rule = new ForwardingRule(stack, \"TestRule\", props);\n\n      expect(rule.resolvedApiVersion).toBe(\"2022-07-01\");\n    });\n\n    it(\"should create Forwarding Rule with multiple target DNS servers\", () => {\n      const props: ForwardingRuleProps = {\n        name: \"contoso-rule\",\n        dnsForwardingRulesetId: mockRulesetId,\n        domainName: \"contoso.com.\",\n        targetDnsServers: [\n          { ipAddress: \"10.0.0.4\", port: 53 },\n          { ipAddress: \"10.0.0.5\", port: 53 },\n          { ipAddress: \"10.0.0.6\" },\n        ],\n      };\n\n      const rule = new ForwardingRule(stack, \"TestRule\", props);\n\n      expect(rule).toBeDefined();\n      expect(rule.props.targetDnsServers).toHaveLength(3);\n    });\n\n    it(\"should create Forwarding Rule with forwarding rule state\", () => {\n      const props: ForwardingRuleProps = {\n        name: \"disabled-rule\",\n        dnsForwardingRulesetId: mockRulesetId,\n        domainName: \"test.local.\",\n        targetDnsServers: [{ ipAddress: \"10.0.0.4\" }],\n        forwardingRuleState: \"Disabled\",\n      };\n\n      const rule = new ForwardingRule(stack, \"TestRule\", props);\n\n      expect(rule).toBeDefined();\n      expect(rule.props.forwardingRuleState).toBe(\"Disabled\");\n    });\n\n    it(\"should create Forwarding Rule with metadata\", () => {\n      const props: ForwardingRuleProps = {\n        name: \"contoso-rule\",\n        dnsForwardingRulesetId: mockRulesetId,\n        domainName: \"contoso.com.\",\n        targetDnsServers: [{ ipAddress: \"10.0.0.4\" }],\n        metadata: {\n          environment: \"production\",\n          owner: \"platform-team\",\n        },\n      };\n\n      const rule = new ForwardingRule(stack, \"TestRule\", props);\n\n      expect(rule).toBeDefined();\n      expect(rule.props.metadata).toEqual({\n        environment: \"production\",\n        owner: \"platform-team\",\n      });\n    });\n  });\n\n  describe(\"Framework Integration\", () => {\n    it(\"should resolve latest API version automatically\", () => {\n      const rule = new ForwardingRule(stack, \"TestRule\", {\n        name: \"contoso-rule\",\n        dnsForwardingRulesetId: mockRulesetId,\n        domainName: \"contoso.com.\",\n        targetDnsServers: [{ ipAddress: \"10.0.0.4\" }],\n      });\n\n      expect(rule.resolvedApiVersion).toBe(\"2022-07-01\");\n      expect(rule.latestVersion()).toBe(\"2022-07-01\");\n    });\n\n    it(\"should provide version configuration\", () => {\n      const rule = new ForwardingRule(stack, \"TestRule\", {\n        name: \"contoso-rule\",\n        dnsForwardingRulesetId: mockRulesetId,\n        domainName: \"contoso.com.\",\n        targetDnsServers: [{ ipAddress: \"10.0.0.4\" }],\n      });\n\n      expect(rule.versionConfig).toBeDefined();\n      expect(rule.versionConfig.version).toBe(\"2022-07-01\");\n      expect(rule.versionConfig.supportLevel).toBe(VersionSupportLevel.ACTIVE);\n    });\n\n    it(\"should provide supported versions\", () => {\n      const rule = new ForwardingRule(stack, \"TestRule\", {\n        name: \"contoso-rule\",\n        dnsForwardingRulesetId: mockRulesetId,\n        domainName: \"contoso.com.\",\n        targetDnsServers: [{ ipAddress: \"10.0.0.4\" }],\n      });\n\n      const versions = rule.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 rule = new ForwardingRule(stack, \"TestRule\", {\n        name: \"contoso-rule\",\n        dnsForwardingRulesetId: mockRulesetId,\n        domainName: \"contoso.com.\",\n        targetDnsServers: [{ ipAddress: \"10.0.0.4\" }],\n      });\n\n      // Verify the rule was created successfully with proper parent\n      expect(rule).toBeDefined();\n      expect(rule.props.dnsForwardingRulesetId).toBe(mockRulesetId);\n    });\n\n    it(\"should correctly handle child resource in Terraform synthesis\", () => {\n      new ForwardingRule(stack, \"TestRule\", {\n        name: \"contoso-rule\",\n        dnsForwardingRulesetId: mockRulesetId,\n        domainName: \"contoso.com.\",\n        targetDnsServers: [{ ipAddress: \"10.0.0.4\" }],\n      });\n\n      const synthesized = Testing.synth(stack);\n      expect(synthesized).toContain(\"forwardingRules\");\n      expect(synthesized).toContain(mockRulesetId);\n    });\n  });\n\n  describe(\"Public Methods - Forwarding Rule Properties\", () => {\n    it(\"should provide provisioning state\", () => {\n      const rule = new ForwardingRule(stack, \"TestRule\", {\n        name: \"contoso-rule\",\n        dnsForwardingRulesetId: mockRulesetId,\n        domainName: \"contoso.com.\",\n        targetDnsServers: [{ ipAddress: \"10.0.0.4\" }],\n      });\n\n      expect(rule.provisioningState).toBeDefined();\n      expect(typeof rule.provisioningState).toBe(\"string\");\n    });\n\n    it(\"should provide target DNS servers\", () => {\n      const rule = new ForwardingRule(stack, \"TestRule\", {\n        name: \"contoso-rule\",\n        dnsForwardingRulesetId: mockRulesetId,\n        domainName: \"contoso.com.\",\n        targetDnsServers: [{ ipAddress: \"10.0.0.4\" }],\n      });\n\n      expect(rule.targetDnsServers).toBeDefined();\n      expect(typeof rule.targetDnsServers).toBe(\"string\");\n    });\n\n    it(\"should provide metadata\", () => {\n      const rule = new ForwardingRule(stack, \"TestRule\", {\n        name: \"contoso-rule\",\n        dnsForwardingRulesetId: mockRulesetId,\n        domainName: \"contoso.com.\",\n        targetDnsServers: [{ ipAddress: \"10.0.0.4\" }],\n        metadata: { key: \"value\" },\n      });\n\n      expect(rule.metadata).toBeDefined();\n      expect(typeof rule.metadata).toBe(\"string\");\n    });\n  });\n\n  describe(\"Outputs\", () => {\n    it(\"should create all required outputs\", () => {\n      const rule = new ForwardingRule(stack, \"TestRule\", {\n        name: \"contoso-rule\",\n        dnsForwardingRulesetId: mockRulesetId,\n        domainName: \"contoso.com.\",\n        targetDnsServers: [{ ipAddress: \"10.0.0.4\" }],\n      });\n\n      expect(rule.idOutput).toBeDefined();\n      expect(rule.nameOutput).toBeDefined();\n      expect(rule.provisioningStateOutput).toBeDefined();\n    });\n\n    it(\"should have correct logical IDs for outputs\", () => {\n      new ForwardingRule(stack, \"TestRule\", {\n        name: \"contoso-rule\",\n        dnsForwardingRulesetId: mockRulesetId,\n        domainName: \"contoso.com.\",\n        targetDnsServers: [{ ipAddress: \"10.0.0.4\" }],\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 ForwardingRule(stack, \"TestRule\", {\n        name: \"contoso-rule\",\n        dnsForwardingRulesetId: mockRulesetId,\n        domainName: \"contoso.com.\",\n        targetDnsServers: [{ ipAddress: \"10.0.0.4\" }],\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 ForwardingRule(stack, \"TestRule\", {\n        name: \"contoso-rule\",\n        dnsForwardingRulesetId: mockRulesetId,\n        domainName: \"contoso.com.\",\n        targetDnsServers: [{ ipAddress: \"10.0.0.4\" }],\n        ignoreChanges: [\"metadata\", \"forwardingRuleState\"],\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 ForwardingRule(stack, \"SynthTest\", {\n        name: \"contoso-rule\",\n        dnsForwardingRulesetId: mockRulesetId,\n        domainName: \"contoso.com.\",\n        targetDnsServers: [{ ipAddress: \"10.0.0.4\", port: 53 }],\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 ForwardingRule(stack, \"SynthTest\", {\n        name: \"contoso-rule\",\n        dnsForwardingRulesetId: mockRulesetId,\n        domainName: \"contoso.com.\",\n        targetDnsServers: [{ ipAddress: \"10.0.0.4\" }],\n      });\n\n      const synthesized = Testing.synth(stack);\n      expect(synthesized).toContain(\"forwardingRules\");\n      expect(synthesized).toContain(\"2022-07-01\");\n    });\n\n    it(\"should include all properties in Terraform body\", () => {\n      new ForwardingRule(stack, \"SynthTest\", {\n        name: \"contoso-rule\",\n        dnsForwardingRulesetId: mockRulesetId,\n        domainName: \"contoso.com.\",\n        targetDnsServers: [\n          { ipAddress: \"10.0.0.4\", port: 53 },\n          { ipAddress: \"10.0.0.5\" },\n        ],\n        forwardingRuleState: \"Enabled\",\n        metadata: { env: \"test\" },\n      });\n\n      const synthesized = Testing.synth(stack);\n      expect(synthesized).toContain(\"contoso.com.\");\n      expect(synthesized).toContain(\"10.0.0.4\");\n      expect(synthesized).toContain(\"10.0.0.5\");\n    });\n  });\n\n  describe(\"Resource Identification\", () => {\n    it(\"should provide resource ID\", () => {\n      const rule = new ForwardingRule(stack, \"TestRule\", {\n        name: \"contoso-rule\",\n        dnsForwardingRulesetId: mockRulesetId,\n        domainName: \"contoso.com.\",\n        targetDnsServers: [{ ipAddress: \"10.0.0.4\" }],\n      });\n\n      expect(rule.id).toBeDefined();\n      expect(typeof rule.id).toBe(\"string\");\n    });\n\n    it(\"should provide resource name from props when specified\", () => {\n      const rule = new ForwardingRule(stack, \"TestRule\", {\n        name: \"contoso-rule\",\n        dnsForwardingRulesetId: mockRulesetId,\n        domainName: \"contoso.com.\",\n        targetDnsServers: [{ ipAddress: \"10.0.0.4\" }],\n      });\n\n      expect(rule.name).toBe(\"contoso-rule\");\n    });\n  });\n\n  describe(\"JSII Compliance\", () => {\n    it(\"should have proper return types for all public methods\", () => {\n      const rule = new ForwardingRule(stack, \"TestRule\", {\n        name: \"contoso-rule\",\n        dnsForwardingRulesetId: mockRulesetId,\n        domainName: \"contoso.com.\",\n        targetDnsServers: [{ ipAddress: \"10.0.0.4\" }],\n      });\n\n      // All getter methods should return strings for Terraform interpolations\n      expect(typeof rule.provisioningState).toBe(\"string\");\n      expect(typeof rule.targetDnsServers).toBe(\"string\");\n      expect(typeof rule.metadata).toBe(\"string\");\n    });\n  });\n\n  describe(\"Schema Registration\", () => {\n    it(\"should register schemas successfully\", () => {\n      const rule = new ForwardingRule(stack, \"TestRule\", {\n        name: \"contoso-rule\",\n        dnsForwardingRulesetId: mockRulesetId,\n        domainName: \"contoso.com.\",\n        targetDnsServers: [{ ipAddress: \"10.0.0.4\" }],\n      });\n\n      // If the rule was created successfully, schemas were registered\n      expect(rule).toBeDefined();\n      expect(rule.resolvedApiVersion).toBe(\"2022-07-01\");\n    });\n\n    it(\"should handle multiple instantiations without errors\", () => {\n      new ForwardingRule(stack, \"TestRule1\", {\n        name: \"contoso-rule-1\",\n        dnsForwardingRulesetId: mockRulesetId,\n        domainName: \"contoso.com.\",\n        targetDnsServers: [{ ipAddress: \"10.0.0.4\" }],\n      });\n\n      // Second instantiation should not throw an error even if schemas are already registered\n      const rule2 = new ForwardingRule(stack, \"TestRule2\", {\n        name: \"contoso-rule-2\",\n        dnsForwardingRulesetId: mockRulesetId,\n        domainName: \"internal.com.\",\n        targetDnsServers: [{ ipAddress: \"10.0.0.5\" }],\n      });\n\n      expect(rule2).toBeDefined();\n    });\n  });\n\n  describe(\"Target DNS Server Configuration\", () => {\n    it(\"should handle default port when not specified\", () => {\n      new ForwardingRule(stack, \"TestRule\", {\n        name: \"contoso-rule\",\n        dnsForwardingRulesetId: mockRulesetId,\n        domainName: \"contoso.com.\",\n        targetDnsServers: [{ ipAddress: \"10.0.0.4\" }],\n      });\n\n      const synthesized = Testing.synth(stack);\n      expect(synthesized).toContain(\"10.0.0.4\");\n      expect(synthesized).toContain(\"53\"); // Default port\n    });\n\n    it(\"should handle custom port when specified\", () => {\n      new ForwardingRule(stack, \"TestRule\", {\n        name: \"contoso-rule\",\n        dnsForwardingRulesetId: mockRulesetId,\n        domainName: \"contoso.com.\",\n        targetDnsServers: [{ ipAddress: \"10.0.0.4\", port: 5353 }],\n      });\n\n      const synthesized = Testing.synth(stack);\n      expect(synthesized).toContain(\"10.0.0.4\");\n      expect(synthesized).toContain(\"5353\");\n    });\n  });\n\n  describe(\"Forwarding Rule State\", () => {\n    it(\"should handle enabled state\", () => {\n      const rule = new ForwardingRule(stack, \"TestRule\", {\n        name: \"enabled-rule\",\n        dnsForwardingRulesetId: mockRulesetId,\n        domainName: \"contoso.com.\",\n        targetDnsServers: [{ ipAddress: \"10.0.0.4\" }],\n        forwardingRuleState: \"Enabled\",\n      });\n\n      expect(rule.props.forwardingRuleState).toBe(\"Enabled\");\n    });\n\n    it(\"should handle disabled state\", () => {\n      const rule = new ForwardingRule(stack, \"TestRule\", {\n        name: \"disabled-rule\",\n        dnsForwardingRulesetId: mockRulesetId,\n        domainName: \"contoso.com.\",\n        targetDnsServers: [{ ipAddress: \"10.0.0.4\" }],\n        forwardingRuleState: \"Disabled\",\n      });\n\n      expect(rule.props.forwardingRuleState).toBe(\"Disabled\");\n    });\n  });\n});\n"]}

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

@@ -0,0 +1,9 @@
+/**
+ * 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.
+ */
+export {};