Fixed the review comments about the tests (mostly lots of missing tests)

Also fixed a few bugs (uncaught exceptions)


git-svn-id: svn://bind10.isc.org/svn/bind10/experiments/python-binding@2264 e5f2f494-b856-4b98-b285-d166d9295462

src/lib/dns/python/message_python.cc

@@ -1364,8 +1364,13 @@ Message_setRcode(s_Message* self, PyObject* args) {
     if (!PyArg_ParseTuple(args, "O!", &rcode_type, &rcode)) {
         return NULL;
     }
-    self->message->setRcode(*rcode->rcode);
-    Py_RETURN_NONE;
+    try {
+        self->message->setRcode(*rcode->rcode);
+        Py_RETURN_NONE;
+    } catch (InvalidMessageOperation imo) {
+        PyErr_SetString(po_InvalidMessageOperation, imo.what());
+        return NULL;
+    }
 }
 
 static PyObject*
@@ -1394,8 +1399,13 @@ Message_setOpcode(s_Message* self, PyObject* args) {
     if (!PyArg_ParseTuple(args, "O!", &opcode_type, &opcode)) {
         return NULL;
     }
-    self->message->setOpcode(*opcode->opcode);
-    Py_RETURN_NONE;
+    try {
+        self->message->setOpcode(*opcode->opcode);
+        Py_RETURN_NONE;
+    } catch (InvalidMessageOperation imo) {
+        PyErr_SetString(po_InvalidMessageOperation, imo.what());
+        return NULL;
+    }
 }
 
 static PyObject*
@@ -1487,14 +1497,18 @@ Message_addRRset(s_Message* self, PyObject* args) {
                                            &PyBool_Type, &sign)) {
         return NULL;
     }
-    
-    if (sign == Py_True) {
-        self->message->addRRset(*section->section, rrset->rrset, true);
-    } else {
-        self->message->addRRset(*section->section, rrset->rrset, false);
+
+    try {
+        if (sign == Py_True) {
+            self->message->addRRset(*section->section, rrset->rrset, true);
+        } else {
+            self->message->addRRset(*section->section, rrset->rrset, false);
+        }
+        Py_RETURN_NONE;
+    } catch (InvalidMessageOperation imo) {
+        PyErr_SetString(po_InvalidMessageOperation, imo.what());
+        return NULL;
     }
-    
-    Py_RETURN_NONE;
 }
 
 static PyObject*

src/lib/dns/python/tests/libdns_python_test.in

@@ -1,21 +0,0 @@
-#! /bin/sh
-
-PYTHON_EXEC=${PYTHON_EXEC:-@PYTHON@}
-export PYTHON_EXEC
-
-CONFIG_PATH=@abs_top_srcdir@/src/lib/dns/python/tests
-
-PYTHONPATH=@abs_top_srcdir@/src/lib/python:@abs_top_srcdir@/src/lib/dns/python/.libs
-export PYTHONPATH
-
-TESTDATA_PATH=@abs_top_srcdir@/src/lib/dns/tests/testdata
-export TESTDATA_PATH
-
-cd ${BIND10_PATH}
-${PYTHON_EXEC} -O ${CONFIG_PATH}/rrtype_python_test.py $*
-
-${PYTHON_EXEC} -O ${CONFIG_PATH}/rrset_python_test.py $*
-
-${PYTHON_EXEC} -O ${CONFIG_PATH}/question_python_test.py $*
-
-${PYTHON_EXEC} -O ${CONFIG_PATH}/message_python_test.py $*

src/lib/dns/python/tests/message_python_test.py

@@ -1,4 +1,4 @@
-# Copyright (C) 2009  Internet Systems Consortium.
+# Copyright (C) 2010  Internet Systems Consortium.
 #
 # Permission to use, copy, modify, and distribute this software for any
 # purpose with or without fee is hereby granted, provided that the above
@@ -14,7 +14,7 @@
 # WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 
 #
-# Tests for the rrtype part of the libdns_python module
+# Tests for the message part of the libdns_python module
 #
 
 import unittest
@@ -59,7 +59,7 @@ class OpcodeTest(unittest.TestCase):
 
     def test_to_text(self):
         self.assertEqual("QUERY", Opcode.QUERY().to_text())
-        self.assertEqual("QUERY", Opcode.QUERY().__str__())
+        self.assertEqual("QUERY", str(Opcode.QUERY()))
         self.assertEqual("IQUERY", Opcode.IQUERY().to_text())
         self.assertEqual("STATUS", Opcode.STATUS().to_text())
         self.assertEqual("RESERVED3", Opcode.RESERVED3().to_text())
@@ -81,24 +81,29 @@ class OpcodeTest(unittest.TestCase):
         o2 = Opcode.NOTIFY()
         o3 = Opcode.NOTIFY()
         self.assertTrue(o2 == o3)
+        self.assertFalse(o2 != o3)
         self.assertTrue(o1 != o2)
         self.assertFalse(o1 == 1)
         self.assertFalse(o1 == o2)
         # can't use assertRaises here...
         try:
             o1 < o2
+            self.fail("operation that should have raised an error unexpectedly succeeded")
         except Exception as err:
             self.assertEqual(TypeError, type(err))
         try:
             o1 <= o2
+            self.fail("operation that should have raised an error unexpectedly succeeded")
         except Exception as err:
             self.assertEqual(TypeError, type(err))
         try:
             o1 > o2
+            self.fail("operation that should have raised an error unexpectedly succeeded")
         except Exception as err:
             self.assertEqual(TypeError, type(err))
         try:
             o1 >= o2
+            self.fail("operation that should have raised an error unexpectedly succeeded")
         except Exception as err:
             self.assertEqual(TypeError, type(err))
 
@@ -106,6 +111,14 @@ class RcodeTest(unittest.TestCase):
     def test_init(self):
         self.assertRaises(TypeError, Rcode, "wrong")
         self.assertRaises(OverflowError, Rcode, 65536)
+        self.assertEqual(Rcode(0).get_code(), 0)
+    
+        self.assertEqual(0, Rcode(0).get_code())
+        self.assertEqual(0xfff, Rcode(0xfff).get_code()) # possible max code
+    
+        # should fail on attempt of construction with an out of range code
+        self.assertRaises(OverflowError, Rcode, 0x1000)
+        self.assertRaises(OverflowError, Rcode, 0xffff)
 
     def test_get_code(self):
         self.assertEqual(0, Rcode.NOERROR().get_code())
@@ -124,6 +137,7 @@ class RcodeTest(unittest.TestCase):
         self.assertEqual(13, Rcode.RESERVED13().get_code())
         self.assertEqual(14, Rcode.RESERVED14().get_code())
         self.assertEqual(15, Rcode.RESERVED15().get_code())
+        self.assertEqual(16, Rcode.BADVERS().get_code())
 
     def test_to_text(self):
         self.assertEqual("NOERROR", Rcode(0).to_text())
@@ -143,7 +157,11 @@ class RcodeTest(unittest.TestCase):
         self.assertEqual("RESERVED13", Rcode(13).to_text())
         self.assertEqual("RESERVED14", Rcode(14).to_text())
         self.assertEqual("RESERVED15", Rcode(15).to_text())
+        self.assertEqual("BADVERS", Rcode(16).to_text())
         
+        self.assertEqual("17", Rcode(Rcode.BADVERS().get_code() + 1).to_text())
+        self.assertEqual("4095", Rcode(0xfff).to_text())
+
     def test_richcmp(self):
         r1 = Rcode.NOERROR()
         r2 = Rcode.FORMERR()
@@ -155,18 +173,22 @@ class RcodeTest(unittest.TestCase):
         # can't use assertRaises here...
         try:
             r1 < r2
+            self.fail("operation that should have raised an error unexpectedly succeeded")
         except Exception as err:
             self.assertEqual(TypeError, type(err))
         try:
             r1 <= r2
+            self.fail("operation that should have raised an error unexpectedly succeeded")
         except Exception as err:
             self.assertEqual(TypeError, type(err))
         try:
             r1 > r2
+            self.fail("operation that should have raised an error unexpectedly succeeded")
         except Exception as err:
             self.assertEqual(TypeError, type(err))
         try:
             r1 >= r2
+            self.fail("operation that should have raised an error unexpectedly succeeded")
         except Exception as err:
             self.assertEqual(TypeError, type(err))
 
@@ -192,22 +214,79 @@ class SectionTest(unittest.TestCase):
         # can't use assertRaises here...
         try:
             s1 < s2
+            self.fail("operation that should have raised an error unexpectedly succeeded")
         except Exception as err:
             self.assertEqual(TypeError, type(err))
         try:
             s1 <= s2
+            self.fail("operation that should have raised an error unexpectedly succeeded")
         except Exception as err:
             self.assertEqual(TypeError, type(err))
         try:
             s1 > s2
+            self.fail("operation that should have raised an error unexpectedly succeeded")
         except Exception as err:
             self.assertEqual(TypeError, type(err))
         try:
             s1 >= s2
+            self.fail("operation that should have raised an error unexpectedly succeeded")
         except Exception as err:
             self.assertEqual(TypeError, type(err))
         
 
+# helper functions for tests taken from c++ unittests
+if "TESTDATA_PATH" in os.environ:
+    testdata_path = os.environ["TESTDATA_PATH"]
+else:
+    testdata_path = "../tests/testdata"
+
+def read_wire_data(filename):
+    data = bytes()
+    file = open(testdata_path + os.sep + filename, "r")
+    for line in file:
+        line = line.strip()
+        if line == "" or line.startswith("#"):
+            pass
+        else:
+            cur_data = bytes.fromhex(line)
+            data += cur_data
+
+    return data
+
+def factoryFromFile(message, file):
+    data = read_wire_data(file)
+    message.from_wire(data)
+    pass
+
+# we don't have direct comparison for rrsets right now (should we?
+# should go in the cpp version first then), so also no direct list
+# comparison. Created a helper function
+def compare_rrset_list(list1, list2):
+    if len(list1) != len(list2):
+        return False
+    for i in range(0, len(list1)):
+        if str(list1[i]) != str(list2[i]):
+            return False
+    return True
+
+# a complete message taken from cpp tests, for testing towire and totext
+def create_message():
+    message_render = Message(Message.RENDER)
+    message_render.set_qid(0x1035)
+    message_render.set_opcode(Opcode.QUERY())
+    message_render.set_rcode(Rcode.NOERROR())
+    message_render.set_header_flag(MessageFlag.QR())
+    message_render.set_header_flag(MessageFlag.RD())
+    message_render.set_header_flag(MessageFlag.AA())
+    message_render.add_question(Question(Name("test.example.com"), RRClass("IN"), RRType("A")))
+    rrset = RRset(Name("test.example.com"), RRClass("IN"),
+                                        RRType("A"), RRTTL(3600))
+    rrset.add_rdata(Rdata(RRType("A"), RRClass("IN"), "192.0.2.1"))
+    rrset.add_rdata(Rdata(RRType("A"), RRClass("IN"), "192.0.2.2"))
+    message_render.add_rrset(Section.ANSWER(), rrset)
+    return message_render
+
+
 class MessageTest(unittest.TestCase):
 
     def setUp(self):
@@ -222,7 +301,7 @@ class MessageTest(unittest.TestCase):
         self.assertRaises(TypeError, self.p.get_header_flag, "wrong")
         self.assertFalse(self.p.get_header_flag(MessageFlag.AA()))
 
-    def test_set_header_flag(self):
+    def test_set_clear_header_flag(self):
         self.assertRaises(TypeError, self.r.set_header_flag, "wrong")
         self.assertRaises(TypeError, self.r.clear_header_flag, "wrong")
 
@@ -246,31 +325,93 @@ class MessageTest(unittest.TestCase):
         self.r.set_dnssec_supported(False)
         self.assertFalse(self.r.is_dnssec_supported())
 
+        self.assertRaises(InvalidMessageOperation,
+                          self.p.set_dnssec_supported, True)
+        self.assertRaises(InvalidMessageOperation,
+                          self.p.set_dnssec_supported, False)
+
     def test_set_udp_size(self):
         self.assertRaises(TypeError, self.r.set_udp_size, "wrong")
+        self.assertRaises(InvalidMessageUDPSize, self.r.set_udp_size, 0)
+        self.assertRaises(InvalidMessageUDPSize, self.r.set_udp_size, 65536)
+        self.assertRaises(InvalidMessageOperation, self.p.set_udp_size, 1024)
+        self.r.set_udp_size(2048)
+        self.assertEqual(2048, self.r.get_udp_size())
 
     def test_set_qid(self):
         self.assertRaises(TypeError, self.r.set_qid, "wrong")
         self.assertRaises(InvalidMessageOperation,
                           self.p.set_qid, 123)
+        self.r.set_qid(1234)
+        self.assertEqual(1234, self.r.get_qid())
 
     def test_set_rcode(self):
         self.assertRaises(TypeError, self.r.set_rcode, "wrong")
 
+        rcode = Rcode.BADVERS()
+        self.r.set_rcode(rcode)
+        self.assertEqual(rcode, self.r.get_rcode())
+
+        self.assertRaises(InvalidMessageOperation,
+                          self.p.set_rcode, rcode)
+        
+
     def test_set_opcode(self):
         self.assertRaises(TypeError, self.r.set_opcode, "wrong")
 
+        opcode = Opcode.IQUERY()
+        self.r.set_opcode(opcode)
+        self.assertEqual(opcode, self.r.get_opcode())
+
+        self.assertRaises(InvalidMessageOperation,
+                          self.p.set_opcode, opcode)
+
     def test_get_section(self):
         self.assertRaises(TypeError, self.r.get_section, "wrong")
 
+        rrset = RRset(Name("example.com"), RRClass("IN"), RRType("A"), RRTTL(3600))
+        rrset.add_rdata(Rdata(RRType("A"), RRClass("IN"), "192.0.2.1"))
+        rrset.add_rdata(Rdata(RRType("A"), RRClass("IN"), "192.0.2.2"))
+        section_rrset = [rrset]
+
+        self.assertRaises(InvalidMessageOperation, self.p.add_rrset,
+                          Section.ANSWER(), rrset)
+        
+        self.assertFalse(compare_rrset_list(section_rrset, self.r.get_section(Section.ANSWER())))
+        self.assertEqual(0, self.r.get_rr_count(Section.ANSWER()))
+        self.r.add_rrset(Section.ANSWER(), rrset)
+        self.assertTrue(compare_rrset_list(section_rrset, self.r.get_section(Section.ANSWER())))
+        self.assertEqual(2, self.r.get_rr_count(Section.ANSWER()))
+
+        self.assertFalse(compare_rrset_list(section_rrset, self.r.get_section(Section.AUTHORITY())))
+        self.assertEqual(0, self.r.get_rr_count(Section.AUTHORITY()))
+        self.r.add_rrset(Section.AUTHORITY(), rrset)
+        self.assertTrue(compare_rrset_list(section_rrset, self.r.get_section(Section.AUTHORITY())))
+        self.assertEqual(2, self.r.get_rr_count(Section.AUTHORITY()))
+
+        self.assertFalse(compare_rrset_list(section_rrset, self.r.get_section(Section.ADDITIONAL())))
+        self.assertEqual(0, self.r.get_rr_count(Section.ADDITIONAL()))
+        self.r.add_rrset(Section.ADDITIONAL(), rrset)
+        self.assertTrue(compare_rrset_list(section_rrset, self.r.get_section(Section.ADDITIONAL())))
+        self.assertEqual(2, self.r.get_rr_count(Section.ADDITIONAL()))
+
     def test_get_rr_count(self):
         self.assertRaises(TypeError, self.r.get_rr_count, "wrong")
+        # counts also tested in add_section
 
     def test_add_question(self):
         self.assertRaises(TypeError, self.r.add_question, "wrong", "wrong")
+        q = Question(Name("example.com"), RRClass("IN"), RRType("A"))
+        qs = [q]
+        self.assertFalse(compare_rrset_list(qs, self.r.get_question()))
+        self.assertEqual(0, self.r.get_rr_count(Section.QUESTION()))
+        self.r.add_question(q)
+        self.assertTrue(compare_rrset_list(qs, self.r.get_question()))
+        self.assertEqual(1, self.r.get_rr_count(Section.QUESTION()))
 
     def test_add_rrset(self):
         self.assertRaises(TypeError, self.r.add_rrset, "wrong")
+        # actual addition already tested in get_section
 
     def test_clear(self):
         self.assertEqual(None, self.r.clear(Message.PARSE))
@@ -283,6 +424,29 @@ class MessageTest(unittest.TestCase):
         self.assertRaises(InvalidMessageOperation,
                           self.p.to_wire, MessageRenderer())
 
+        message_render = create_message()
+        renderer = MessageRenderer()
+        message_render.to_wire(renderer)
+        self.assertEqual(b'\x105\x85\x00\x00\x01\x00\x02\x00\x00\x00\x00\x04test\x07example\x03com\x00\x00\x01\x00\x01\xc0\x0c\x00\x01\x00\x01\x00\x00\x0e\x10\x00\x04\xc0\x00\x02\x01\xc0\x0c\x00\x01\x00\x01\x00\x00\x0e\x10\x00\x04\xc0\x00\x02\x02',
+                         renderer.get_data())
+
+    def test_to_text(self):
+        message_render = create_message()
+        
+        msg_str =\
+""";; ->>HEADER<<- opcode: QUERY, status: NOERROR, id: 4149
+;; flags: qr aa rd ; QUESTION: 1, ANSWER: 2, AUTHORITY: 0, ADDITIONAL: 0
+
+;; QUESTION SECTION:
+;test.example.com. IN A
+
+;; ANSWER SECTION:
+test.example.com. 3600 IN A 192.0.2.1
+test.example.com. 3600 IN A 192.0.2.2
+"""
+        self.assertEqual(msg_str, message_render.to_text())
+        self.assertEqual(msg_str, str(message_render))
+
     def test_from_wire(self):
         self.assertRaises(TypeError, self.r.from_wire, 1)
         self.assertRaises(InvalidMessageOperation,
@@ -290,50 +454,6 @@ class MessageTest(unittest.TestCase):
         self.assertRaises(MessageTooShort,
                           Message.from_wire, self.p, bytes())
 
-# helper functions for tests taken from c++ unittests
-if "TESTDATA_PATH" in os.environ:
-    testdata_path = os.environ["TESTDATA_PATH"]
-else:
-    testdata_path = "../tests/testdata"
-
-def read_wire_data(filename):
-    data = bytes()
-    file = open(testdata_path + os.sep + filename, "r")
-    for line in file:
-        line = line.strip()
-        if line == "" or line.startswith("#"):
-            pass
-        else:
-            cur_data = bytes.fromhex(line)
-            data += cur_data
-
-    return data
-
-def factoryFromFile(message, file):
-    data = read_wire_data(file)
-    message.from_wire(data)
-    pass
-
-class ConvertedUnittests(unittest.TestCase):
-    
-    # tests below based on c++ unit tests
-    def test_RcodeConstruct(self):
-        # normal cases
-        self.assertEqual(0, Rcode(0).get_code())
-        self.assertEqual(0xfff, Rcode(0xfff).get_code()) # possible max code
-    
-        # should fail on attempt of construction with an out of range code
-        self.assertRaises(OverflowError, Rcode, 0x1000)
-        self.assertRaises(OverflowError, Rcode, 0xffff)
-    
-    def test_RcodeToText(self):
-        self.assertEqual("NOERROR", Rcode.NOERROR().to_text())
-        self.assertEqual("BADVERS", Rcode.BADVERS().to_text())
-        self.assertEqual("17", Rcode(Rcode.BADVERS().get_code() + 1).to_text())
-        self.assertEqual("4095", Rcode(0xfff).to_text())
-    
-    
-    def test_fromWire(self):
         test_name = Name("test.example.com");
         
         message_parse = Message(0)
@@ -366,7 +486,7 @@ class ConvertedUnittests(unittest.TestCase):
         self.assertEqual("192.0.2.1", rdata[0].to_text())
         self.assertEqual("192.0.2.2", rdata[1].to_text())
         self.assertEqual(2, len(rdata))
-    
+
     def test_GetEDNS0DOBit(self):
         message_parse = Message(Message.PARSE)
         ## Without EDNS0, DNSSEC is considered to be unsupported.
@@ -491,43 +611,6 @@ class ConvertedUnittests(unittest.TestCase):
                           message_parse,
                           "message_fromWire9")
     
-    def test_to_text_and_wire(self):
-        message_render = Message(Message.RENDER)
-        message_render.set_qid(0x1035)
-        message_render.set_opcode(Opcode.QUERY())
-        message_render.set_rcode(Rcode.NOERROR())
-        message_render.set_header_flag(MessageFlag.QR())
-        message_render.set_header_flag(MessageFlag.RD())
-        message_render.set_header_flag(MessageFlag.AA())
-        message_render.add_question(Question(Name("test.example.com"), RRClass("IN"), RRType("A")))
-        rrset = RRset(Name("test.example.com"), RRClass("IN"),
-                                            RRType("A"), RRTTL(3600))
-        rrset.add_rdata(Rdata(RRType("A"), RRClass("IN"), "192.0.2.1"))
-        rrset.add_rdata(Rdata(RRType("A"), RRClass("IN"), "192.0.2.2"))
-        message_render.add_rrset(Section.ANSWER(), rrset)
-    
-        self.assertEqual(1, message_render.get_rr_count(Section.QUESTION()))
-        self.assertEqual(2, message_render.get_rr_count(Section.ANSWER()))
-        self.assertEqual(0, message_render.get_rr_count(Section.AUTHORITY()))
-        self.assertEqual(0, message_render.get_rr_count(Section.ADDITIONAL()))
-
-        renderer = MessageRenderer()
-        message_render.to_wire(renderer)
-        self.assertEqual(b'\x105\x85\x00\x00\x01\x00\x02\x00\x00\x00\x00\x04test\x07example\x03com\x00\x00\x01\x00\x01\xc0\x0c\x00\x01\x00\x01\x00\x00\x0e\x10\x00\x04\xc0\x00\x02\x01\xc0\x0c\x00\x01\x00\x01\x00\x00\x0e\x10\x00\x04\xc0\x00\x02\x02',
-                         renderer.get_data())
-        msg_str =\
-""";; ->>HEADER<<- opcode: QUERY, status: NOERROR, id: 4149
-;; flags: qr aa rd ; QUESTION: 1, ANSWER: 2, AUTHORITY: 0, ADDITIONAL: 0
-
-;; QUESTION SECTION:
-;test.example.com. IN A
-
-;; ANSWER SECTION:
-test.example.com. 3600 IN A 192.0.2.1
-test.example.com. 3600 IN A 192.0.2.2
-"""
-        self.assertEqual(msg_str, message_render.to_text())
-        self.assertEqual(msg_str, message_render.__str__())
 
 if __name__ == '__main__':
     unittest.main()

src/lib/dns/python/tests/messagerenderer_python_test.py

@@ -48,19 +48,6 @@ class MessageRendererTest(unittest.TestCase):
         message.add_rrset(Section.AUTHORITY(), rrset)
         self.message2 = message
 
-        #message = Message(Message.RENDER)
-        #message.set_qid(123)
-        #message.set_header_flag(MessageFlag.AA())
-        #message.set_header_flag(MessageFlag.QR())
-        #message.set_opcode(Opcode.QUERY())
-        #message.set_rcode(Rcode.NOERROR())
-        #message.add_question(Question(name, c, t))
-        #rrset = RRset(name, c, t, ttl)
-        #for i in range(1, 99):
-        #    rrset.add_rdata(Rdata(t, c, "192.0.2." + str(i)))
-        #message.add_rrset(Section.AUTHORITY(), rrset)
-        #self.message3 = message
-
         self.renderer1 = MessageRenderer()
         self.renderer2 = MessageRenderer()
         self.renderer3 = MessageRenderer()

src/lib/dns/python/tests/name_python_test.py

@@ -58,6 +58,18 @@ class NameComparisonTest(unittest.TestCase):
         self.assertEqual("COMMONANCESTOR", NameComparisonResult.NameRelation[self.ncr12.get_relation()])
         self.assertEqual("COMMONANCESTOR", NameComparisonResult.NameRelation[self.ncr15.get_relation()])
 
+        superdomain = Name("com")
+        relation = superdomain.compare(self.name1)
+        self.assertEqual("SUPERDOMAIN", NameComparisonResult.NameRelation[relation.get_relation()])
+
+        subdomain = Name("sub.aaaa.example.com")
+        relation = subdomain.compare(self.name1)
+        self.assertEqual("SUBDOMAIN", NameComparisonResult.NameRelation[relation.get_relation()])
+
+        same = Name("aaaa.example.com")
+        relation = same.compare(self.name1)
+        self.assertEqual("EQUAL", NameComparisonResult.NameRelation[relation.get_relation()])
+
 class NameTest(unittest.TestCase):
     def setUp(self):
         self.name1 = Name("example.com")
@@ -82,7 +94,6 @@ class NameTest(unittest.TestCase):
         self.assertRaises(InvalidBufferPosition, Name, b, 100)
         b = bytearray()
         b += b'\x07example'*32 + b'\x03com\x00'
-        # no TooLong for from wire?
         self.assertRaises(DNSMessageFORMERR, Name, b, 0)
 
     def test_at(self):
@@ -104,6 +115,7 @@ class NameTest(unittest.TestCase):
     def test_to_text(self):
         self.assertEqual("example.com.", self.name1.to_text())
         self.assertEqual(".", self.name2.to_text())
+        self.assertEqual(".", str(self.name2))
         self.assertEqual("something.completely.different.", self.name3.to_text())
 
     def test_to_wire(self):
@@ -129,8 +141,6 @@ class NameTest(unittest.TestCase):
         self.assertFalse(self.name1.equals(self.name2))
         self.assertFalse(self.name1.equals(self.name3))
         self.assertTrue(self.name1.equals(self.name4))
-        #TODO: == not yet defined
-        #self.assertEqual(self.name1, self.name2)
 
     def test_split(self):
         s = self.name1.split(1,1)
@@ -173,10 +183,18 @@ class NameTest(unittest.TestCase):
     def test_richcmp(self):
         self.assertTrue(self.name1 > self.name2)
         self.assertFalse(self.name1 < self.name2)
+        self.assertFalse(self.name2 > self.name1)
+        self.assertTrue(self.name2 < self.name1)
         self.assertTrue(self.name1 == self.name4)
+        self.assertFalse(self.name1 != self.name4)
+        self.assertTrue(self.name1 != self.name2)
+        self.assertFalse(self.name1 == self.name2)
         self.assertTrue(self.name1 <= self.name4)
         self.assertTrue(self.name1 >= self.name4)
         self.assertFalse(self.name1 <= self.name2)
+        self.assertTrue(self.name4 >= self.name1)
+        self.assertTrue(self.name4 <= self.name1)
+        self.assertFalse(self.name2 >= self.name1)
 
 if __name__ == '__main__':
     unittest.main()

src/lib/dns/python/tests/question_python_test.py

@@ -1,4 +1,4 @@
-# Copyright (C) 2009  Internet Systems Consortium.
+# Copyright (C) 2010  Internet Systems Consortium.
 #
 # Permission to use, copy, modify, and distribute this software for any
 # purpose with or without fee is hereby granted, provided that the above
@@ -55,7 +55,8 @@ class QuestionTest(unittest.TestCase):
         self.assertRaises(TypeError, Question, "wrong")
 
     # tests below based on cpp unit tests
-    def test_QuestionTest_fromWire(self):
+    # also tests get_name, get_class and get_type
+    def test_from_wire(self):
         
         q = question_from_wire("question_fromWire")
 
@@ -79,15 +80,14 @@ class QuestionTest(unittest.TestCase):
                           question_from_wire,
                           "question_fromWire", 36)
     
-    
-    def test_QuestionTest_to_text(self):
+    def test_to_text(self):
     
         self.assertEqual("foo.example.com. IN NS\n", self.test_question1.to_text())
-        self.assertEqual("foo.example.com. IN NS\n", self.test_question1.__str__())
+        self.assertEqual("foo.example.com. IN NS\n", str(self.test_question1))
         self.assertEqual("bar.example.com. CH A\n", self.test_question2.to_text())
     
     
-    def test_QuestionTest_to_wireBuffer(self):
+    def test_to_wire_buffer(self):
         obuffer = bytes()
         obuffer = self.test_question1.to_wire(obuffer)
         obuffer = self.test_question2.to_wire(obuffer)
@@ -95,7 +95,7 @@ class QuestionTest(unittest.TestCase):
         self.assertEqual(obuffer, wiredata)
     
     
-    def test_QuestionTest_to_wireRenderer(self):
+    def test_to_wire_renderer(self):
         renderer = MessageRenderer()
         self.test_question1.to_wire(renderer)
         self.test_question2.to_wire(renderer)

src/lib/dns/python/tests/rdata_python_test.py

@@ -51,11 +51,20 @@ class RdataTest(unittest.TestCase):
         self.assertEqual(b'\x03foo', b)
         self.assertRaises(TypeError, self.rdata1.to_wire, 1)
 
+        renderer = MessageRenderer()
+        self.rdata1.to_wire(renderer)
+        self.assertEqual(b'\xc0\x00\x02b', renderer.get_data())
+
+        renderer = MessageRenderer()
+        self.rdata3.to_wire(renderer)
+        self.assertEqual(b'\x0casdfasdfasdf', renderer.get_data())
+
     def test_rdata_to_text(self):
         self.assertEqual("192.0.2.98", self.rdata1.to_text())
         self.assertEqual("192.0.2.99", self.rdata2.to_text())
         self.assertEqual("\"asdfasdfasdf\"", self.rdata3.to_text())
         self.assertEqual("\"foo\"", self.rdata4.to_text())
+        self.assertEqual("\"foo\"", str(self.rdata4))
 
     def test_richcmp(self):
         self.assertTrue(self.rdata1 < self.rdata2);
@@ -66,5 +75,13 @@ class RdataTest(unittest.TestCase):
         other_rdata = Rdata(RRType("TXT"), RRClass("IN"), "foo")
         self.assertTrue(self.rdata4 == other_rdata)
 
+        self.assertFalse(self.rdata1 > self.rdata2);
+        self.assertFalse(self.rdata1 >= self.rdata2);
+        self.assertTrue(self.rdata1 < self.rdata2);
+        self.assertTrue(self.rdata1 <= self.rdata2);
+        self.assertFalse(self.rdata3 == self.rdata4)
+        self.assertFalse(self.rdata4 != other_rdata)
+        
+
 if __name__ == '__main__':
     unittest.main()

src/lib/dns/python/tests/rrclass_python_test.py

@@ -40,7 +40,7 @@ class RRClassTest(unittest.TestCase):
         
     def test_rrclass_to_text(self):
         self.assertEqual("IN", self.c1.to_text())
-        self.assertEqual("IN", self.c1.__str__())
+        self.assertEqual("IN", str(self.c1))
         self.assertEqual("CH", self.c2.to_text())
 
     def test_rrclass_to_wire(self):
@@ -63,6 +63,15 @@ class RRClassTest(unittest.TestCase):
         self.assertTrue(self.c1 <= self.c2)
         self.assertFalse(self.c1 > self.c2)
         self.assertFalse(self.c1 >= self.c2)
+        other_rrclass = RRClass("IN")
+        self.assertTrue(self.c1 == other_rrclass)
+
+        self.assertFalse(self.c1 == self.c2)
+        self.assertFalse(self.c1 > self.c2)
+        self.assertFalse(self.c1 >= self.c2)
+        self.assertTrue(self.c1 < self.c2)
+        self.assertTrue(self.c1 <= self.c2)
+        self.assertFalse(self.c1 != other_rrclass)
 
     def test_statics(self):
         self.assertEqual(RRClass.IN(), RRClass("IN"))

src/lib/dns/python/tests/rrset_python_test.py

@@ -1,4 +1,4 @@
-# Copyright (C) 2009  Internet Systems Consortium.
+# Copyright (C) 2010  Internet Systems Consortium.
 #
 # Permission to use, copy, modify, and distribute this software for any
 # purpose with or without fee is hereby granted, provided that the above
@@ -85,9 +85,8 @@ class TestModuleSpec(unittest.TestCase):
                          self.rrset_a.to_text());
         self.assertEqual("test.example.com. 3600 IN A 192.0.2.1\n"
                          "test.example.com. 3600 IN A 192.0.2.2\n",
-                         self.rrset_a.__str__());
+                         str(self.rrset_a));
 
-        #rrset_empty = RRset(self.test_name, RRClass("IN"), RRType("A"), RRTTL(3600))
         self.assertRaises(EmptyRRset, self.rrset_a_empty.to_text)
 
     def test_to_wire_buffer(self):
@@ -104,6 +103,13 @@ class TestModuleSpec(unittest.TestCase):
         mr = MessageRenderer()
         self.rrset_a.to_wire(mr)
         self.assertEqual(exp_buffer, mr.get_data())
+
+    def test_get_rdata(self):
+        rdata = [ Rdata(RRType("A"), RRClass("IN"), "192.0.2.1"),
+                  Rdata(RRType("A"), RRClass("IN"), "192.0.2.2")
+                ]
+        self.assertEqual(rdata, self.rrset_a.get_rdata())
+        self.assertEqual([], self.rrset_a_empty.get_rdata())
         
 if __name__ == '__main__':
     unittest.main()

src/lib/dns/python/tests/rrttl_python_test.py

@@ -21,7 +21,7 @@ import unittest
 import os
 from libdns_python import *
 
-class RdataTest(unittest.TestCase):
+class RRTTLTest(unittest.TestCase):
     def setUp(self):
         self.t1 = RRTTL(1)
         self.t2 = RRTTL(3600)
@@ -40,12 +40,12 @@ class RdataTest(unittest.TestCase):
         b[3] = 15
         self.assertEqual(15, RRTTL(b).get_value())
         
-    def test_rdata_to_text(self):
+    def test_rrttl_to_text(self):
         self.assertEqual("1", self.t1.to_text())
-        self.assertEqual("1", self.t1.__str__())
+        self.assertEqual("1", str(self.t1))
         self.assertEqual("3600", self.t2.to_text())
 
-    def test_rdata_to_wire(self):
+    def test_rrttl_to_wire(self):
         b = bytearray()
         self.t1.to_wire(b)
         self.assertEqual(b'\x00\x00\x00\x01', b)
@@ -57,7 +57,7 @@ class RdataTest(unittest.TestCase):
         self.assertEqual(b'\x00\x00\x0e\x10', mr.get_data())
         self.assertRaises(TypeError, self.t1.to_wire, 1)
 
-    def test_rdata_richcmp(self):
+    def test_rrttl_richcmp(self):
         self.assertTrue(self.t1 == RRTTL(1))
         self.assertFalse(self.t1 != RRTTL(1))
         self.assertFalse(self.t1 == 1)
@@ -66,5 +66,12 @@ class RdataTest(unittest.TestCase):
         self.assertFalse(self.t1 > self.t2)
         self.assertFalse(self.t1 >= self.t2)
 
+        self.assertFalse(self.t1 != RRTTL(1))
+        self.assertTrue(self.t1 == RRTTL(1))
+        self.assertFalse(self.t1 > self.t2)
+        self.assertFalse(self.t1 >= self.t2)
+        self.assertTrue(self.t1 < self.t2)
+        self.assertTrue(self.t1 <= self.t2)
+
 if __name__ == '__main__':
     unittest.main()

src/lib/dns/python/tests/rrtype_python_test.py

@@ -1,4 +1,4 @@
-# Copyright (C) 2009  Internet Systems Consortium.
+# Copyright (C) 2010  Internet Systems Consortium.
 #
 # Permission to use, copy, modify, and distribute this software for any
 # purpose with or without fee is hereby granted, provided that the above
@@ -39,9 +39,10 @@ class TestModuleSpec(unittest.TestCase):
         self.assertRaises(IncompleteRRType, RRType, b)
         self.assertRaises(TypeError, RRType, Exception)
     
-    def test_from_text(self):
+    def test_init_from_text(self):
         self.assertEqual("A", RRType("A").to_text())
         self.assertEqual("NS", RRType("NS").to_text());
+        self.assertEqual("NS", str(RRType("NS")));
     
         self.assertEqual("TYPE65535", RRType("TYPE65535").to_text());
     
@@ -101,6 +102,14 @@ class TestModuleSpec(unittest.TestCase):
         self.assertFalse(RRType(100) > RRType(65535));
         self.assertFalse(RRType(100) >= RRType(65535));
 
+        self.assertFalse(RRType(1) != RRType("A"));
+        self.assertFalse(RRType(0) == RRType("A"));
+        self.assertFalse(RRType("A") > RRType("NS"));
+        self.assertFalse(RRType("A") >= RRType("NS"));
+        self.assertFalse(RRType(100) > RRType(65535));
+        self.assertTrue(RRType(100) < RRType(65535));
+        self.assertTrue(RRType(100) <= RRType(65535));
+
         self.assertFalse(self.rrtype_1 == 1)
 
     def test_statics(self):