fixup! Reimplement the FORMERR system test in Python

diff --git a/bin/tests/system/formerr/tests_formerr.py b/bin/tests/system/formerr/tests_formerr.py
index c8e3d13a4a13e9181af06d5f0e0364ddbfa9302d..b38712f7fbe87de7b080d537e46af2fc7d38a3cc 100644 (file)
--- a/bin/tests/system/formerr/tests_formerr.py
+++ b/bin/tests/system/formerr/tests_formerr.py
@@ -43,15 +43,15 @@ def u32(value: int) -> bytes:
     return value.to_bytes(4, byteorder="big")
 
 
-def name_wire(name: str) -> bytes:
-    return dns.name.from_text(name).to_wire()
+def name(text: str) -> bytes:
+    return dns.name.from_text(text).to_wire()
 
 
-def root_wire() -> bytes:
+def root() -> bytes:
     return dns.name.root.to_wire()
 
 
-def dns_header(
+def header(
     message_id: int = 0,
     flags: int = 0,
     opcode: int = dns.opcode.QUERY,
@@ -80,7 +80,7 @@ def formerr_response_header(
     nscount: int = 0,
     arcount: int = 0,
 ) -> bytes:
-    return dns_header(
+    return header(
         message_id=message_id,
         flags=dns.flags.QR,
         opcode=opcode,
@@ -92,19 +92,19 @@ def formerr_response_header(
     )
 
 
-def question_wire(
-    qname_wire: bytes,
+def question(
+    qname: bytes,
     qtype: dns.rdatatype.RdataType = dns.rdatatype.RdataType.A,
     qclass: dns.rdataclass.RdataClass = dns.rdataclass.RdataClass.IN,
 ) -> bytes:
     return wire(
-        qname_wire,
+        qname,
         u16(qtype),
         u16(qclass),
     )
 
 
-def rr_wire(
+def rr(
     owner: bytes,
     rrtype: SupportsInt,
     rrclass: SupportsInt,
@@ -113,7 +113,7 @@ def rr_wire(
     rdata: bytes = b"",
 ) -> bytes:
     return wire(
-        question_wire(
+        question(
             owner, dns.rdatatype.RdataType(rrtype), dns.rdataclass.RdataClass(rrclass)
         ),
         u32(ttl),
@@ -122,9 +122,9 @@ def rr_wire(
     )
 
 
-def oversized_name_wire() -> bytes:
+def oversized_name() -> bytes:
     labels = [bytes([15]) + b"A" * 15 for _ in range(15)]
-    labels.append(bytes([14]) + b"A" * 14 + root_wire())
+    labels.append(bytes([14]) + b"A" * 14 + root())
     return wire(*labels)
 
 
@@ -133,8 +133,8 @@ def soa_rr(
     expire: int,
     minimum: int,
 ) -> bytes:
-    return rr_wire(
-        root_wire(),
+    return rr(
+        root(),
         dns.rdatatype.RdataType.SOA,
         dns.rdataclass.RdataClass.IN,
         ttl=1,
@@ -156,7 +156,7 @@ def nsec3_rr(
     *,
     owner: bytes,
 ) -> bytes:
-    return rr_wire(
+    return rr(
         owner,
         dns.rdatatype.RdataType.NSEC3,
         dns.rdataclass.RdataClass.IN,
@@ -186,8 +186,8 @@ def key_rdata(
 
 
 def key_rr(*, rdclass: dns.rdataclass.RdataClass) -> bytes:
-    return rr_wire(
-        root_wire(),
+    return rr(
+        root(),
         dns.rdatatype.RdataType.KEY,
         rdclass,
         ttl=1,
@@ -201,8 +201,8 @@ def key_rr(*, rdclass: dns.rdataclass.RdataClass) -> bytes:
 
 
 def malformed_rrsig_rr() -> bytes:
-    return rr_wire(
-        root_wire(),
+    return rr(
+        root(),
         dns.rdatatype.RdataType.RRSIG,
         dns.rdataclass.RdataClass.IN,
         ttl=1,
@@ -224,7 +224,7 @@ def malformed_rrsig_rr() -> bytes:
 
 def tsig_rr(
     *,
-    owner: bytes = root_wire(),
+    owner: bytes = root(),
     rdclass: dns.rdataclass.RdataClass = dns.rdataclass.RdataClass.ANY,
     algorithm: dns.name.Name = dns.name.root,
     time_signed: int = 0x010203040506,
@@ -234,7 +234,7 @@ def tsig_rr(
     error: int = 0,
     other: bytes = b"",
 ) -> bytes:
-    return rr_wire(
+    return rr(
         owner,
         dns.rdatatype.RdataType.TSIG,
         rdclass,
@@ -254,7 +254,7 @@ def tsig_rr(
 
 
 def opt_rr(*, owner: bytes) -> bytes:
-    return rr_wire(
+    return rr(
         owner,
         dns.rdatatype.RdataType.OPT,
         dns.rdataclass.RdataClass.IN,
@@ -275,8 +275,8 @@ def a_rdata(ipv4_bytes: bytes = b"\x00\x00\x00\x00") -> bytes:
     ).to_wire()
 
 
-def a_rr(owner: bytes = root_wire()) -> bytes:
-    return rr_wire(
+def a_rr(owner: bytes = root()) -> bytes:
+    return rr(
         owner,
         dns.rdatatype.RdataType.A,
         dns.rdataclass.RdataClass.IN,
@@ -298,19 +298,19 @@ def query_raw_tcp(host: str, port: int, packet_wire: bytes) -> dns.message.Messa
     [
         pytest.param(
             wire(
-                dns_header(qdcount=1),
-                question_wire(oversized_name_wire()),
+                header(qdcount=1),
+                question(oversized_name()),
             ),
             formerr_response_header(),
             id="nametoolong",
         ),
         pytest.param(
             wire(
-                dns_header(qdcount=2),
-                question_wire(name_wire("AAAAAAAAAAAAAA."), dns.rdatatype.RdataType.A),
+                header(qdcount=2),
+                question(name("AAAAAAAAAAAAAA."), dns.rdatatype.RdataType.A),
                 # Two names concatenated in the QNAME field
-                question_wire(
-                    wire(name_wire("AAAAAAAAAAAAAA."), name_wire("AAAAAAAAAAAAAB.")),
+                question(
+                    wire(name("AAAAAAAAAAAAAA."), name("AAAAAAAAAAAAAB.")),
                     dns.rdatatype.RdataType.A,
                 ),
             ),
@@ -319,40 +319,40 @@ def query_raw_tcp(host: str, port: int, packet_wire: bytes) -> dns.message.Messa
         ),
         pytest.param(
             wire(
-                dns_header(qdcount=2),
-                question_wire(name_wire("AAAAAAAAAAAAAA."), dns.rdatatype.RdataType.A),
-                question_wire(name_wire("AAAAAAAAAAAAAA."), dns.rdatatype.RdataType.NS),
+                header(qdcount=2),
+                question(name("AAAAAAAAAAAAAA."), dns.rdatatype.RdataType.A),
+                question(name("AAAAAAAAAAAAAA."), dns.rdatatype.RdataType.NS),
             ),
             formerr_response_header(),
             id="twoquestiontypes",
         ),
         pytest.param(
             wire(
-                dns_header(qdcount=2),
-                question_wire(name_wire("AAAAAAAAAAAAAA."), dns.rdatatype.RdataType.A),
-                question_wire(name_wire("AAAAAAAAAAAAAA."), dns.rdatatype.RdataType.A),
+                header(qdcount=2),
+                question(name("AAAAAAAAAAAAAA."), dns.rdatatype.RdataType.A),
+                question(name("AAAAAAAAAAAAAA."), dns.rdatatype.RdataType.A),
             ),
             formerr_response_header(),
             id="dupquestion",
         ),
         pytest.param(
             wire(
-                dns_header(qdcount=1, ancount=2),
-                question_wire(root_wire(), dns.rdatatype.RdataType.SOA),
+                header(qdcount=1, ancount=2),
+                question(root(), dns.rdatatype.RdataType.SOA),
                 soa_rr(expire=4, minimum=5),
                 soa_rr(expire=4, minimum=6),
             ),
             wire(
                 formerr_response_header(qdcount=1),
-                question_wire(root_wire(), dns.rdatatype.RdataType.SOA),
+                question(root(), dns.rdatatype.RdataType.SOA),
             ),
             id="dupans",
         ),
         pytest.param(
             wire(
-                dns_header(ancount=1),
-                rr_wire(
-                    root_wire(),
+                header(ancount=1),
+                rr(
+                    root(),
                     dns.rdatatype.RdataType.MAILB,
                     dns.rdataclass.RdataClass.IN,
                     ttl=1,
@@ -362,7 +362,7 @@ def query_raw_tcp(host: str, port: int, packet_wire: bytes) -> dns.message.Messa
             id="qtypeasanswer",
         ),
         pytest.param(
-            dns_header(),
+            header(),
             # This would be NOERROR if it included a COOKIE option,
             # but is a FORMERR without one.
             formerr_response_header(),
@@ -370,33 +370,33 @@ def query_raw_tcp(host: str, port: int, packet_wire: bytes) -> dns.message.Messa
         ),
         pytest.param(
             wire(
-                dns_header(message_id=8, qdcount=1, nscount=1),
-                question_wire(root_wire(), dns.rdatatype.RdataType.A),
+                header(message_id=8, qdcount=1, nscount=1),
+                question(root(), dns.rdatatype.RdataType.A),
                 # Bad NSEC3 owner: X. is not in the base32hex alphabet.
-                nsec3_rr(owner=name_wire("X.")),
+                nsec3_rr(owner=name("X.")),
             ),
             wire(
                 formerr_response_header(
                     message_id=8, rcode=dns.rcode.SERVFAIL, qdcount=1
                 ),
-                question_wire(root_wire(), dns.rdatatype.RdataType.A),
+                question(root(), dns.rdatatype.RdataType.A),
             ),
             id="badnsec3owner",
         ),
         pytest.param(
             wire(
-                dns_header(message_id=9, arcount=1),
+                header(message_id=9, arcount=1),
                 # Truncated A record (no ttl, length or data)
-                question_wire(root_wire(), dns.rdatatype.RdataType.A),
+                question(root(), dns.rdatatype.RdataType.A),
             ),
             formerr_response_header(message_id=9),
             id="shortrecord",
         ),
         pytest.param(
             wire(
-                dns_header(qdcount=1),
+                header(qdcount=1),
                 # Truncated question (no class)
-                root_wire(),
+                root(),
                 u16(dns.rdatatype.RdataType.A),
             ),
             formerr_response_header(),
@@ -404,14 +404,14 @@ def query_raw_tcp(host: str, port: int, packet_wire: bytes) -> dns.message.Messa
         ),
         pytest.param(
             wire(
-                dns_header(qdcount=2),
-                question_wire(
-                    root_wire(),
+                header(qdcount=2),
+                question(
+                    root(),
                     dns.rdatatype.RdataType.A,
                     dns.rdataclass.RdataClass.IN,
                 ),
-                question_wire(
-                    root_wire(),
+                question(
+                    root(),
                     dns.rdatatype.RdataType.A,
                     dns.rdataclass.RdataClass(2),
                 ),
@@ -421,18 +421,18 @@ def query_raw_tcp(host: str, port: int, packet_wire: bytes) -> dns.message.Messa
         ),
         pytest.param(
             wire(
-                dns_header(arcount=1),
-                a_rr(owner=oversized_name_wire()),
+                header(arcount=1),
+                a_rr(owner=oversized_name()),
             ),
             formerr_response_header(),
             id="badrecordname",
         ),
         pytest.param(
             wire(
-                dns_header(arcount=2),
+                header(arcount=2),
                 a_rr(),
-                rr_wire(
-                    root_wire(),
+                rr(
+                    root(),
                     dns.rdatatype.RdataType(65280),
                     dns.rdataclass.RdataClass(256),
                     ttl=33554433,
@@ -444,28 +444,28 @@ def query_raw_tcp(host: str, port: int, packet_wire: bytes) -> dns.message.Messa
         ),
         pytest.param(
             wire(
-                dns_header(qdcount=1, arcount=1),
-                question_wire(root_wire(), dns.rdatatype.RdataType.A),
+                header(qdcount=1, arcount=1),
+                question(root(), dns.rdatatype.RdataType.A),
                 key_rr(rdclass=dns.rdataclass.RdataClass(2)),
             ),
             wire(
                 formerr_response_header(qdcount=1),
-                question_wire(root_wire(), dns.rdatatype.RdataType.A),
+                question(root(), dns.rdatatype.RdataType.A),
             ),
             id="keyclass",
         ),
         pytest.param(
             wire(
-                dns_header(arcount=1),
+                header(arcount=1),
                 # OPT owner should be root
-                opt_rr(owner=name_wire("A.")),
+                opt_rr(owner=name("A.")),
             ),
             formerr_response_header(),
             id="optwrongname",
         ),
         pytest.param(
             wire(
-                dns_header(arcount=1),
+                header(arcount=1),
                 malformed_rrsig_rr(),
             ),
             formerr_response_header(),
@@ -473,9 +473,9 @@ def query_raw_tcp(host: str, port: int, packet_wire: bytes) -> dns.message.Messa
         ),
         pytest.param(
             wire(
-                dns_header(opcode=dns.opcode.UPDATE, nscount=1),
-                rr_wire(
-                    root_wire(),
+                header(opcode=dns.opcode.UPDATE, nscount=1),
+                rr(
+                    root(),
                     dns.rdatatype.RdataType.A,
                     dns.rdataclass.RdataClass.ANY,
                     ttl=0,
@@ -488,7 +488,7 @@ def query_raw_tcp(host: str, port: int, packet_wire: bytes) -> dns.message.Messa
         ),
         pytest.param(
             wire(
-                dns_header(arcount=1),
+                header(arcount=1),
                 # Class should be ANY not IN
                 tsig_rr(rdclass=dns.rdataclass.RdataClass.IN),
             ),
@@ -497,7 +497,7 @@ def query_raw_tcp(host: str, port: int, packet_wire: bytes) -> dns.message.Messa
         ),
         pytest.param(
             wire(
-                dns_header(arcount=2),
+                header(arcount=2),
                 tsig_rr(),
                 # TSIG should be the last record
                 a_rr(),