@microsoft/terraform-cdk-constructs 1.7.1 → 1.9.0

package/lib/azure-privatednszone/test/private-dns-records.spec.js

@@ -0,0 +1,756 @@
+"use strict";
+/**
+ * Unit tests for Azure Private DNS Zone Record implementations
+ *
+ * This test suite validates all 8 Private DNS record types:
+ * - PrivateDnsARecord
+ * - PrivateDnsAaaaRecord
+ * - PrivateDnsCnameRecord
+ * - PrivateDnsMxRecord
+ * - PrivateDnsPtrRecord
+ * - PrivateDnsSoaRecord
+ * - PrivateDnsSrvRecord
+ * - PrivateDnsTxtRecord
+ *
+ * Tests verify basic creation, correct resource types, API versions,
+ * parent ID resolution, resource body structure, TTL handling,
+ * record-specific properties, and metadata handling.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const cdktf_1 = require("cdktf");
+const cdktf = require("cdktf");
+const records_1 = require("../lib/records");
+const private_dns_record_schemas_1 = require("../lib/records/private-dns-record-schemas");
+// Sample Private DNS Zone ID for testing
+const SAMPLE_ZONE_ID = "/subscriptions/12345678-1234-1234-1234-123456789012/resourceGroups/rg-test/providers/Microsoft.Network/privateDnsZones/example.com";
+describe("PrivateDnsARecord", () => {
+    let app;
+    let stack;
+    beforeEach(() => {
+        app = cdktf_1.Testing.app();
+        stack = new cdktf.TerraformStack(app, "TestStack");
+    });
+    describe("Basic Creation", () => {
+        it("should create an A record with required properties", () => {
+            const record = new records_1.PrivateDnsARecord(stack, "test-a-record", {
+                name: "www",
+                privateDnsZoneId: SAMPLE_ZONE_ID,
+                records: [{ ipv4Address: "10.0.1.4" }],
+            });
+            expect(record).toBeInstanceOf(records_1.PrivateDnsARecord);
+            expect(record.props.name).toBe("www");
+            expect(record.props.privateDnsZoneId).toBe(SAMPLE_ZONE_ID);
+            expect(record.props.records).toHaveLength(1);
+            expect(record.props.records[0].ipv4Address).toBe("10.0.1.4");
+        });
+        it("should create an A record with multiple IP addresses", () => {
+            const record = new records_1.PrivateDnsARecord(stack, "test-a-record-multi", {
+                name: "www",
+                privateDnsZoneId: SAMPLE_ZONE_ID,
+                records: [{ ipv4Address: "10.0.1.4" }, { ipv4Address: "10.0.1.5" }],
+            });
+            expect(record.props.records).toHaveLength(2);
+        });
+        it("should create an apex A record with @ name", () => {
+            const record = new records_1.PrivateDnsARecord(stack, "test-a-record-apex", {
+                name: "@",
+                privateDnsZoneId: SAMPLE_ZONE_ID,
+                records: [{ ipv4Address: "10.0.1.4" }],
+            });
+            expect(record.props.name).toBe("@");
+        });
+    });
+    describe("Resource Type and API Version", () => {
+        it("should set correct resource type", () => {
+            new records_1.PrivateDnsARecord(stack, "test-a-record", {
+                name: "www",
+                privateDnsZoneId: SAMPLE_ZONE_ID,
+                records: [{ ipv4Address: "10.0.1.4" }],
+            });
+            const synthesized = cdktf_1.Testing.synth(stack);
+            expect(synthesized).toContain(private_dns_record_schemas_1.PRIVATE_DNS_A_RECORD_TYPE);
+        });
+        it("should use correct API version", () => {
+            const record = new records_1.PrivateDnsARecord(stack, "test-a-record", {
+                name: "www",
+                privateDnsZoneId: SAMPLE_ZONE_ID,
+                records: [{ ipv4Address: "10.0.1.4" }],
+            });
+            expect(record.resolvedApiVersion).toBe("2024-06-01");
+        });
+    });
+    describe("Parent ID Resolution", () => {
+        it("should set parentId to the zone ID", () => {
+            new records_1.PrivateDnsARecord(stack, "test-a-record", {
+                name: "www",
+                privateDnsZoneId: SAMPLE_ZONE_ID,
+                records: [{ ipv4Address: "10.0.1.4" }],
+            });
+            const synthesized = cdktf_1.Testing.synth(stack);
+            expect(synthesized).toContain(SAMPLE_ZONE_ID);
+        });
+    });
+    describe("TTL Handling", () => {
+        it("should use default TTL of 3600 when not specified", () => {
+            new records_1.PrivateDnsARecord(stack, "test-a-record", {
+                name: "www",
+                privateDnsZoneId: SAMPLE_ZONE_ID,
+                records: [{ ipv4Address: "10.0.1.4" }],
+            });
+            const synthesized = cdktf_1.Testing.synth(stack);
+            expect(synthesized).toContain("3600");
+        });
+        it("should use custom TTL when specified", () => {
+            new records_1.PrivateDnsARecord(stack, "test-a-record", {
+                name: "www",
+                privateDnsZoneId: SAMPLE_ZONE_ID,
+                ttl: 300,
+                records: [{ ipv4Address: "10.0.1.4" }],
+            });
+            const synthesized = cdktf_1.Testing.synth(stack);
+            expect(synthesized).toContain("300");
+        });
+    });
+    describe("Resource Body Structure", () => {
+        it("should include aRecords in the body", () => {
+            new records_1.PrivateDnsARecord(stack, "test-a-record", {
+                name: "www",
+                privateDnsZoneId: SAMPLE_ZONE_ID,
+                records: [{ ipv4Address: "10.0.1.4" }],
+            });
+            const synthesized = cdktf_1.Testing.synth(stack);
+            expect(synthesized).toContain("aRecords");
+            expect(synthesized).toContain("ipv4Address");
+            expect(synthesized).toContain("10.0.1.4");
+        });
+    });
+    describe("Metadata Handling", () => {
+        it("should include metadata when provided", () => {
+            new records_1.PrivateDnsARecord(stack, "test-a-record", {
+                name: "www",
+                privateDnsZoneId: SAMPLE_ZONE_ID,
+                records: [{ ipv4Address: "10.0.1.4" }],
+                metadata: { environment: "test", owner: "team-a" },
+            });
+            const synthesized = cdktf_1.Testing.synth(stack);
+            expect(synthesized).toContain("metadata");
+            expect(synthesized).toContain("environment");
+            expect(synthesized).toContain("test");
+        });
+        it("should not include metadata when not provided", () => {
+            new records_1.PrivateDnsARecord(stack, "test-a-record", {
+                name: "www",
+                privateDnsZoneId: SAMPLE_ZONE_ID,
+                records: [{ ipv4Address: "10.0.1.4" }],
+            });
+            const synthesized = cdktf_1.Testing.synth(stack);
+            // Check that metadata is not mentioned in the synthesized output when not provided
+            // We just verify the record was created successfully without metadata in props
+            expect(synthesized).toBeDefined();
+            // The absence of metadata in the record definition should result in no metadata key in the body
+            // Since metadata is optional and not specified, it shouldn't appear in the output
+        });
+    });
+    describe("Outputs", () => {
+        it("should create required outputs", () => {
+            const record = new records_1.PrivateDnsARecord(stack, "test-a-record", {
+                name: "www",
+                privateDnsZoneId: SAMPLE_ZONE_ID,
+                records: [{ ipv4Address: "10.0.1.4" }],
+            });
+            expect(record.idOutput).toBeInstanceOf(cdktf.TerraformOutput);
+            expect(record.nameOutput).toBeInstanceOf(cdktf.TerraformOutput);
+            expect(record.fqdnOutput).toBeInstanceOf(cdktf.TerraformOutput);
+        });
+        it("should provide fqdn property", () => {
+            const record = new records_1.PrivateDnsARecord(stack, "test-a-record", {
+                name: "www",
+                privateDnsZoneId: SAMPLE_ZONE_ID,
+                records: [{ ipv4Address: "10.0.1.4" }],
+            });
+            expect(record.fqdn).toBeDefined();
+            expect(typeof record.fqdn).toBe("string");
+        });
+    });
+});
+describe("PrivateDnsAaaaRecord", () => {
+    let app;
+    let stack;
+    beforeEach(() => {
+        app = cdktf_1.Testing.app();
+        stack = new cdktf.TerraformStack(app, "TestStack");
+    });
+    describe("Basic Creation", () => {
+        it("should create an AAAA record with required properties", () => {
+            const record = new records_1.PrivateDnsAaaaRecord(stack, "test-aaaa-record", {
+                name: "www",
+                privateDnsZoneId: SAMPLE_ZONE_ID,
+                records: [{ ipv6Address: "2001:db8::1" }],
+            });
+            expect(record).toBeInstanceOf(records_1.PrivateDnsAaaaRecord);
+            expect(record.props.name).toBe("www");
+            expect(record.props.records[0].ipv6Address).toBe("2001:db8::1");
+        });
+        it("should create an AAAA record with multiple IPv6 addresses", () => {
+            const record = new records_1.PrivateDnsAaaaRecord(stack, "test-aaaa-record-multi", {
+                name: "www",
+                privateDnsZoneId: SAMPLE_ZONE_ID,
+                records: [
+                    { ipv6Address: "2001:db8::1" },
+                    { ipv6Address: "2001:db8::2" },
+                ],
+            });
+            expect(record.props.records).toHaveLength(2);
+        });
+    });
+    describe("Resource Type and API Version", () => {
+        it("should set correct resource type", () => {
+            new records_1.PrivateDnsAaaaRecord(stack, "test-aaaa-record", {
+                name: "www",
+                privateDnsZoneId: SAMPLE_ZONE_ID,
+                records: [{ ipv6Address: "2001:db8::1" }],
+            });
+            const synthesized = cdktf_1.Testing.synth(stack);
+            expect(synthesized).toContain(private_dns_record_schemas_1.PRIVATE_DNS_AAAA_RECORD_TYPE);
+        });
+        it("should use correct API version", () => {
+            const record = new records_1.PrivateDnsAaaaRecord(stack, "test-aaaa-record", {
+                name: "www",
+                privateDnsZoneId: SAMPLE_ZONE_ID,
+                records: [{ ipv6Address: "2001:db8::1" }],
+            });
+            expect(record.resolvedApiVersion).toBe("2024-06-01");
+        });
+    });
+    describe("Resource Body Structure", () => {
+        it("should include aaaaRecords in the body", () => {
+            new records_1.PrivateDnsAaaaRecord(stack, "test-aaaa-record", {
+                name: "www",
+                privateDnsZoneId: SAMPLE_ZONE_ID,
+                records: [{ ipv6Address: "2001:db8::1" }],
+            });
+            const synthesized = cdktf_1.Testing.synth(stack);
+            expect(synthesized).toContain("aaaaRecords");
+            expect(synthesized).toContain("ipv6Address");
+            expect(synthesized).toContain("2001:db8::1");
+        });
+    });
+    describe("TTL and Metadata", () => {
+        it("should handle TTL and metadata", () => {
+            new records_1.PrivateDnsAaaaRecord(stack, "test-aaaa-record", {
+                name: "www",
+                privateDnsZoneId: SAMPLE_ZONE_ID,
+                ttl: 600,
+                records: [{ ipv6Address: "2001:db8::1" }],
+                metadata: { type: "ipv6" },
+            });
+            const synthesized = cdktf_1.Testing.synth(stack);
+            expect(synthesized).toContain("600");
+            expect(synthesized).toContain("metadata");
+        });
+    });
+});
+describe("PrivateDnsCnameRecord", () => {
+    let app;
+    let stack;
+    beforeEach(() => {
+        app = cdktf_1.Testing.app();
+        stack = new cdktf.TerraformStack(app, "TestStack");
+    });
+    describe("Basic Creation", () => {
+        it("should create a CNAME record with required properties", () => {
+            const record = new records_1.PrivateDnsCnameRecord(stack, "test-cname-record", {
+                name: "app",
+                privateDnsZoneId: SAMPLE_ZONE_ID,
+                cname: "www.internal.example.com",
+            });
+            expect(record).toBeInstanceOf(records_1.PrivateDnsCnameRecord);
+            expect(record.props.name).toBe("app");
+            expect(record.props.cname).toBe("www.internal.example.com");
+        });
+    });
+    describe("Resource Type and API Version", () => {
+        it("should set correct resource type", () => {
+            new records_1.PrivateDnsCnameRecord(stack, "test-cname-record", {
+                name: "app",
+                privateDnsZoneId: SAMPLE_ZONE_ID,
+                cname: "www.internal.example.com",
+            });
+            const synthesized = cdktf_1.Testing.synth(stack);
+            expect(synthesized).toContain(private_dns_record_schemas_1.PRIVATE_DNS_CNAME_RECORD_TYPE);
+        });
+        it("should use correct API version", () => {
+            const record = new records_1.PrivateDnsCnameRecord(stack, "test-cname-record", {
+                name: "app",
+                privateDnsZoneId: SAMPLE_ZONE_ID,
+                cname: "www.internal.example.com",
+            });
+            expect(record.resolvedApiVersion).toBe("2024-06-01");
+        });
+    });
+    describe("Resource Body Structure", () => {
+        it("should include cnameRecord in the body", () => {
+            new records_1.PrivateDnsCnameRecord(stack, "test-cname-record", {
+                name: "app",
+                privateDnsZoneId: SAMPLE_ZONE_ID,
+                cname: "www.internal.example.com",
+            });
+            const synthesized = cdktf_1.Testing.synth(stack);
+            expect(synthesized).toContain("cnameRecord");
+            expect(synthesized).toContain("cname");
+            expect(synthesized).toContain("www.internal.example.com");
+        });
+    });
+    describe("TTL and Metadata", () => {
+        it("should handle TTL and metadata", () => {
+            new records_1.PrivateDnsCnameRecord(stack, "test-cname-record", {
+                name: "app",
+                privateDnsZoneId: SAMPLE_ZONE_ID,
+                ttl: 1800,
+                cname: "www.internal.example.com",
+                metadata: { alias: "true" },
+            });
+            const synthesized = cdktf_1.Testing.synth(stack);
+            expect(synthesized).toContain("1800");
+            expect(synthesized).toContain("metadata");
+        });
+    });
+});
+describe("PrivateDnsMxRecord", () => {
+    let app;
+    let stack;
+    beforeEach(() => {
+        app = cdktf_1.Testing.app();
+        stack = new cdktf.TerraformStack(app, "TestStack");
+    });
+    describe("Basic Creation", () => {
+        it("should create an MX record with required properties", () => {
+            const record = new records_1.PrivateDnsMxRecord(stack, "test-mx-record", {
+                name: "@",
+                privateDnsZoneId: SAMPLE_ZONE_ID,
+                records: [{ preference: 10, exchange: "mail1.internal.example.com" }],
+            });
+            expect(record).toBeInstanceOf(records_1.PrivateDnsMxRecord);
+            expect(record.props.name).toBe("@");
+            expect(record.props.records[0].preference).toBe(10);
+            expect(record.props.records[0].exchange).toBe("mail1.internal.example.com");
+        });
+        it("should create an MX record with multiple mail servers", () => {
+            const record = new records_1.PrivateDnsMxRecord(stack, "test-mx-record-multi", {
+                name: "@",
+                privateDnsZoneId: SAMPLE_ZONE_ID,
+                records: [
+                    { preference: 10, exchange: "mail1.internal.example.com" },
+                    { preference: 20, exchange: "mail2.internal.example.com" },
+                ],
+            });
+            expect(record.props.records).toHaveLength(2);
+        });
+    });
+    describe("Resource Type and API Version", () => {
+        it("should set correct resource type", () => {
+            new records_1.PrivateDnsMxRecord(stack, "test-mx-record", {
+                name: "@",
+                privateDnsZoneId: SAMPLE_ZONE_ID,
+                records: [{ preference: 10, exchange: "mail1.internal.example.com" }],
+            });
+            const synthesized = cdktf_1.Testing.synth(stack);
+            expect(synthesized).toContain(private_dns_record_schemas_1.PRIVATE_DNS_MX_RECORD_TYPE);
+        });
+        it("should use correct API version", () => {
+            const record = new records_1.PrivateDnsMxRecord(stack, "test-mx-record", {
+                name: "@",
+                privateDnsZoneId: SAMPLE_ZONE_ID,
+                records: [{ preference: 10, exchange: "mail1.internal.example.com" }],
+            });
+            expect(record.resolvedApiVersion).toBe("2024-06-01");
+        });
+    });
+    describe("Resource Body Structure", () => {
+        it("should include mxRecords in the body", () => {
+            new records_1.PrivateDnsMxRecord(stack, "test-mx-record", {
+                name: "@",
+                privateDnsZoneId: SAMPLE_ZONE_ID,
+                records: [{ preference: 10, exchange: "mail1.internal.example.com" }],
+            });
+            const synthesized = cdktf_1.Testing.synth(stack);
+            expect(synthesized).toContain("mxRecords");
+            expect(synthesized).toContain("preference");
+            expect(synthesized).toContain("exchange");
+        });
+    });
+});
+describe("PrivateDnsPtrRecord", () => {
+    let app;
+    let stack;
+    beforeEach(() => {
+        app = cdktf_1.Testing.app();
+        stack = new cdktf.TerraformStack(app, "TestStack");
+    });
+    describe("Basic Creation", () => {
+        it("should create a PTR record with required properties", () => {
+            const record = new records_1.PrivateDnsPtrRecord(stack, "test-ptr-record", {
+                name: "4",
+                privateDnsZoneId: SAMPLE_ZONE_ID,
+                records: [{ ptrdname: "server1.internal.example.com" }],
+            });
+            expect(record).toBeInstanceOf(records_1.PrivateDnsPtrRecord);
+            expect(record.props.name).toBe("4");
+            expect(record.props.records[0].ptrdname).toBe("server1.internal.example.com");
+        });
+        it("should create a PTR record with multiple targets", () => {
+            const record = new records_1.PrivateDnsPtrRecord(stack, "test-ptr-record-multi", {
+                name: "4",
+                privateDnsZoneId: SAMPLE_ZONE_ID,
+                records: [
+                    { ptrdname: "server1.internal.example.com" },
+                    { ptrdname: "server1-alias.internal.example.com" },
+                ],
+            });
+            expect(record.props.records).toHaveLength(2);
+        });
+    });
+    describe("Resource Type and API Version", () => {
+        it("should set correct resource type", () => {
+            new records_1.PrivateDnsPtrRecord(stack, "test-ptr-record", {
+                name: "4",
+                privateDnsZoneId: SAMPLE_ZONE_ID,
+                records: [{ ptrdname: "server1.internal.example.com" }],
+            });
+            const synthesized = cdktf_1.Testing.synth(stack);
+            expect(synthesized).toContain(private_dns_record_schemas_1.PRIVATE_DNS_PTR_RECORD_TYPE);
+        });
+        it("should use correct API version", () => {
+            const record = new records_1.PrivateDnsPtrRecord(stack, "test-ptr-record", {
+                name: "4",
+                privateDnsZoneId: SAMPLE_ZONE_ID,
+                records: [{ ptrdname: "server1.internal.example.com" }],
+            });
+            expect(record.resolvedApiVersion).toBe("2024-06-01");
+        });
+    });
+    describe("Resource Body Structure", () => {
+        it("should include ptrRecords in the body", () => {
+            new records_1.PrivateDnsPtrRecord(stack, "test-ptr-record", {
+                name: "4",
+                privateDnsZoneId: SAMPLE_ZONE_ID,
+                records: [{ ptrdname: "server1.internal.example.com" }],
+            });
+            const synthesized = cdktf_1.Testing.synth(stack);
+            expect(synthesized).toContain("ptrRecords");
+            expect(synthesized).toContain("ptrdname");
+        });
+    });
+});
+describe("PrivateDnsSoaRecord", () => {
+    let app;
+    let stack;
+    beforeEach(() => {
+        app = cdktf_1.Testing.app();
+        stack = new cdktf.TerraformStack(app, "TestStack");
+    });
+    describe("Basic Creation", () => {
+        it("should create a SOA record with required properties", () => {
+            const record = new records_1.PrivateDnsSoaRecord(stack, "test-soa-record", {
+                name: "@",
+                privateDnsZoneId: SAMPLE_ZONE_ID,
+                soaRecord: {
+                    email: "admin.example.com",
+                },
+            });
+            expect(record).toBeInstanceOf(records_1.PrivateDnsSoaRecord);
+            expect(record.props.name).toBe("@");
+            expect(record.props.soaRecord.email).toBe("admin.example.com");
+        });
+        it("should create a SOA record with all optional properties", () => {
+            const record = new records_1.PrivateDnsSoaRecord(stack, "test-soa-record-full", {
+                name: "@",
+                privateDnsZoneId: SAMPLE_ZONE_ID,
+                soaRecord: {
+                    email: "admin.example.com",
+                    host: "ns1.example.com",
+                    serialNumber: 1,
+                    refreshTime: 3600,
+                    retryTime: 300,
+                    expireTime: 2419200,
+                    minimumTtl: 300,
+                },
+            });
+            expect(record.props.soaRecord.host).toBe("ns1.example.com");
+            expect(record.props.soaRecord.refreshTime).toBe(3600);
+            expect(record.props.soaRecord.retryTime).toBe(300);
+            expect(record.props.soaRecord.expireTime).toBe(2419200);
+            expect(record.props.soaRecord.minimumTtl).toBe(300);
+        });
+    });
+    describe("Resource Type and API Version", () => {
+        it("should set correct resource type", () => {
+            new records_1.PrivateDnsSoaRecord(stack, "test-soa-record", {
+                name: "@",
+                privateDnsZoneId: SAMPLE_ZONE_ID,
+                soaRecord: {
+                    email: "admin.example.com",
+                },
+            });
+            const synthesized = cdktf_1.Testing.synth(stack);
+            expect(synthesized).toContain(private_dns_record_schemas_1.PRIVATE_DNS_SOA_RECORD_TYPE);
+        });
+        it("should use correct API version", () => {
+            const record = new records_1.PrivateDnsSoaRecord(stack, "test-soa-record", {
+                name: "@",
+                privateDnsZoneId: SAMPLE_ZONE_ID,
+                soaRecord: {
+                    email: "admin.example.com",
+                },
+            });
+            expect(record.resolvedApiVersion).toBe("2024-06-01");
+        });
+    });
+    describe("Resource Body Structure", () => {
+        it("should include soaRecord in the body", () => {
+            new records_1.PrivateDnsSoaRecord(stack, "test-soa-record", {
+                name: "@",
+                privateDnsZoneId: SAMPLE_ZONE_ID,
+                soaRecord: {
+                    email: "admin.example.com",
+                    refreshTime: 3600,
+                },
+            });
+            const synthesized = cdktf_1.Testing.synth(stack);
+            expect(synthesized).toContain("soaRecord");
+            expect(synthesized).toContain("email");
+            expect(synthesized).toContain("refreshTime");
+        });
+    });
+});
+describe("PrivateDnsSrvRecord", () => {
+    let app;
+    let stack;
+    beforeEach(() => {
+        app = cdktf_1.Testing.app();
+        stack = new cdktf.TerraformStack(app, "TestStack");
+    });
+    describe("Basic Creation", () => {
+        it("should create an SRV record with required properties", () => {
+            const record = new records_1.PrivateDnsSrvRecord(stack, "test-srv-record", {
+                name: "_sip._tcp",
+                privateDnsZoneId: SAMPLE_ZONE_ID,
+                records: [
+                    {
+                        priority: 10,
+                        weight: 60,
+                        port: 5060,
+                        target: "sipserver1.internal.example.com",
+                    },
+                ],
+            });
+            expect(record).toBeInstanceOf(records_1.PrivateDnsSrvRecord);
+            expect(record.props.name).toBe("_sip._tcp");
+            expect(record.props.records[0].priority).toBe(10);
+            expect(record.props.records[0].weight).toBe(60);
+            expect(record.props.records[0].port).toBe(5060);
+            expect(record.props.records[0].target).toBe("sipserver1.internal.example.com");
+        });
+        it("should create an SRV record with multiple servers", () => {
+            const record = new records_1.PrivateDnsSrvRecord(stack, "test-srv-record-multi", {
+                name: "_sip._tcp",
+                privateDnsZoneId: SAMPLE_ZONE_ID,
+                records: [
+                    {
+                        priority: 10,
+                        weight: 60,
+                        port: 5060,
+                        target: "sipserver1.internal.example.com",
+                    },
+                    {
+                        priority: 10,
+                        weight: 40,
+                        port: 5060,
+                        target: "sipserver2.internal.example.com",
+                    },
+                ],
+            });
+            expect(record.props.records).toHaveLength(2);
+        });
+    });
+    describe("Resource Type and API Version", () => {
+        it("should set correct resource type", () => {
+            new records_1.PrivateDnsSrvRecord(stack, "test-srv-record", {
+                name: "_sip._tcp",
+                privateDnsZoneId: SAMPLE_ZONE_ID,
+                records: [
+                    {
+                        priority: 10,
+                        weight: 60,
+                        port: 5060,
+                        target: "sipserver1.internal.example.com",
+                    },
+                ],
+            });
+            const synthesized = cdktf_1.Testing.synth(stack);
+            expect(synthesized).toContain(private_dns_record_schemas_1.PRIVATE_DNS_SRV_RECORD_TYPE);
+        });
+        it("should use correct API version", () => {
+            const record = new records_1.PrivateDnsSrvRecord(stack, "test-srv-record", {
+                name: "_sip._tcp",
+                privateDnsZoneId: SAMPLE_ZONE_ID,
+                records: [
+                    {
+                        priority: 10,
+                        weight: 60,
+                        port: 5060,
+                        target: "sipserver1.internal.example.com",
+                    },
+                ],
+            });
+            expect(record.resolvedApiVersion).toBe("2024-06-01");
+        });
+    });
+    describe("Resource Body Structure", () => {
+        it("should include srvRecords in the body", () => {
+            new records_1.PrivateDnsSrvRecord(stack, "test-srv-record", {
+                name: "_sip._tcp",
+                privateDnsZoneId: SAMPLE_ZONE_ID,
+                records: [
+                    {
+                        priority: 10,
+                        weight: 60,
+                        port: 5060,
+                        target: "sipserver1.internal.example.com",
+                    },
+                ],
+            });
+            const synthesized = cdktf_1.Testing.synth(stack);
+            expect(synthesized).toContain("srvRecords");
+            expect(synthesized).toContain("priority");
+            expect(synthesized).toContain("weight");
+            expect(synthesized).toContain("port");
+            expect(synthesized).toContain("target");
+        });
+    });
+});
+describe("PrivateDnsTxtRecord", () => {
+    let app;
+    let stack;
+    beforeEach(() => {
+        app = cdktf_1.Testing.app();
+        stack = new cdktf.TerraformStack(app, "TestStack");
+    });
+    describe("Basic Creation", () => {
+        it("should create a TXT record with required properties", () => {
+            const record = new records_1.PrivateDnsTxtRecord(stack, "test-txt-record", {
+                name: "@",
+                privateDnsZoneId: SAMPLE_ZONE_ID,
+                records: [
+                    { value: ["v=spf1 include:spf.protection.outlook.com -all"] },
+                ],
+            });
+            expect(record).toBeInstanceOf(records_1.PrivateDnsTxtRecord);
+            expect(record.props.name).toBe("@");
+            expect(record.props.records[0].value).toContain("v=spf1 include:spf.protection.outlook.com -all");
+        });
+        it("should create a TXT record with multiple entries", () => {
+            const record = new records_1.PrivateDnsTxtRecord(stack, "test-txt-record-multi", {
+                name: "@",
+                privateDnsZoneId: SAMPLE_ZONE_ID,
+                records: [
+                    { value: ["v=spf1 include:spf.protection.outlook.com -all"] },
+                    { value: ["google-site-verification=abc123"] },
+                ],
+            });
+            expect(record.props.records).toHaveLength(2);
+        });
+        it("should handle TXT record with multiple string values", () => {
+            const record = new records_1.PrivateDnsTxtRecord(stack, "test-txt-record-split", {
+                name: "_dmarc",
+                privateDnsZoneId: SAMPLE_ZONE_ID,
+                records: [
+                    {
+                        value: [
+                            "v=DMARC1;",
+                            "p=quarantine;",
+                            "rua=mailto:dmarc@example.com",
+                        ],
+                    },
+                ],
+            });
+            expect(record.props.records[0].value).toHaveLength(3);
+        });
+    });
+    describe("Resource Type and API Version", () => {
+        it("should set correct resource type", () => {
+            new records_1.PrivateDnsTxtRecord(stack, "test-txt-record", {
+                name: "@",
+                privateDnsZoneId: SAMPLE_ZONE_ID,
+                records: [{ value: ["v=spf1 -all"] }],
+            });
+            const synthesized = cdktf_1.Testing.synth(stack);
+            expect(synthesized).toContain(private_dns_record_schemas_1.PRIVATE_DNS_TXT_RECORD_TYPE);
+        });
+        it("should use correct API version", () => {
+            const record = new records_1.PrivateDnsTxtRecord(stack, "test-txt-record", {
+                name: "@",
+                privateDnsZoneId: SAMPLE_ZONE_ID,
+                records: [{ value: ["v=spf1 -all"] }],
+            });
+            expect(record.resolvedApiVersion).toBe("2024-06-01");
+        });
+    });
+    describe("Resource Body Structure", () => {
+        it("should include txtRecords in the body", () => {
+            new records_1.PrivateDnsTxtRecord(stack, "test-txt-record", {
+                name: "@",
+                privateDnsZoneId: SAMPLE_ZONE_ID,
+                records: [{ value: ["v=spf1 -all"] }],
+            });
+            const synthesized = cdktf_1.Testing.synth(stack);
+            expect(synthesized).toContain("txtRecords");
+            expect(synthesized).toContain("value");
+        });
+    });
+});
+describe("Private DNS Records - Cross-cutting Concerns", () => {
+    let app;
+    let stack;
+    beforeEach(() => {
+        app = cdktf_1.Testing.app();
+        stack = new cdktf.TerraformStack(app, "TestStack");
+    });
+    describe("Multiple Record Types in Same Stack", () => {
+        it("should handle multiple record types in the same stack", () => {
+            new records_1.PrivateDnsARecord(stack, "a-record", {
+                name: "www",
+                privateDnsZoneId: SAMPLE_ZONE_ID,
+                records: [{ ipv4Address: "10.0.1.4" }],
+            });
+            new records_1.PrivateDnsAaaaRecord(stack, "aaaa-record", {
+                name: "www",
+                privateDnsZoneId: SAMPLE_ZONE_ID,
+                records: [{ ipv6Address: "2001:db8::1" }],
+            });
+            new records_1.PrivateDnsCnameRecord(stack, "cname-record", {
+                name: "app",
+                privateDnsZoneId: SAMPLE_ZONE_ID,
+                cname: "www.example.com",
+            });
+            const synthesized = cdktf_1.Testing.synth(stack);
+            expect(synthesized).toContain(private_dns_record_schemas_1.PRIVATE_DNS_A_RECORD_TYPE);
+            expect(synthesized).toContain(private_dns_record_schemas_1.PRIVATE_DNS_AAAA_RECORD_TYPE);
+            expect(synthesized).toContain(private_dns_record_schemas_1.PRIVATE_DNS_CNAME_RECORD_TYPE);
+        });
+    });
+    describe("Terraform Synthesis", () => {
+        it("should synthesize valid Terraform configuration", () => {
+            new records_1.PrivateDnsARecord(stack, "test-a-record", {
+                name: "www",
+                privateDnsZoneId: SAMPLE_ZONE_ID,
+                records: [{ ipv4Address: "10.0.1.4" }],
+            });
+            const synthesized = cdktf_1.Testing.synth(stack);
+            expect(synthesized).toBeDefined();
+            const stackConfig = JSON.parse(synthesized);
+            expect(stackConfig.resource).toBeDefined();
+        });
+    });
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"private-dns-records.spec.js","sourceRoot":"","sources":["../../../src/azure-privatednszone/test/private-dns-records.spec.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Unit tests for Azure Private DNS Zone Record implementations\n *\n * This test suite validates all 8 Private DNS record types:\n * - PrivateDnsARecord\n * - PrivateDnsAaaaRecord\n * - PrivateDnsCnameRecord\n * - PrivateDnsMxRecord\n * - PrivateDnsPtrRecord\n * - PrivateDnsSoaRecord\n * - PrivateDnsSrvRecord\n * - PrivateDnsTxtRecord\n *\n * Tests verify basic creation, correct resource types, API versions,\n * parent ID resolution, resource body structure, TTL handling,\n * record-specific properties, and metadata handling.\n */\n\nimport { Testing } from \"cdktf\";\nimport * as cdktf from \"cdktf\";\nimport {\n  PrivateDnsARecord,\n  PrivateDnsAaaaRecord,\n  PrivateDnsCnameRecord,\n  PrivateDnsMxRecord,\n  PrivateDnsPtrRecord,\n  PrivateDnsSoaRecord,\n  PrivateDnsSrvRecord,\n  PrivateDnsTxtRecord,\n} from \"../lib/records\";\nimport {\n  PRIVATE_DNS_A_RECORD_TYPE,\n  PRIVATE_DNS_AAAA_RECORD_TYPE,\n  PRIVATE_DNS_CNAME_RECORD_TYPE,\n  PRIVATE_DNS_MX_RECORD_TYPE,\n  PRIVATE_DNS_PTR_RECORD_TYPE,\n  PRIVATE_DNS_SOA_RECORD_TYPE,\n  PRIVATE_DNS_SRV_RECORD_TYPE,\n  PRIVATE_DNS_TXT_RECORD_TYPE,\n} from \"../lib/records/private-dns-record-schemas\";\n\n// Sample Private DNS Zone ID for testing\nconst SAMPLE_ZONE_ID =\n  \"/subscriptions/12345678-1234-1234-1234-123456789012/resourceGroups/rg-test/providers/Microsoft.Network/privateDnsZones/example.com\";\n\ndescribe(\"PrivateDnsARecord\", () => {\n  let app: cdktf.App;\n  let stack: cdktf.TerraformStack;\n\n  beforeEach(() => {\n    app = Testing.app();\n    stack = new cdktf.TerraformStack(app, \"TestStack\");\n  });\n\n  describe(\"Basic Creation\", () => {\n    it(\"should create an A record with required properties\", () => {\n      const record = new PrivateDnsARecord(stack, \"test-a-record\", {\n        name: \"www\",\n        privateDnsZoneId: SAMPLE_ZONE_ID,\n        records: [{ ipv4Address: \"10.0.1.4\" }],\n      });\n\n      expect(record).toBeInstanceOf(PrivateDnsARecord);\n      expect(record.props.name).toBe(\"www\");\n      expect(record.props.privateDnsZoneId).toBe(SAMPLE_ZONE_ID);\n      expect(record.props.records).toHaveLength(1);\n      expect(record.props.records[0].ipv4Address).toBe(\"10.0.1.4\");\n    });\n\n    it(\"should create an A record with multiple IP addresses\", () => {\n      const record = new PrivateDnsARecord(stack, \"test-a-record-multi\", {\n        name: \"www\",\n        privateDnsZoneId: SAMPLE_ZONE_ID,\n        records: [{ ipv4Address: \"10.0.1.4\" }, { ipv4Address: \"10.0.1.5\" }],\n      });\n\n      expect(record.props.records).toHaveLength(2);\n    });\n\n    it(\"should create an apex A record with @ name\", () => {\n      const record = new PrivateDnsARecord(stack, \"test-a-record-apex\", {\n        name: \"@\",\n        privateDnsZoneId: SAMPLE_ZONE_ID,\n        records: [{ ipv4Address: \"10.0.1.4\" }],\n      });\n\n      expect(record.props.name).toBe(\"@\");\n    });\n  });\n\n  describe(\"Resource Type and API Version\", () => {\n    it(\"should set correct resource type\", () => {\n      new PrivateDnsARecord(stack, \"test-a-record\", {\n        name: \"www\",\n        privateDnsZoneId: SAMPLE_ZONE_ID,\n        records: [{ ipv4Address: \"10.0.1.4\" }],\n      });\n\n      const synthesized = Testing.synth(stack);\n      expect(synthesized).toContain(PRIVATE_DNS_A_RECORD_TYPE);\n    });\n\n    it(\"should use correct API version\", () => {\n      const record = new PrivateDnsARecord(stack, \"test-a-record\", {\n        name: \"www\",\n        privateDnsZoneId: SAMPLE_ZONE_ID,\n        records: [{ ipv4Address: \"10.0.1.4\" }],\n      });\n\n      expect(record.resolvedApiVersion).toBe(\"2024-06-01\");\n    });\n  });\n\n  describe(\"Parent ID Resolution\", () => {\n    it(\"should set parentId to the zone ID\", () => {\n      new PrivateDnsARecord(stack, \"test-a-record\", {\n        name: \"www\",\n        privateDnsZoneId: SAMPLE_ZONE_ID,\n        records: [{ ipv4Address: \"10.0.1.4\" }],\n      });\n\n      const synthesized = Testing.synth(stack);\n      expect(synthesized).toContain(SAMPLE_ZONE_ID);\n    });\n  });\n\n  describe(\"TTL Handling\", () => {\n    it(\"should use default TTL of 3600 when not specified\", () => {\n      new PrivateDnsARecord(stack, \"test-a-record\", {\n        name: \"www\",\n        privateDnsZoneId: SAMPLE_ZONE_ID,\n        records: [{ ipv4Address: \"10.0.1.4\" }],\n      });\n\n      const synthesized = Testing.synth(stack);\n      expect(synthesized).toContain(\"3600\");\n    });\n\n    it(\"should use custom TTL when specified\", () => {\n      new PrivateDnsARecord(stack, \"test-a-record\", {\n        name: \"www\",\n        privateDnsZoneId: SAMPLE_ZONE_ID,\n        ttl: 300,\n        records: [{ ipv4Address: \"10.0.1.4\" }],\n      });\n\n      const synthesized = Testing.synth(stack);\n      expect(synthesized).toContain(\"300\");\n    });\n  });\n\n  describe(\"Resource Body Structure\", () => {\n    it(\"should include aRecords in the body\", () => {\n      new PrivateDnsARecord(stack, \"test-a-record\", {\n        name: \"www\",\n        privateDnsZoneId: SAMPLE_ZONE_ID,\n        records: [{ ipv4Address: \"10.0.1.4\" }],\n      });\n\n      const synthesized = Testing.synth(stack);\n      expect(synthesized).toContain(\"aRecords\");\n      expect(synthesized).toContain(\"ipv4Address\");\n      expect(synthesized).toContain(\"10.0.1.4\");\n    });\n  });\n\n  describe(\"Metadata Handling\", () => {\n    it(\"should include metadata when provided\", () => {\n      new PrivateDnsARecord(stack, \"test-a-record\", {\n        name: \"www\",\n        privateDnsZoneId: SAMPLE_ZONE_ID,\n        records: [{ ipv4Address: \"10.0.1.4\" }],\n        metadata: { environment: \"test\", owner: \"team-a\" },\n      });\n\n      const synthesized = Testing.synth(stack);\n      expect(synthesized).toContain(\"metadata\");\n      expect(synthesized).toContain(\"environment\");\n      expect(synthesized).toContain(\"test\");\n    });\n\n    it(\"should not include metadata when not provided\", () => {\n      new PrivateDnsARecord(stack, \"test-a-record\", {\n        name: \"www\",\n        privateDnsZoneId: SAMPLE_ZONE_ID,\n        records: [{ ipv4Address: \"10.0.1.4\" }],\n      });\n\n      const synthesized = Testing.synth(stack);\n      // Check that metadata is not mentioned in the synthesized output when not provided\n      // We just verify the record was created successfully without metadata in props\n      expect(synthesized).toBeDefined();\n      // The absence of metadata in the record definition should result in no metadata key in the body\n      // Since metadata is optional and not specified, it shouldn't appear in the output\n    });\n  });\n\n  describe(\"Outputs\", () => {\n    it(\"should create required outputs\", () => {\n      const record = new PrivateDnsARecord(stack, \"test-a-record\", {\n        name: \"www\",\n        privateDnsZoneId: SAMPLE_ZONE_ID,\n        records: [{ ipv4Address: \"10.0.1.4\" }],\n      });\n\n      expect(record.idOutput).toBeInstanceOf(cdktf.TerraformOutput);\n      expect(record.nameOutput).toBeInstanceOf(cdktf.TerraformOutput);\n      expect(record.fqdnOutput).toBeInstanceOf(cdktf.TerraformOutput);\n    });\n\n    it(\"should provide fqdn property\", () => {\n      const record = new PrivateDnsARecord(stack, \"test-a-record\", {\n        name: \"www\",\n        privateDnsZoneId: SAMPLE_ZONE_ID,\n        records: [{ ipv4Address: \"10.0.1.4\" }],\n      });\n\n      expect(record.fqdn).toBeDefined();\n      expect(typeof record.fqdn).toBe(\"string\");\n    });\n  });\n});\n\ndescribe(\"PrivateDnsAaaaRecord\", () => {\n  let app: cdktf.App;\n  let stack: cdktf.TerraformStack;\n\n  beforeEach(() => {\n    app = Testing.app();\n    stack = new cdktf.TerraformStack(app, \"TestStack\");\n  });\n\n  describe(\"Basic Creation\", () => {\n    it(\"should create an AAAA record with required properties\", () => {\n      const record = new PrivateDnsAaaaRecord(stack, \"test-aaaa-record\", {\n        name: \"www\",\n        privateDnsZoneId: SAMPLE_ZONE_ID,\n        records: [{ ipv6Address: \"2001:db8::1\" }],\n      });\n\n      expect(record).toBeInstanceOf(PrivateDnsAaaaRecord);\n      expect(record.props.name).toBe(\"www\");\n      expect(record.props.records[0].ipv6Address).toBe(\"2001:db8::1\");\n    });\n\n    it(\"should create an AAAA record with multiple IPv6 addresses\", () => {\n      const record = new PrivateDnsAaaaRecord(stack, \"test-aaaa-record-multi\", {\n        name: \"www\",\n        privateDnsZoneId: SAMPLE_ZONE_ID,\n        records: [\n          { ipv6Address: \"2001:db8::1\" },\n          { ipv6Address: \"2001:db8::2\" },\n        ],\n      });\n\n      expect(record.props.records).toHaveLength(2);\n    });\n  });\n\n  describe(\"Resource Type and API Version\", () => {\n    it(\"should set correct resource type\", () => {\n      new PrivateDnsAaaaRecord(stack, \"test-aaaa-record\", {\n        name: \"www\",\n        privateDnsZoneId: SAMPLE_ZONE_ID,\n        records: [{ ipv6Address: \"2001:db8::1\" }],\n      });\n\n      const synthesized = Testing.synth(stack);\n      expect(synthesized).toContain(PRIVATE_DNS_AAAA_RECORD_TYPE);\n    });\n\n    it(\"should use correct API version\", () => {\n      const record = new PrivateDnsAaaaRecord(stack, \"test-aaaa-record\", {\n        name: \"www\",\n        privateDnsZoneId: SAMPLE_ZONE_ID,\n        records: [{ ipv6Address: \"2001:db8::1\" }],\n      });\n\n      expect(record.resolvedApiVersion).toBe(\"2024-06-01\");\n    });\n  });\n\n  describe(\"Resource Body Structure\", () => {\n    it(\"should include aaaaRecords in the body\", () => {\n      new PrivateDnsAaaaRecord(stack, \"test-aaaa-record\", {\n        name: \"www\",\n        privateDnsZoneId: SAMPLE_ZONE_ID,\n        records: [{ ipv6Address: \"2001:db8::1\" }],\n      });\n\n      const synthesized = Testing.synth(stack);\n      expect(synthesized).toContain(\"aaaaRecords\");\n      expect(synthesized).toContain(\"ipv6Address\");\n      expect(synthesized).toContain(\"2001:db8::1\");\n    });\n  });\n\n  describe(\"TTL and Metadata\", () => {\n    it(\"should handle TTL and metadata\", () => {\n      new PrivateDnsAaaaRecord(stack, \"test-aaaa-record\", {\n        name: \"www\",\n        privateDnsZoneId: SAMPLE_ZONE_ID,\n        ttl: 600,\n        records: [{ ipv6Address: \"2001:db8::1\" }],\n        metadata: { type: \"ipv6\" },\n      });\n\n      const synthesized = Testing.synth(stack);\n      expect(synthesized).toContain(\"600\");\n      expect(synthesized).toContain(\"metadata\");\n    });\n  });\n});\n\ndescribe(\"PrivateDnsCnameRecord\", () => {\n  let app: cdktf.App;\n  let stack: cdktf.TerraformStack;\n\n  beforeEach(() => {\n    app = Testing.app();\n    stack = new cdktf.TerraformStack(app, \"TestStack\");\n  });\n\n  describe(\"Basic Creation\", () => {\n    it(\"should create a CNAME record with required properties\", () => {\n      const record = new PrivateDnsCnameRecord(stack, \"test-cname-record\", {\n        name: \"app\",\n        privateDnsZoneId: SAMPLE_ZONE_ID,\n        cname: \"www.internal.example.com\",\n      });\n\n      expect(record).toBeInstanceOf(PrivateDnsCnameRecord);\n      expect(record.props.name).toBe(\"app\");\n      expect(record.props.cname).toBe(\"www.internal.example.com\");\n    });\n  });\n\n  describe(\"Resource Type and API Version\", () => {\n    it(\"should set correct resource type\", () => {\n      new PrivateDnsCnameRecord(stack, \"test-cname-record\", {\n        name: \"app\",\n        privateDnsZoneId: SAMPLE_ZONE_ID,\n        cname: \"www.internal.example.com\",\n      });\n\n      const synthesized = Testing.synth(stack);\n      expect(synthesized).toContain(PRIVATE_DNS_CNAME_RECORD_TYPE);\n    });\n\n    it(\"should use correct API version\", () => {\n      const record = new PrivateDnsCnameRecord(stack, \"test-cname-record\", {\n        name: \"app\",\n        privateDnsZoneId: SAMPLE_ZONE_ID,\n        cname: \"www.internal.example.com\",\n      });\n\n      expect(record.resolvedApiVersion).toBe(\"2024-06-01\");\n    });\n  });\n\n  describe(\"Resource Body Structure\", () => {\n    it(\"should include cnameRecord in the body\", () => {\n      new PrivateDnsCnameRecord(stack, \"test-cname-record\", {\n        name: \"app\",\n        privateDnsZoneId: SAMPLE_ZONE_ID,\n        cname: \"www.internal.example.com\",\n      });\n\n      const synthesized = Testing.synth(stack);\n      expect(synthesized).toContain(\"cnameRecord\");\n      expect(synthesized).toContain(\"cname\");\n      expect(synthesized).toContain(\"www.internal.example.com\");\n    });\n  });\n\n  describe(\"TTL and Metadata\", () => {\n    it(\"should handle TTL and metadata\", () => {\n      new PrivateDnsCnameRecord(stack, \"test-cname-record\", {\n        name: \"app\",\n        privateDnsZoneId: SAMPLE_ZONE_ID,\n        ttl: 1800,\n        cname: \"www.internal.example.com\",\n        metadata: { alias: \"true\" },\n      });\n\n      const synthesized = Testing.synth(stack);\n      expect(synthesized).toContain(\"1800\");\n      expect(synthesized).toContain(\"metadata\");\n    });\n  });\n});\n\ndescribe(\"PrivateDnsMxRecord\", () => {\n  let app: cdktf.App;\n  let stack: cdktf.TerraformStack;\n\n  beforeEach(() => {\n    app = Testing.app();\n    stack = new cdktf.TerraformStack(app, \"TestStack\");\n  });\n\n  describe(\"Basic Creation\", () => {\n    it(\"should create an MX record with required properties\", () => {\n      const record = new PrivateDnsMxRecord(stack, \"test-mx-record\", {\n        name: \"@\",\n        privateDnsZoneId: SAMPLE_ZONE_ID,\n        records: [{ preference: 10, exchange: \"mail1.internal.example.com\" }],\n      });\n\n      expect(record).toBeInstanceOf(PrivateDnsMxRecord);\n      expect(record.props.name).toBe(\"@\");\n      expect(record.props.records[0].preference).toBe(10);\n      expect(record.props.records[0].exchange).toBe(\n        \"mail1.internal.example.com\",\n      );\n    });\n\n    it(\"should create an MX record with multiple mail servers\", () => {\n      const record = new PrivateDnsMxRecord(stack, \"test-mx-record-multi\", {\n        name: \"@\",\n        privateDnsZoneId: SAMPLE_ZONE_ID,\n        records: [\n          { preference: 10, exchange: \"mail1.internal.example.com\" },\n          { preference: 20, exchange: \"mail2.internal.example.com\" },\n        ],\n      });\n\n      expect(record.props.records).toHaveLength(2);\n    });\n  });\n\n  describe(\"Resource Type and API Version\", () => {\n    it(\"should set correct resource type\", () => {\n      new PrivateDnsMxRecord(stack, \"test-mx-record\", {\n        name: \"@\",\n        privateDnsZoneId: SAMPLE_ZONE_ID,\n        records: [{ preference: 10, exchange: \"mail1.internal.example.com\" }],\n      });\n\n      const synthesized = Testing.synth(stack);\n      expect(synthesized).toContain(PRIVATE_DNS_MX_RECORD_TYPE);\n    });\n\n    it(\"should use correct API version\", () => {\n      const record = new PrivateDnsMxRecord(stack, \"test-mx-record\", {\n        name: \"@\",\n        privateDnsZoneId: SAMPLE_ZONE_ID,\n        records: [{ preference: 10, exchange: \"mail1.internal.example.com\" }],\n      });\n\n      expect(record.resolvedApiVersion).toBe(\"2024-06-01\");\n    });\n  });\n\n  describe(\"Resource Body Structure\", () => {\n    it(\"should include mxRecords in the body\", () => {\n      new PrivateDnsMxRecord(stack, \"test-mx-record\", {\n        name: \"@\",\n        privateDnsZoneId: SAMPLE_ZONE_ID,\n        records: [{ preference: 10, exchange: \"mail1.internal.example.com\" }],\n      });\n\n      const synthesized = Testing.synth(stack);\n      expect(synthesized).toContain(\"mxRecords\");\n      expect(synthesized).toContain(\"preference\");\n      expect(synthesized).toContain(\"exchange\");\n    });\n  });\n});\n\ndescribe(\"PrivateDnsPtrRecord\", () => {\n  let app: cdktf.App;\n  let stack: cdktf.TerraformStack;\n\n  beforeEach(() => {\n    app = Testing.app();\n    stack = new cdktf.TerraformStack(app, \"TestStack\");\n  });\n\n  describe(\"Basic Creation\", () => {\n    it(\"should create a PTR record with required properties\", () => {\n      const record = new PrivateDnsPtrRecord(stack, \"test-ptr-record\", {\n        name: \"4\",\n        privateDnsZoneId: SAMPLE_ZONE_ID,\n        records: [{ ptrdname: \"server1.internal.example.com\" }],\n      });\n\n      expect(record).toBeInstanceOf(PrivateDnsPtrRecord);\n      expect(record.props.name).toBe(\"4\");\n      expect(record.props.records[0].ptrdname).toBe(\n        \"server1.internal.example.com\",\n      );\n    });\n\n    it(\"should create a PTR record with multiple targets\", () => {\n      const record = new PrivateDnsPtrRecord(stack, \"test-ptr-record-multi\", {\n        name: \"4\",\n        privateDnsZoneId: SAMPLE_ZONE_ID,\n        records: [\n          { ptrdname: \"server1.internal.example.com\" },\n          { ptrdname: \"server1-alias.internal.example.com\" },\n        ],\n      });\n\n      expect(record.props.records).toHaveLength(2);\n    });\n  });\n\n  describe(\"Resource Type and API Version\", () => {\n    it(\"should set correct resource type\", () => {\n      new PrivateDnsPtrRecord(stack, \"test-ptr-record\", {\n        name: \"4\",\n        privateDnsZoneId: SAMPLE_ZONE_ID,\n        records: [{ ptrdname: \"server1.internal.example.com\" }],\n      });\n\n      const synthesized = Testing.synth(stack);\n      expect(synthesized).toContain(PRIVATE_DNS_PTR_RECORD_TYPE);\n    });\n\n    it(\"should use correct API version\", () => {\n      const record = new PrivateDnsPtrRecord(stack, \"test-ptr-record\", {\n        name: \"4\",\n        privateDnsZoneId: SAMPLE_ZONE_ID,\n        records: [{ ptrdname: \"server1.internal.example.com\" }],\n      });\n\n      expect(record.resolvedApiVersion).toBe(\"2024-06-01\");\n    });\n  });\n\n  describe(\"Resource Body Structure\", () => {\n    it(\"should include ptrRecords in the body\", () => {\n      new PrivateDnsPtrRecord(stack, \"test-ptr-record\", {\n        name: \"4\",\n        privateDnsZoneId: SAMPLE_ZONE_ID,\n        records: [{ ptrdname: \"server1.internal.example.com\" }],\n      });\n\n      const synthesized = Testing.synth(stack);\n      expect(synthesized).toContain(\"ptrRecords\");\n      expect(synthesized).toContain(\"ptrdname\");\n    });\n  });\n});\n\ndescribe(\"PrivateDnsSoaRecord\", () => {\n  let app: cdktf.App;\n  let stack: cdktf.TerraformStack;\n\n  beforeEach(() => {\n    app = Testing.app();\n    stack = new cdktf.TerraformStack(app, \"TestStack\");\n  });\n\n  describe(\"Basic Creation\", () => {\n    it(\"should create a SOA record with required properties\", () => {\n      const record = new PrivateDnsSoaRecord(stack, \"test-soa-record\", {\n        name: \"@\",\n        privateDnsZoneId: SAMPLE_ZONE_ID,\n        soaRecord: {\n          email: \"admin.example.com\",\n        },\n      });\n\n      expect(record).toBeInstanceOf(PrivateDnsSoaRecord);\n      expect(record.props.name).toBe(\"@\");\n      expect(record.props.soaRecord.email).toBe(\"admin.example.com\");\n    });\n\n    it(\"should create a SOA record with all optional properties\", () => {\n      const record = new PrivateDnsSoaRecord(stack, \"test-soa-record-full\", {\n        name: \"@\",\n        privateDnsZoneId: SAMPLE_ZONE_ID,\n        soaRecord: {\n          email: \"admin.example.com\",\n          host: \"ns1.example.com\",\n          serialNumber: 1,\n          refreshTime: 3600,\n          retryTime: 300,\n          expireTime: 2419200,\n          minimumTtl: 300,\n        },\n      });\n\n      expect(record.props.soaRecord.host).toBe(\"ns1.example.com\");\n      expect(record.props.soaRecord.refreshTime).toBe(3600);\n      expect(record.props.soaRecord.retryTime).toBe(300);\n      expect(record.props.soaRecord.expireTime).toBe(2419200);\n      expect(record.props.soaRecord.minimumTtl).toBe(300);\n    });\n  });\n\n  describe(\"Resource Type and API Version\", () => {\n    it(\"should set correct resource type\", () => {\n      new PrivateDnsSoaRecord(stack, \"test-soa-record\", {\n        name: \"@\",\n        privateDnsZoneId: SAMPLE_ZONE_ID,\n        soaRecord: {\n          email: \"admin.example.com\",\n        },\n      });\n\n      const synthesized = Testing.synth(stack);\n      expect(synthesized).toContain(PRIVATE_DNS_SOA_RECORD_TYPE);\n    });\n\n    it(\"should use correct API version\", () => {\n      const record = new PrivateDnsSoaRecord(stack, \"test-soa-record\", {\n        name: \"@\",\n        privateDnsZoneId: SAMPLE_ZONE_ID,\n        soaRecord: {\n          email: \"admin.example.com\",\n        },\n      });\n\n      expect(record.resolvedApiVersion).toBe(\"2024-06-01\");\n    });\n  });\n\n  describe(\"Resource Body Structure\", () => {\n    it(\"should include soaRecord in the body\", () => {\n      new PrivateDnsSoaRecord(stack, \"test-soa-record\", {\n        name: \"@\",\n        privateDnsZoneId: SAMPLE_ZONE_ID,\n        soaRecord: {\n          email: \"admin.example.com\",\n          refreshTime: 3600,\n        },\n      });\n\n      const synthesized = Testing.synth(stack);\n      expect(synthesized).toContain(\"soaRecord\");\n      expect(synthesized).toContain(\"email\");\n      expect(synthesized).toContain(\"refreshTime\");\n    });\n  });\n});\n\ndescribe(\"PrivateDnsSrvRecord\", () => {\n  let app: cdktf.App;\n  let stack: cdktf.TerraformStack;\n\n  beforeEach(() => {\n    app = Testing.app();\n    stack = new cdktf.TerraformStack(app, \"TestStack\");\n  });\n\n  describe(\"Basic Creation\", () => {\n    it(\"should create an SRV record with required properties\", () => {\n      const record = new PrivateDnsSrvRecord(stack, \"test-srv-record\", {\n        name: \"_sip._tcp\",\n        privateDnsZoneId: SAMPLE_ZONE_ID,\n        records: [\n          {\n            priority: 10,\n            weight: 60,\n            port: 5060,\n            target: \"sipserver1.internal.example.com\",\n          },\n        ],\n      });\n\n      expect(record).toBeInstanceOf(PrivateDnsSrvRecord);\n      expect(record.props.name).toBe(\"_sip._tcp\");\n      expect(record.props.records[0].priority).toBe(10);\n      expect(record.props.records[0].weight).toBe(60);\n      expect(record.props.records[0].port).toBe(5060);\n      expect(record.props.records[0].target).toBe(\n        \"sipserver1.internal.example.com\",\n      );\n    });\n\n    it(\"should create an SRV record with multiple servers\", () => {\n      const record = new PrivateDnsSrvRecord(stack, \"test-srv-record-multi\", {\n        name: \"_sip._tcp\",\n        privateDnsZoneId: SAMPLE_ZONE_ID,\n        records: [\n          {\n            priority: 10,\n            weight: 60,\n            port: 5060,\n            target: \"sipserver1.internal.example.com\",\n          },\n          {\n            priority: 10,\n            weight: 40,\n            port: 5060,\n            target: \"sipserver2.internal.example.com\",\n          },\n        ],\n      });\n\n      expect(record.props.records).toHaveLength(2);\n    });\n  });\n\n  describe(\"Resource Type and API Version\", () => {\n    it(\"should set correct resource type\", () => {\n      new PrivateDnsSrvRecord(stack, \"test-srv-record\", {\n        name: \"_sip._tcp\",\n        privateDnsZoneId: SAMPLE_ZONE_ID,\n        records: [\n          {\n            priority: 10,\n            weight: 60,\n            port: 5060,\n            target: \"sipserver1.internal.example.com\",\n          },\n        ],\n      });\n\n      const synthesized = Testing.synth(stack);\n      expect(synthesized).toContain(PRIVATE_DNS_SRV_RECORD_TYPE);\n    });\n\n    it(\"should use correct API version\", () => {\n      const record = new PrivateDnsSrvRecord(stack, \"test-srv-record\", {\n        name: \"_sip._tcp\",\n        privateDnsZoneId: SAMPLE_ZONE_ID,\n        records: [\n          {\n            priority: 10,\n            weight: 60,\n            port: 5060,\n            target: \"sipserver1.internal.example.com\",\n          },\n        ],\n      });\n\n      expect(record.resolvedApiVersion).toBe(\"2024-06-01\");\n    });\n  });\n\n  describe(\"Resource Body Structure\", () => {\n    it(\"should include srvRecords in the body\", () => {\n      new PrivateDnsSrvRecord(stack, \"test-srv-record\", {\n        name: \"_sip._tcp\",\n        privateDnsZoneId: SAMPLE_ZONE_ID,\n        records: [\n          {\n            priority: 10,\n            weight: 60,\n            port: 5060,\n            target: \"sipserver1.internal.example.com\",\n          },\n        ],\n      });\n\n      const synthesized = Testing.synth(stack);\n      expect(synthesized).toContain(\"srvRecords\");\n      expect(synthesized).toContain(\"priority\");\n      expect(synthesized).toContain(\"weight\");\n      expect(synthesized).toContain(\"port\");\n      expect(synthesized).toContain(\"target\");\n    });\n  });\n});\n\ndescribe(\"PrivateDnsTxtRecord\", () => {\n  let app: cdktf.App;\n  let stack: cdktf.TerraformStack;\n\n  beforeEach(() => {\n    app = Testing.app();\n    stack = new cdktf.TerraformStack(app, \"TestStack\");\n  });\n\n  describe(\"Basic Creation\", () => {\n    it(\"should create a TXT record with required properties\", () => {\n      const record = new PrivateDnsTxtRecord(stack, \"test-txt-record\", {\n        name: \"@\",\n        privateDnsZoneId: SAMPLE_ZONE_ID,\n        records: [\n          { value: [\"v=spf1 include:spf.protection.outlook.com -all\"] },\n        ],\n      });\n\n      expect(record).toBeInstanceOf(PrivateDnsTxtRecord);\n      expect(record.props.name).toBe(\"@\");\n      expect(record.props.records[0].value).toContain(\n        \"v=spf1 include:spf.protection.outlook.com -all\",\n      );\n    });\n\n    it(\"should create a TXT record with multiple entries\", () => {\n      const record = new PrivateDnsTxtRecord(stack, \"test-txt-record-multi\", {\n        name: \"@\",\n        privateDnsZoneId: SAMPLE_ZONE_ID,\n        records: [\n          { value: [\"v=spf1 include:spf.protection.outlook.com -all\"] },\n          { value: [\"google-site-verification=abc123\"] },\n        ],\n      });\n\n      expect(record.props.records).toHaveLength(2);\n    });\n\n    it(\"should handle TXT record with multiple string values\", () => {\n      const record = new PrivateDnsTxtRecord(stack, \"test-txt-record-split\", {\n        name: \"_dmarc\",\n        privateDnsZoneId: SAMPLE_ZONE_ID,\n        records: [\n          {\n            value: [\n              \"v=DMARC1;\",\n              \"p=quarantine;\",\n              \"rua=mailto:dmarc@example.com\",\n            ],\n          },\n        ],\n      });\n\n      expect(record.props.records[0].value).toHaveLength(3);\n    });\n  });\n\n  describe(\"Resource Type and API Version\", () => {\n    it(\"should set correct resource type\", () => {\n      new PrivateDnsTxtRecord(stack, \"test-txt-record\", {\n        name: \"@\",\n        privateDnsZoneId: SAMPLE_ZONE_ID,\n        records: [{ value: [\"v=spf1 -all\"] }],\n      });\n\n      const synthesized = Testing.synth(stack);\n      expect(synthesized).toContain(PRIVATE_DNS_TXT_RECORD_TYPE);\n    });\n\n    it(\"should use correct API version\", () => {\n      const record = new PrivateDnsTxtRecord(stack, \"test-txt-record\", {\n        name: \"@\",\n        privateDnsZoneId: SAMPLE_ZONE_ID,\n        records: [{ value: [\"v=spf1 -all\"] }],\n      });\n\n      expect(record.resolvedApiVersion).toBe(\"2024-06-01\");\n    });\n  });\n\n  describe(\"Resource Body Structure\", () => {\n    it(\"should include txtRecords in the body\", () => {\n      new PrivateDnsTxtRecord(stack, \"test-txt-record\", {\n        name: \"@\",\n        privateDnsZoneId: SAMPLE_ZONE_ID,\n        records: [{ value: [\"v=spf1 -all\"] }],\n      });\n\n      const synthesized = Testing.synth(stack);\n      expect(synthesized).toContain(\"txtRecords\");\n      expect(synthesized).toContain(\"value\");\n    });\n  });\n});\n\ndescribe(\"Private DNS Records - Cross-cutting Concerns\", () => {\n  let app: cdktf.App;\n  let stack: cdktf.TerraformStack;\n\n  beforeEach(() => {\n    app = Testing.app();\n    stack = new cdktf.TerraformStack(app, \"TestStack\");\n  });\n\n  describe(\"Multiple Record Types in Same Stack\", () => {\n    it(\"should handle multiple record types in the same stack\", () => {\n      new PrivateDnsARecord(stack, \"a-record\", {\n        name: \"www\",\n        privateDnsZoneId: SAMPLE_ZONE_ID,\n        records: [{ ipv4Address: \"10.0.1.4\" }],\n      });\n\n      new PrivateDnsAaaaRecord(stack, \"aaaa-record\", {\n        name: \"www\",\n        privateDnsZoneId: SAMPLE_ZONE_ID,\n        records: [{ ipv6Address: \"2001:db8::1\" }],\n      });\n\n      new PrivateDnsCnameRecord(stack, \"cname-record\", {\n        name: \"app\",\n        privateDnsZoneId: SAMPLE_ZONE_ID,\n        cname: \"www.example.com\",\n      });\n\n      const synthesized = Testing.synth(stack);\n      expect(synthesized).toContain(PRIVATE_DNS_A_RECORD_TYPE);\n      expect(synthesized).toContain(PRIVATE_DNS_AAAA_RECORD_TYPE);\n      expect(synthesized).toContain(PRIVATE_DNS_CNAME_RECORD_TYPE);\n    });\n  });\n\n  describe(\"Terraform Synthesis\", () => {\n    it(\"should synthesize valid Terraform configuration\", () => {\n      new PrivateDnsARecord(stack, \"test-a-record\", {\n        name: \"www\",\n        privateDnsZoneId: SAMPLE_ZONE_ID,\n        records: [{ ipv4Address: \"10.0.1.4\" }],\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});\n"]}