fix rrset match signature problemsfull_match

3 files changed, 55 insertions, 27 deletions

diff --git a/dns/message.py b/dns/message.py
index ea71a45..9824e70 100644
--- a/dns/message.py
+++ b/dns/message.py
@@ -351,7 +351,8 @@ class Message:
                     return rrset
             else:
                 for rrset in section:
-                    if rrset.match(name, rdclass, rdtype, covers, deleting):
+                    if rrset.full_match(name, rdclass, rdtype, covers,
+                                        deleting):
                         return rrset
         if not create:
             raise KeyError
diff --git a/dns/rrset.py b/dns/rrset.py
index adfcad9..a71d457 100644
--- a/dns/rrset.py
+++ b/dns/rrset.py
@@ -76,22 +76,37 @@ class RRset(dns.rdataset.Rdataset):
             return False
         return super().__eq__(other)
 
-    # pylint: disable=arguments-differ
+    def match(self, *args, **kwargs):
+        """Does this rrset match the specified attributes?
+
+        Behaves as :py:func:`full_match()` if the first argument is a
+        ``dns.name.Name``, and as :py:func:`dns.rdataset.Rdataset.match()`
+        otherwise.
 
-    def match(self, name, rdclass, rdtype, covers,
-              deleting=None):
-        """Returns ``True`` if this rrset matches the specified class, type,
-        covers, and deletion state.
+        (This behavior fixes a design mistake where the signature of this
+        method became incompatible with that of its superclass.  The fix
+        makes RRsets matchable as Rdatasets while preserving backwards
+        compatibility.)
         """
+        if isinstance(args[0], dns.name.Name):
+            return self.full_match(*args, **kwargs)
+        else:
+            return super().match(*args, **kwargs)
 
+    def full_match(self, name, rdclass, rdtype, covers,
+                    deleting=None):
+        """Returns ``True`` if this rrset matches the specified name, class,
+        type, covers, and deletion state.
+        """
         if not super().match(rdclass, rdtype, covers):
             return False
         if self.name != name or self.deleting != deleting:
             return False
         return True
 
-    def to_text(self, origin=None, relativize=True,
-                **kw):
+    # pylint: disable=arguments-differ
+
+    def to_text(self, origin=None, relativize=True, **kw):
         """Convert the RRset into DNS zone file format.
 
         See ``dns.name.Name.choose_relativity`` for more information
diff --git a/tests/test_rrset.py b/tests/test_rrset.py
index 7835ba1..5c3f17d 100644
--- a/tests/test_rrset.py
+++ b/tests/test_rrset.py
@@ -79,42 +79,54 @@ class RRsetTestCase(unittest.TestCase):
         self.assertFalse(r1 is r2)
         self.assertTrue(r1 == r2)
 
-    def testMatch1(self):
+    def testFullMatch1(self):
         r1 = dns.rrset.from_text_list('foo', 30, 'in', 'a',
                                       ['10.0.0.1', '10.0.0.2'])
-        self.assertTrue(r1.match(r1.name, dns.rdataclass.IN,
-                                 dns.rdatatype.A, dns.rdatatype.NONE))
+        self.assertTrue(r1.full_match(r1.name, dns.rdataclass.IN,
+                                      dns.rdatatype.A, dns.rdatatype.NONE))
 
-    def testMatch2(self):
+    def testFullMatch2(self):
         r1 = dns.rrset.from_text_list('foo', 30, 'in', 'a',
                                       ['10.0.0.1', '10.0.0.2'])
         r1.deleting = dns.rdataclass.NONE
-        self.assertTrue(r1.match(r1.name, dns.rdataclass.IN,
-                                 dns.rdatatype.A, dns.rdatatype.NONE,
-                                 dns.rdataclass.NONE))
+        self.assertTrue(r1.full_match(r1.name, dns.rdataclass.IN,
+                                      dns.rdatatype.A, dns.rdatatype.NONE,
+                                      dns.rdataclass.NONE))
 
-    def testNoMatch1(self):
+    def testNoFullMatch1(self):
         n = dns.name.from_text('bar', None)
         r1 = dns.rrset.from_text_list('foo', 30, 'in', 'a',
                                       ['10.0.0.1', '10.0.0.2'])
-        self.assertFalse(r1.match(n, dns.rdataclass.IN,
-                                  dns.rdatatype.A, dns.rdatatype.NONE,
-                                  dns.rdataclass.ANY))
+        self.assertFalse(r1.full_match(n, dns.rdataclass.IN,
+                                       dns.rdatatype.A, dns.rdatatype.NONE,
+                                       dns.rdataclass.ANY))
 
-    def testNoMatch2(self):
+    def testNoFullMatch2(self):
         r1 = dns.rrset.from_text_list('foo', 30, 'in', 'a',
                                       ['10.0.0.1', '10.0.0.2'])
         r1.deleting = dns.rdataclass.NONE
-        self.assertFalse(r1.match(r1.name, dns.rdataclass.IN,
-                                  dns.rdatatype.A, dns.rdatatype.NONE,
-                                  dns.rdataclass.ANY))
+        self.assertFalse(r1.full_match(r1.name, dns.rdataclass.IN,
+                                       dns.rdatatype.A, dns.rdatatype.NONE,
+                                       dns.rdataclass.ANY))
+
+    def testNoFullMatch3(self):
+        r1 = dns.rrset.from_text_list('foo', 30, 'in', 'a',
+                                      ['10.0.0.1', '10.0.0.2'])
+        self.assertFalse(r1.full_match(r1.name, dns.rdataclass.IN,
+                                       dns.rdatatype.MX, dns.rdatatype.NONE,
+                                       dns.rdataclass.ANY))
+
+    def testMatchCompatibilityWithFullMatch(self):
+        r1 = dns.rrset.from_text_list('foo', 30, 'in', 'a',
+                                      ['10.0.0.1', '10.0.0.2'])
+        self.assertTrue(r1.match(r1.name, dns.rdataclass.IN,
+                                 dns.rdatatype.A, dns.rdatatype.NONE))
 
-    def testNoMatch3(self):
+    def testMatchCompatibilityWithRdatasetMatch(self):
         r1 = dns.rrset.from_text_list('foo', 30, 'in', 'a',
                                       ['10.0.0.1', '10.0.0.2'])
-        self.assertFalse(r1.match(r1.name, dns.rdataclass.IN,
-                                  dns.rdatatype.MX, dns.rdatatype.NONE,
-                                  dns.rdataclass.ANY))
+        self.assertTrue(r1.match(dns.rdataclass.IN, dns.rdatatype.A,
+                                 dns.rdatatype.NONE))
 
     def testToRdataset(self):
         r1 = dns.rrset.from_text_list('foo', 30, 'in', 'a',