[1457] Address (most) review comments

replaced rrsets_as_rrs() by a much simpler generator
style fixes such as private methods
added additional tests

src/lib/python/isc/ddns/libddns_messages.mes

@@ -109,8 +109,7 @@ A FORMERR response is sent back to the client.
 % LIBDDNS_UPDATE_DATASRC_ERROR error in datasource during DDNS update: %1
 An error occured while committing the DDNS update changes to the
 datasource. The specific error is printed. A SERVFAIL response is sent
-back to the client. In theory, if the datasource is implemented
-correctly, no changes should have been made to the zone contents.
+back to the client.
 
 % LIBDDNS_UPDATE_DELETE_BAD_TYPE update client %1 for zone %2: update deletion RR bad type: %3
 The Update section of a DDNS update message contains a statement
@@ -126,7 +125,7 @@ A FORMERR response is sent back to the client.
 
 % LIBDDNS_UPDATE_DELETE_RRSET_NOT_EMPTY update client %1 for zone %2: update deletion RR contains data %3
 The Update section of a DDNS update message contains a 'delete rrset'
-statement with a non-empty Rrset. This is not allowed by the protocol.
+statement with a non-empty RRset. This is not allowed by the protocol.
 A FORMERR response is sent back to the client.
 
 % LIBDDNS_UPDATE_DELETE_RR_BAD_TYPE update client %1 for zone %2: update deletion RR bad type: %3

src/lib/python/isc/ddns/session.py

@@ -59,40 +59,23 @@ class UpdateError(Exception):
         self.rcode = rcode
         self.nolog = nolog
 
-def foreach_rr_in_rrset(rrset, method, *kwargs):
-    '''Helper function. For DDNS, in a number of cases, we need to
-       treat the various RRs in a single RRset separately.
-       Our libdns++ has no concept of RRs, so in that case,
-       what we do is create a temporary 1-RR RRset for each Rdata
-       in the RRset object.
-       This method then calls the given method with the given args
-       for each of the temporary rrsets (the rrset in *wargs is
-       replaced by the temporary one)
-       Note: if this method is useful in more places, we may want
-       to move it out of ddns.
-       Example:
-       Say you have a method that prints a prexif string and an
-       rrset, def my_print(prefix, rrset)
-       Given an rrset my_rrset, you'd print the entire rrset
-       with my_print("foo", rrset)
-       And with this helper function, to print each rr invidually,
-       you'd call
-       foreach_rr_in_rrsetet(rrset, my_print, "foo", rrset)
-       Note the rrset is needed twice, the first to identify it,
-       the second as the 'real' argument to my_print (which is replaced
-       by this function.
+def foreach_rr(rrset):
+    '''
+    Generator that creates a new RRset with one RR from
+    the given RRset upon each iteration, usable in calls that
+    need to loop over an RRset and perform an action with each
+    of the individual RRs in it.
+    Example:
+    for rr in foreach_rr(rrset):
+        print(str(rr))
     '''
-    result = None
     for rdata in rrset.get_rdata():
-        tmp_rrset = isc.dns.RRset(rrset.get_name(),
-                                  rrset.get_class(),
-                                  rrset.get_type(),
-                                  rrset.get_ttl())
-        tmp_rrset.add_rdata(rdata)
-        # Replace the rrset in the original arguments by our rrset
-        args = [arg if arg != rrset else tmp_rrset for arg in kwargs]
-        result = method(*args)
-    return result
+        rr = isc.dns.RRset(rrset.get_name(),
+                           rrset.get_class(),
+                           rrset.get_type(),
+                           rrset.get_ttl())
+        rr.add_rdata(rdata)
+        yield rr
 
 def convert_rrset_class(rrset, rrclass):
     '''Returns a (new) rrset with the data from the given rrset,
@@ -228,10 +211,10 @@ class UpdateSession:
         zclass = zrecord.get_class()
         zone_type, datasrc_client = self.__zone_config.find_zone(zname, zclass)
         if zone_type == isc.ddns.zone_config.ZONE_PRIMARY:
+            _, self.__finder = datasrc_client.find_zone(zname)
             self.__zname = zname
             self.__zclass = zclass
             self.__datasrc_client = datasrc_client
-            _, self.__finder = datasrc_client.find_zone(zname)
             return
         elif zone_type == isc.ddns.zone_config.ZONE_SECONDARY:
             # We are a secondary server; since we don't yet support update
@@ -468,7 +451,8 @@ class UpdateSession:
                 if rrset.get_type() == RRType.SOA():
                     # In case there's multiple soa records in the update
                     # somehow, just take the last
-                    foreach_rr_in_rrset(rrset, self.__set_soa_rrset, rrset)
+                    for rr in foreach_rr(rrset):
+                        self.__set_soa_rrset(rr)
             elif rrset.get_class() == RRClass.ANY():
                 if rrset.get_ttl().get_value() != 0:
                     logger.info(LIBDDNS_UPDATE_DELETE_NONZERO_TTL,
@@ -538,7 +522,7 @@ class UpdateSession:
         '''
         # For a number of cases, we may need to remove data in the zone
         # (note; SOA is handled separately by __do_update, so that one
-        # is not explicitely ignored here)
+        # is explicitely ignored here)
         if rrset.get_type() == RRType.SOA():
             return
         result, orig_rrset, _ = self.__finder.find(rrset.get_name(),
@@ -565,7 +549,8 @@ class UpdateSession:
             # If this type is CNAME, ignore the update
             if rrset.get_type() == RRType.CNAME():
                 return
-        foreach_rr_in_rrset(rrset, self.__do_update_add_single_rr, diff, rrset, orig_rrset)
+        for rr in foreach_rr(rrset):
+            self.__do_update_add_single_rr(diff, rr, orig_rrset)
 
     def __do_update_delete_rrset(self, diff, rrset):
         '''Deletes the rrset with the name and type of the given
@@ -578,12 +563,14 @@ class UpdateSession:
                                                   rrset.get_type(),
                                                   ZoneFinder.NO_WILDCARD |
                                                   ZoneFinder.FIND_GLUE_OK)
-        if to_delete.get_name() == self.__zname and\
-           (to_delete.get_type() == RRType.SOA() or\
-            to_delete.get_type() == RRType.NS()):
-            # ignore
-            return
-        foreach_rr_in_rrset(to_delete, diff.delete_data, to_delete)
+        if result == ZoneFinder.SUCCESS:
+            if to_delete.get_name() == self.__zname and\
+               (to_delete.get_type() == RRType.SOA() or\
+                to_delete.get_type() == RRType.NS()):
+                # ignore
+                return
+            for rr in foreach_rr(to_delete):
+                diff.delete_data(rr)
 
     def __ns_deleter_helper(self, diff, rrset):
         '''Special case helper for deleting NS resource records
@@ -636,7 +623,8 @@ class UpdateSession:
                     to_delete.get_type() == RRType.NS()):
                     continue
                 else:
-                    foreach_rr_in_rrset(to_delete, diff.delete_data, to_delete)
+                    for rr in foreach_rr(to_delete):
+                        diff.delete_data(rr)
 
     def __do_update_delete_rrs_from_rrset(self, diff, rrset):
         '''Deletes all resource records in the given rrset from the
@@ -661,7 +649,8 @@ class UpdateSession:
                 # delegate to helper method
                 self.__ns_deleter_helper(diff, to_delete)
                 return
-        foreach_rr_in_rrset(to_delete, diff.delete_data, to_delete)
+        for rr in foreach_rr(to_delete):
+            diff.delete_data(rr)
 
     def __update_soa(self, diff):
         '''Checks the member value __added_soa, and depending on
@@ -716,7 +705,7 @@ class UpdateSession:
             # of the Diff class, this is not the case, and therefore it
             # is easier to work with full rrsets for the most parts
             # (less lookups needed; conversion to individual rrs is
-            # the same offort whether it is done here or in the several
+            # the same effort whether it is done here or in the several
             # do_update statements)
             for rrset in self.__message.get_section(SECTION_UPDATE):
                 if rrset.get_class() == self.__zclass:

src/lib/python/isc/ddns/tests/session_tests.py

@@ -58,6 +58,16 @@ def create_update_msg(zones=[TEST_ZONE_RECORD], prerequisites=[],
 
     return renderer.get_data(), msg
 
+def add_rdata(rrset, rdata):
+    '''
+    Helper function for easily adding Rdata fields to RRsets.
+    This function assumes the given rdata is of type string or bytes,
+    and corresponds to the given rrset
+    '''
+    rrset.add_rdata(isc.dns.Rdata(rrset.get_type(),
+                                  rrset.get_class(),
+                                  rdata))
+
 def create_rrset(name, rrclass, rrtype, ttl, rdatas = []):
     '''
     Helper method to easily create RRsets, auto-converts
@@ -79,16 +89,6 @@ def create_rrset(name, rrclass, rrtype, ttl, rdatas = []):
         add_rdata(rrset, rdata)
     return rrset
 
-def add_rdata(rrset, rdata):
-    '''
-    Helper function for easily adding Rdata fields to RRsets.
-    This function assumes the given rdata is of type string or bytes,
-    and corresponds to the given rrset
-    '''
-    rrset.add_rdata(isc.dns.Rdata(rrset.get_type(),
-                                  rrset.get_class(),
-                                  rdata))
-
 class SessionTest(unittest.TestCase):
     '''Session tests'''
     def setUp(self):
@@ -185,33 +185,22 @@ class SessionTest(unittest.TestCase):
         # zone class doesn't match
         self.check_notauth(Name('example.org'), RRClass.CH())
 
-    def foreach_rr_in_rrset_helper(self, rr, l):
-        l.append(rr.to_text())
-
     def test_foreach_rr_in_rrset(self):
         rrset = create_rrset("www.example.org", TEST_RRCLASS,
                              RRType.A(), 3600, [ "192.0.2.1" ])
 
         l = []
-        foreach_rr_in_rrset(rrset, self.foreach_rr_in_rrset_helper, rrset, l)
+        for rr in foreach_rr(rrset):
+            l.append(str(rr))
         self.assertEqual(["www.example.org. 3600 IN A 192.0.2.1\n"], l)
 
         add_rdata(rrset, "192.0.2.2")
         add_rdata(rrset, "192.0.2.3")
 
-        # if the helper is called directly, the list should have
-        # one entry, with a multiline string
-        # but through the helper, there should be several 1-line entries
-        l = []
-        self.foreach_rr_in_rrset_helper(rrset, l)
-        self.assertEqual(["www.example.org. 3600 IN A 192.0.2.1\n" +
-                          "www.example.org. 3600 IN A 192.0.2.2\n" +
-                          "www.example.org. 3600 IN A 192.0.2.3\n"
-                         ], l)
-
-        # but through the helper, there should be several 1-line entries
+        # but through the generator, there should be several 1-line entries
         l = []
-        foreach_rr_in_rrset(rrset, self.foreach_rr_in_rrset_helper, rrset, l)
+        for rr in foreach_rr(rrset):
+            l.append(str(rr))
         self.assertEqual(["www.example.org. 3600 IN A 192.0.2.1\n",
                           "www.example.org. 3600 IN A 192.0.2.2\n",
                           "www.example.org. 3600 IN A 192.0.2.3\n",
@@ -609,7 +598,7 @@ class SessionTest(unittest.TestCase):
            Function does not do much but makes the code look nicer'''
         self.assertEqual(expected, method(rrset))
 
-    def initialize_update_rrsets(self):
+    def __initialize_update_rrsets(self):
         '''Prepare a number of RRsets to be used in several update tests
            The rrsets are stored in self'''
         orig_a_rrset = create_rrset("www.example.org", TEST_RRCLASS,
@@ -690,7 +679,7 @@ class SessionTest(unittest.TestCase):
         '''Test whether the prescan succeeds on data that is ok, and whether
            if notices the SOA if present'''
         # prepare a set of correct update statements
-        self.initialize_update_rrsets()
+        self.__initialize_update_rrsets()
 
         self.check_prescan_result(Rcode.NOERROR(), [ self.rrset_update_a ])
 
@@ -785,8 +774,8 @@ class SessionTest(unittest.TestCase):
                              [ b'\x00' ])
         self.check_prescan_result(Rcode.FORMERR(), [ rrset ])
 
-    def check_inzone_data(self, expected_result, name, rrtype,
-                          expected_rrset = None):
+    def __check_inzone_data(self, expected_result, name, rrtype,
+                            expected_rrset = None):
         '''Does a find on TEST_ZONE for the given rrset's name and type,
            then checks if the result matches the expected result.
            If so, and if expected_rrset is given, they are compared as
@@ -817,7 +806,7 @@ class SessionTest(unittest.TestCase):
         Tests a sequence of related add and delete updates. Some other
         cases are tested by later tests.
         '''
-        self.initialize_update_rrsets()
+        self.__initialize_update_rrsets()
 
         # initially, the www should only contain one rr
         # (set to self.orig_a_rrset)
@@ -830,115 +819,191 @@ class SessionTest(unittest.TestCase):
                                           "192.0.2.3" ])
 
         # Sanity check, make sure original data is really there before updates
-        self.check_inzone_data(isc.datasrc.ZoneFinder.SUCCESS,
-                               isc.dns.Name("www.example.org"),
-                               RRType.A(),
-                               self.orig_a_rrset)
+        self.__check_inzone_data(isc.datasrc.ZoneFinder.SUCCESS,
+                                 isc.dns.Name("www.example.org"),
+                                 RRType.A(),
+                                 self.orig_a_rrset)
 
         # Add two rrs
         self.check_full_handle_result(Rcode.NOERROR(), [ self.rrset_update_a ])
 
-        self.check_inzone_data(isc.datasrc.ZoneFinder.SUCCESS,
-                               isc.dns.Name("www.example.org"),
-                               RRType.A(),
-                               extended_a_rrset)
+        self.__check_inzone_data(isc.datasrc.ZoneFinder.SUCCESS,
+                                 isc.dns.Name("www.example.org"),
+                                 RRType.A(),
+                                 extended_a_rrset)
 
         # Adding the same RRsets should not make a difference.
         self.check_full_handle_result(Rcode.NOERROR(), [ self.rrset_update_a ])
 
-        self.check_inzone_data(isc.datasrc.ZoneFinder.SUCCESS,
-                               isc.dns.Name("www.example.org"),
-                               RRType.A(),
-                               extended_a_rrset)
+        self.__check_inzone_data(isc.datasrc.ZoneFinder.SUCCESS,
+                                 isc.dns.Name("www.example.org"),
+                                 RRType.A(),
+                                 extended_a_rrset)
 
         # Now delete those two, and we should end up with the original RRset
         self.check_full_handle_result(Rcode.NOERROR(),
                                       [ self.rrset_update_del_rrset_part ])
-        self.check_inzone_data(isc.datasrc.ZoneFinder.SUCCESS,
-                               isc.dns.Name("www.example.org"),
-                               RRType.A(),
-                               self.orig_a_rrset)
+        self.__check_inzone_data(isc.datasrc.ZoneFinder.SUCCESS,
+                                 isc.dns.Name("www.example.org"),
+                                 RRType.A(),
+                                 self.orig_a_rrset)
 
         # 'Deleting' them again should make no difference
         self.check_full_handle_result(Rcode.NOERROR(),
                                       [ self.rrset_update_del_rrset_part ])
-        self.check_inzone_data(isc.datasrc.ZoneFinder.SUCCESS,
-                               isc.dns.Name("www.example.org"),
-                               RRType.A(),
-                               self.orig_a_rrset)
+        self.__check_inzone_data(isc.datasrc.ZoneFinder.SUCCESS,
+                                 isc.dns.Name("www.example.org"),
+                                 RRType.A(),
+                                 self.orig_a_rrset)
 
         # But deleting the entire rrset, independent of its contents, should
         # work
         self.check_full_handle_result(Rcode.NOERROR(),
                                       [ self.rrset_update_del_rrset ])
-        self.check_inzone_data(isc.datasrc.ZoneFinder.NXDOMAIN,
-                               isc.dns.Name("www.example.org"),
-                               RRType.A())
+        self.__check_inzone_data(isc.datasrc.ZoneFinder.NXDOMAIN,
+                                 isc.dns.Name("www.example.org"),
+                                 RRType.A())
 
         # Check that if we update the SOA, it is updated to our value
         self.check_full_handle_result(Rcode.NOERROR(),
                                       [ self.rrset_update_soa2 ])
-        self.check_inzone_data(isc.datasrc.ZoneFinder.SUCCESS,
-                               isc.dns.Name("example.org"),
-                               RRType.SOA(),
-                               self.rrset_update_soa2)
+        self.__check_inzone_data(isc.datasrc.ZoneFinder.SUCCESS,
+                                 isc.dns.Name("example.org"),
+                                 RRType.SOA(),
+                                 self.rrset_update_soa2)
+
+    def test_glue_deletions(self):
+        self.__check_inzone_data(isc.datasrc.ZoneFinder.SUCCESS,
+                                 isc.dns.Name("sub.example.org."),
+                                 RRType.NS())
+        self.__check_inzone_data(isc.datasrc.ZoneFinder.SUCCESS,
+                                 isc.dns.Name("ns.sub.example.org."),
+                                 RRType.A())
+
+        # See that we can delete glue
+        rrset_delete_glue = create_rrset("ns.sub.example.org.",
+                                         RRClass.ANY(),
+                                         RRType.A(),
+                                         0)
+        self.check_full_handle_result(Rcode.NOERROR(),
+                                      [ rrset_delete_glue ])
+        self.__check_inzone_data(isc.datasrc.ZoneFinder.SUCCESS,
+                                 isc.dns.Name("sub.example.org."),
+                                 RRType.NS())
+        self.__check_inzone_data(isc.datasrc.ZoneFinder.NXDOMAIN,
+                                 isc.dns.Name("ns.sub.example.org."),
+                                 RRType.A())
+
+        # Check that we don't accidentally delete a delegation if we
+        # try to delete non-existent glue
+        rrset_delete_nonexistent_glue = create_rrset("foo.sub.example.org.",
+                                                     RRClass.ANY(),
+                                                     RRType.A(),
+                                                     0)
+        self.check_full_handle_result(Rcode.NOERROR(),
+                                      [ rrset_delete_nonexistent_glue ])
+        self.__check_inzone_data(isc.datasrc.ZoneFinder.SUCCESS,
+                                 isc.dns.Name("sub.example.org."),
+                                 RRType.NS())
 
     def test_update_add_new_data(self):
         '''
         This tests adds data where none is present
         '''
         # Add data at a completely new name
-        self.check_inzone_data(isc.datasrc.ZoneFinder.NXDOMAIN,
-                               isc.dns.Name("new.example.org"),
-                               RRType.A())
+        self.__check_inzone_data(isc.datasrc.ZoneFinder.NXDOMAIN,
+                                 isc.dns.Name("new.example.org"),
+                                 RRType.A())
         rrset = create_rrset("new.example.org", TEST_RRCLASS, RRType.A(),
                              3600, [ "192.0.2.1", "192.0.2.2" ])
         self.check_full_handle_result(Rcode.NOERROR(), [ rrset ])
-        self.check_inzone_data(isc.datasrc.ZoneFinder.SUCCESS,
-                               isc.dns.Name("new.example.org"),
-                               RRType.A(),
-                               rrset)
+        self.__check_inzone_data(isc.datasrc.ZoneFinder.SUCCESS,
+                                 isc.dns.Name("new.example.org"),
+                                 RRType.A(),
+                                 rrset)
 
         # Also try a name where data is present, but none of this
         # specific type
-        self.check_inzone_data(isc.datasrc.ZoneFinder.NXRRSET,
-                               isc.dns.Name("new.example.org"),
-                               RRType.TXT())
+        self.__check_inzone_data(isc.datasrc.ZoneFinder.NXRRSET,
+                                 isc.dns.Name("new.example.org"),
+                                 RRType.TXT())
         rrset = create_rrset("new.example.org", TEST_RRCLASS, RRType.TXT(),
                              3600, [ "foo" ])
         self.check_full_handle_result(Rcode.NOERROR(), [ rrset ])
-        self.check_inzone_data(isc.datasrc.ZoneFinder.SUCCESS,
-                               isc.dns.Name("new.example.org"),
-                               RRType.TXT(),
-                               rrset)
+        self.__check_inzone_data(isc.datasrc.ZoneFinder.SUCCESS,
+                                 isc.dns.Name("new.example.org"),
+                                 RRType.TXT(),
+                                 rrset)
+
+    def test_update_add_new_data_interspersed(self):
+        '''
+        This tests adds data where none is present, similar to
+        test_update_add_new_data, but this time the second RRset
+        is put into the record between the two RRs of the first
+        RRset.
+        '''
+        # Add data at a completely new name
+        self.__check_inzone_data(isc.datasrc.ZoneFinder.NXDOMAIN,
+                                 isc.dns.Name("new_a.example.org"),
+                                 RRType.A())
+        self.__check_inzone_data(isc.datasrc.ZoneFinder.NXDOMAIN,
+                                 isc.dns.Name("new_txt.example.org"),
+                                 RRType.TXT())
+
+        rrset1 = create_rrset("new_a.example.org", TEST_RRCLASS, RRType.A(),
+                              3600, [ "192.0.2.1" ])
+
+        rrset2 = create_rrset("new_txt.example.org", TEST_RRCLASS, RRType.TXT(),
+                              3600, [ "foo" ])
+
+        rrset3 = create_rrset("new_a.example.org", TEST_RRCLASS, RRType.A(),
+                              3600, [ "192.0.2.2" ])
+
+        self.check_full_handle_result(Rcode.NOERROR(),
+                                      [ rrset1, rrset2, rrset3 ])
+
+        # The update should have merged rrset1 and rrset3
+        rrset_merged = create_rrset("new_a.example.org", TEST_RRCLASS,
+                                    RRType.A(), 3600,
+                                    [ "192.0.2.1", "192.0.2.2" ])
+
+        self.__check_inzone_data(isc.datasrc.ZoneFinder.SUCCESS,
+                                 isc.dns.Name("new_a.example.org"),
+                                 RRType.A(),
+                                 rrset_merged)
+
+        self.__check_inzone_data(isc.datasrc.ZoneFinder.SUCCESS,
+                                 isc.dns.Name("new_txt.example.org"),
+                                 RRType.TXT(),
+                                 rrset2)
 
     def test_update_delete_name(self):
-        self.initialize_update_rrsets()
+        self.__initialize_update_rrsets()
 
         # First check it is there
-        self.check_inzone_data(isc.datasrc.ZoneFinder.SUCCESS,
-                               isc.dns.Name("www.example.org"),
-                               RRType.A())
+        self.__check_inzone_data(isc.datasrc.ZoneFinder.SUCCESS,
+                                 isc.dns.Name("www.example.org"),
+                                 RRType.A())
 
         # Delete the entire name
         self.check_full_handle_result(Rcode.NOERROR(),
                                       [ self.rrset_update_del_name ])
-        self.check_inzone_data(isc.datasrc.ZoneFinder.NXDOMAIN,
-                               isc.dns.Name("www.example.org"),
-                               RRType.A())
+        self.__check_inzone_data(isc.datasrc.ZoneFinder.NXDOMAIN,
+                                 isc.dns.Name("www.example.org"),
+                                 RRType.A())
 
         # Should still be gone after pointless second delete
         self.check_full_handle_result(Rcode.NOERROR(),
                                       [ self.rrset_update_del_name ])
-        self.check_inzone_data(isc.datasrc.ZoneFinder.NXDOMAIN,
-                               isc.dns.Name("www.example.org"),
-                               RRType.A())
+        self.__check_inzone_data(isc.datasrc.ZoneFinder.NXDOMAIN,
+                                 isc.dns.Name("www.example.org"),
+                                 RRType.A())
 
     def test_update_apex_special_cases(self):
         '''
         Tests a few special cases when deleting data from the apex
         '''
-        self.initialize_update_rrsets()
+        self.__initialize_update_rrsets()
 
         # the original SOA
         orig_soa_rrset = create_rrset("example.org", TEST_RRCLASS,
@@ -960,60 +1025,60 @@ class SessionTest(unittest.TestCase):
                                       [ "ns3.example.org." ])
 
         # Sanity check, make sure original data is really there before updates
-        self.check_inzone_data(isc.datasrc.ZoneFinder.SUCCESS,
-                               isc.dns.Name("example.org"),
-                               RRType.NS(),
-                               orig_ns_rrset)
+        self.__check_inzone_data(isc.datasrc.ZoneFinder.SUCCESS,
+                                 isc.dns.Name("example.org"),
+                                 RRType.NS(),
+                                 orig_ns_rrset)
         # We will delete the MX record later in this test, so let's make
         # sure that it exists (we do not care about its value)
-        self.check_inzone_data(isc.datasrc.ZoneFinder.SUCCESS,
-                               isc.dns.Name("example.org"),
-                               RRType.MX())
+        self.__check_inzone_data(isc.datasrc.ZoneFinder.SUCCESS,
+                                 isc.dns.Name("example.org"),
+                                 RRType.MX())
 
         # Check that we cannot delete the SOA record by direction deletion
         # both by name+type and by full rrset
         self.check_full_handle_result(Rcode.NOERROR(),
                                       [ self.rrset_update_del_soa_apex,
                                         self.rrset_update_soa_del ])
-        self.check_inzone_data(isc.datasrc.ZoneFinder.SUCCESS,
-                               isc.dns.Name("example.org"),
-                               RRType.SOA(),
-                               orig_soa_rrset)
+        self.__check_inzone_data(isc.datasrc.ZoneFinder.SUCCESS,
+                                 isc.dns.Name("example.org"),
+                                 RRType.SOA(),
+                                 orig_soa_rrset)
 
         # If we delete everything at the apex, the SOA and NS rrsets should be
         # untouched
         self.check_full_handle_result(Rcode.NOERROR(),
                                       [ self.rrset_update_del_name_apex ])
-        self.check_inzone_data(isc.datasrc.ZoneFinder.SUCCESS,
-                               isc.dns.Name("example.org"),
-                               RRType.SOA(),
-                               orig_soa_rrset)
-        self.check_inzone_data(isc.datasrc.ZoneFinder.SUCCESS,
-                               isc.dns.Name("example.org"),
-                               RRType.NS(),
-                               orig_ns_rrset)
+        self.__check_inzone_data(isc.datasrc.ZoneFinder.SUCCESS,
+                                 isc.dns.Name("example.org"),
+                                 RRType.SOA(),
+                                 orig_soa_rrset)
+        self.__check_inzone_data(isc.datasrc.ZoneFinder.SUCCESS,
+                                 isc.dns.Name("example.org"),
+                                 RRType.NS(),
+                                 orig_ns_rrset)
         # but the MX should be gone
-        self.check_inzone_data(isc.datasrc.ZoneFinder.NXRRSET,
-                               isc.dns.Name("example.org"),
-                               RRType.MX())
+        self.__check_inzone_data(isc.datasrc.ZoneFinder.NXRRSET,
+                                 isc.dns.Name("example.org"),
+                                 RRType.MX())
 
         # Deleting the NS rrset by name and type only, it should also be left
         # untouched
         self.check_full_handle_result(Rcode.NOERROR(),
                                       [ self.rrset_update_del_ns_apex ])
-        self.check_inzone_data(isc.datasrc.ZoneFinder.SUCCESS,
-                               isc.dns.Name("example.org"),
-                               RRType.NS(),
-                               orig_ns_rrset)
+        self.__check_inzone_data(isc.datasrc.ZoneFinder.SUCCESS,
+                                 isc.dns.Name("example.org"),
+                                 RRType.NS(),
+                                 orig_ns_rrset)
 
         # If we delete the NS at the apex specifically, it should still
         # keep one record
         self.check_full_handle_result(Rcode.NOERROR(),
                                       [ self.rrset_update_del_rrset_ns ])
-        self.check_inzone_data(isc.datasrc.ZoneFinder.SUCCESS,
-                               isc.dns.Name("example.org"),
-                               RRType.NS(),
-                               short_ns_rrset)
+        self.__check_inzone_data(isc.datasrc.ZoneFinder.SUCCESS,
+                                 isc.dns.Name("example.org"),
+                                 RRType.NS(),
+                                 short_ns_rrset)
 
     def test_update_delete_normal_rrset_at_apex(self):
         '''
@@ -1021,64 +1086,64 @@ class SessionTest(unittest.TestCase):
         '''
 
         # MX should simply be deleted
-        self.initialize_update_rrsets()
-        self.check_inzone_data(isc.datasrc.ZoneFinder.SUCCESS,
-                               isc.dns.Name("example.org"),
-                               RRType.MX())
+        self.__initialize_update_rrsets()
+        self.__check_inzone_data(isc.datasrc.ZoneFinder.SUCCESS,
+                                 isc.dns.Name("example.org"),
+                                 RRType.MX())
         self.check_full_handle_result(Rcode.NOERROR(),
                                       [ self.rrset_update_del_rrset_mx ])
-        self.check_inzone_data(isc.datasrc.ZoneFinder.NXRRSET,
-                               isc.dns.Name("example.org"),
-                               RRType.MX())
+        self.__check_inzone_data(isc.datasrc.ZoneFinder.NXRRSET,
+                                 isc.dns.Name("example.org"),
+                                 RRType.MX())
 
     def test_update_cname_special_cases(self):
-        self.initialize_update_rrsets()
+        self.__initialize_update_rrsets()
 
         # Sanity check
         orig_cname_rrset = create_rrset("cname.example.org", TEST_RRCLASS,
                                         RRType.CNAME(), 3600,
                                         [ "www.example.org." ])
-        self.check_inzone_data(isc.datasrc.ZoneFinder.CNAME,
-                               isc.dns.Name("cname.example.org"),
-                               RRType.A(),
-                               orig_cname_rrset)
+        self.__check_inzone_data(isc.datasrc.ZoneFinder.CNAME,
+                                 isc.dns.Name("cname.example.org"),
+                                 RRType.A(),
+                                 orig_cname_rrset)
 
         # If we try to add data where a cname is preset
         rrset = create_rrset("cname.example.org", TEST_RRCLASS, RRType.A(),
                              3600, [ "192.0.2.1" ])
 
         self.check_full_handle_result(Rcode.NOERROR(), [ rrset ])
-        self.check_inzone_data(isc.datasrc.ZoneFinder.CNAME,
-                               isc.dns.Name("cname.example.org"),
-                               RRType.A(),
-                               orig_cname_rrset)
+        self.__check_inzone_data(isc.datasrc.ZoneFinder.CNAME,
+                                 isc.dns.Name("cname.example.org"),
+                                 RRType.A(),
+                                 orig_cname_rrset)
 
         # But updating the cname itself should work
         new_cname_rrset = create_rrset("cname.example.org", TEST_RRCLASS,
                                        RRType.CNAME(), 3600,
                                        [ "mail.example.org." ])
         self.check_full_handle_result(Rcode.NOERROR(), [ new_cname_rrset ])
-        self.check_inzone_data(isc.datasrc.ZoneFinder.CNAME,
-                               isc.dns.Name("cname.example.org"),
-                               RRType.A(),
-                               new_cname_rrset)
+        self.__check_inzone_data(isc.datasrc.ZoneFinder.CNAME,
+                                 isc.dns.Name("cname.example.org"),
+                                 RRType.A(),
+                                 new_cname_rrset)
 
-        self.initialize_update_rrsets()
+        self.__initialize_update_rrsets()
 
         # Likewise, adding a cname where other data is
         # present should do nothing either
-        self.check_inzone_data(isc.datasrc.ZoneFinder.SUCCESS,
-                               isc.dns.Name("www.example.org"),
-                               RRType.A(),
-                               self.orig_a_rrset)
+        self.__check_inzone_data(isc.datasrc.ZoneFinder.SUCCESS,
+                                 isc.dns.Name("www.example.org"),
+                                 RRType.A(),
+                                 self.orig_a_rrset)
         new_cname_rrset = create_rrset("www.example.org", TEST_RRCLASS,
                                        RRType.CNAME(), 3600,
                                        [ "mail.example.org." ])
         self.check_full_handle_result(Rcode.NOERROR(), [ new_cname_rrset ])
-        self.check_inzone_data(isc.datasrc.ZoneFinder.SUCCESS,
-                               isc.dns.Name("www.example.org"),
-                               RRType.A(),
-                               self.orig_a_rrset)
+        self.__check_inzone_data(isc.datasrc.ZoneFinder.SUCCESS,
+                                 isc.dns.Name("www.example.org"),
+                                 RRType.A(),
+                                 self.orig_a_rrset)
 
     def test_update_bad_class(self):
         rrset = create_rrset("example.org.", RRClass.CH(), RRType.TXT(), 0,