Modernize object cmp methods

octodns/record/__init__.py

@@ -13,13 +13,6 @@ from six import string_types, text_type
 
 from .geo import GeoCodes
 
-# TODO: remove when Python 2.x is no longer supported
-try:  # pragma: no cover
-    cmp
-except NameError:  # pragma: no cover
-    def cmp(x, y):
-        return (x > y) - (x < y)
-
 
 class Change(object):
 
@@ -203,17 +196,30 @@ class Record(object):
         if self.ttl != other.ttl:
             return Update(self, other)
 
-    # NOTE: we're using __hash__ and __cmp__ methods that consider Records
+    # NOTE: we're using __hash__ and ordering methods that consider Records
     # equivalent if they have the same name & _type. Values are ignored. This
     # is useful when computing diffs/changes.
 
     def __hash__(self):
         return '{}:{}'.format(self.name, self._type).__hash__()
 
-    def __cmp__(self, other):
-        a = '{}:{}'.format(self.name, self._type)
-        b = '{}:{}'.format(other.name, other._type)
-        return cmp(a, b)
+    def __eq__(self, other):
+        return ((self.name, self._type) == (other.name, other._type))
+
+    def __ne__(self, other):
+        return ((self.name, self._type) != (other.name, other._type))
+
+    def __lt__(self, other):
+        return ((self.name, self._type) < (other.name, other._type))
+
+    def __le__(self, other):
+        return ((self.name, self._type) <= (other.name, other._type))
+
+    def __gt__(self, other):
+        return ((self.name, self._type) > (other.name, other._type))
+
+    def __ge__(self, other):
+        return ((self.name, self._type) >= (other.name, other._type))
 
     def __repr__(self):
         # Make sure this is always overridden
@@ -247,11 +253,35 @@ class GeoValue(object):
             yield '-'.join(bits)
             bits.pop()
 
-    def __cmp__(self, other):
-        return 0 if (self.continent_code == other.continent_code and
-                     self.country_code == other.country_code and
-                     self.subdivision_code == other.subdivision_code and
-                     self.values == other.values) else 1
+    def __eq__(self, other):
+        return ((self.continent_code, self.country_code, self.subdivision_code,
+                self.values) == (other.continent_code, other.country_code,
+                                 other.subdivision_code, other.values))
+
+    def __ne__(self, other):
+        return ((self.continent_code, self.country_code, self.subdivision_code,
+                self.values) != (other.continent_code, other.country_code,
+                                 other.subdivision_code, other.values))
+
+    def __lt__(self, other):
+        return ((self.continent_code, self.country_code, self.subdivision_code,
+                self.values) < (other.continent_code, other.country_code,
+                                other.subdivision_code, other.values))
+
+    def __le__(self, other):
+        return ((self.continent_code, self.country_code, self.subdivision_code,
+                self.values) <= (other.continent_code, other.country_code,
+                                 other.subdivision_code, other.values))
+
+    def __gt__(self, other):
+        return ((self.continent_code, self.country_code, self.subdivision_code,
+                self.values) > (other.continent_code, other.country_code,
+                                other.subdivision_code, other.values))
+
+    def __ge__(self, other):
+        return ((self.continent_code, self.country_code, self.subdivision_code,
+                self.values) >= (other.continent_code, other.country_code,
+                                 other.subdivision_code, other.values))
 
     def __repr__(self):
         return "'Geo {} {} {} {}'".format(self.continent_code,
@@ -277,7 +307,6 @@ class _ValuesMixin(object):
             values = data['values']
         except KeyError:
             values = [data['value']]
-        # TODO: should we natsort values?
         self.values = sorted(self._value_type.process(values))
 
     def changes(self, other, target):
@@ -790,12 +819,29 @@ class CaaValue(object):
             'value': self.value,
         }
 
-    def __cmp__(self, other):
-        if self.flags == other.flags:
-            if self.tag == other.tag:
-                return cmp(self.value, other.value)
-            return cmp(self.tag, other.tag)
-        return cmp(self.flags, other.flags)
+    def __eq__(self, other):
+        return ((self.flags, self.tag, self.value) ==
+                (other.flags, other.tag, other.value))
+
+    def __ne__(self, other):
+        return ((self.flags, self.tag, self.value) !=
+                (other.flags, other.tag, other.value))
+
+    def __lt__(self, other):
+        return ((self.flags, self.tag, self.value) <
+                (other.flags, other.tag, other.value))
+
+    def __le__(self, other):
+        return ((self.flags, self.tag, self.value) <=
+                (other.flags, other.tag, other.value))
+
+    def __gt__(self, other):
+        return ((self.flags, self.tag, self.value) >
+                (other.flags, other.tag, other.value))
+
+    def __ge__(self, other):
+        return ((self.flags, self.tag, self.value) >=
+                (other.flags, other.tag, other.value))
 
     def __repr__(self):
         return '{} {} "{}"'.format(self.flags, self.tag, self.value)
@@ -872,10 +918,29 @@ class MxValue(object):
             'exchange': self.exchange,
         }
 
-    def __cmp__(self, other):
-        if self.preference == other.preference:
-            return cmp(self.exchange, other.exchange)
-        return cmp(self.preference, other.preference)
+    def __eq__(self, other):
+        return ((self.preference, self.exchange) ==
+                (other.preference, other.exchange))
+
+    def __ne__(self, other):
+        return ((self.preference, self.exchange) !=
+                (other.preference, other.exchange))
+
+    def __lt__(self, other):
+        return ((self.preference, self.exchange) <
+                (other.preference, other.exchange))
+
+    def __le__(self, other):
+        return ((self.preference, self.exchange) <=
+                (other.preference, other.exchange))
+
+    def __gt__(self, other):
+        return ((self.preference, self.exchange) >
+                (other.preference, other.exchange))
+
+    def __ge__(self, other):
+        return ((self.preference, self.exchange) >=
+                (other.preference, other.exchange))
 
     def __repr__(self):
         return "'{} {}'".format(self.preference, self.exchange)
@@ -945,18 +1010,41 @@ class NaptrValue(object):
             'replacement': self.replacement,
         }
 
-    def __cmp__(self, other):
-        if self.order != other.order:
-            return cmp(self.order, other.order)
-        elif self.preference != other.preference:
-            return cmp(self.preference, other.preference)
-        elif self.flags != other.flags:
-            return cmp(self.flags, other.flags)
-        elif self.service != other.service:
-            return cmp(self.service, other.service)
-        elif self.regexp != other.regexp:
-            return cmp(self.regexp, other.regexp)
-        return cmp(self.replacement, other.replacement)
+    def __eq__(self, other):
+        return ((self.order, self.preference, self.flags, self.service,
+                 self.regexp, self.replacement) ==
+                (other.order, other.preference, other.flags, other.service,
+                 other.regexp, other.replacement))
+
+    def __ne__(self, other):
+        return ((self.order, self.preference, self.flags, self.service,
+                 self.regexp, self.replacement) !=
+                (other.order, other.preference, other.flags, other.service,
+                 other.regexp, other.replacement))
+
+    def __lt__(self, other):
+        return ((self.order, self.preference, self.flags, self.service,
+                 self.regexp, self.replacement) <
+                (other.order, other.preference, other.flags, other.service,
+                 other.regexp, other.replacement))
+
+    def __le__(self, other):
+        return ((self.order, self.preference, self.flags, self.service,
+                 self.regexp, self.replacement) <=
+                (other.order, other.preference, other.flags, other.service,
+                 other.regexp, other.replacement))
+
+    def __gt__(self, other):
+        return ((self.order, self.preference, self.flags, self.service,
+                 self.regexp, self.replacement) >
+                (other.order, other.preference, other.flags, other.service,
+                 other.regexp, other.replacement))
+
+    def __ge__(self, other):
+        return ((self.order, self.preference, self.flags, self.service,
+                 self.regexp, self.replacement) >=
+                (other.order, other.preference, other.flags, other.service,
+                 other.regexp, other.replacement))
 
     def __repr__(self):
         flags = self.flags if self.flags is not None else ''
@@ -1057,12 +1145,29 @@ class SshfpValue(object):
             'fingerprint': self.fingerprint,
         }
 
-    def __cmp__(self, other):
-        if self.algorithm != other.algorithm:
-            return cmp(self.algorithm, other.algorithm)
-        elif self.fingerprint_type != other.fingerprint_type:
-            return cmp(self.fingerprint_type, other.fingerprint_type)
-        return cmp(self.fingerprint, other.fingerprint)
+    def __eq__(self, other):
+        return ((self.algorithm, self.fingerprint_type, self.fingerprint) ==
+                (other.algorithm, other.fingerprint_type, other.fingerprint))
+
+    def __ne__(self, other):
+        return ((self.algorithm, self.fingerprint_type, self.fingerprint) !=
+                (other.algorithm, other.fingerprint_type, other.fingerprint))
+
+    def __lt__(self, other):
+        return ((self.algorithm, self.fingerprint_type, self.fingerprint) <
+                (other.algorithm, other.fingerprint_type, other.fingerprint))
+
+    def __le__(self, other):
+        return ((self.algorithm, self.fingerprint_type, self.fingerprint) <=
+                (other.algorithm, other.fingerprint_type, other.fingerprint))
+
+    def __gt__(self, other):
+        return ((self.algorithm, self.fingerprint_type, self.fingerprint) >
+                (other.algorithm, other.fingerprint_type, other.fingerprint))
+
+    def __ge__(self, other):
+        return ((self.algorithm, self.fingerprint_type, self.fingerprint) >=
+                (other.algorithm, other.fingerprint_type, other.fingerprint))
 
     def __repr__(self):
         return "'{} {} {}'".format(self.algorithm, self.fingerprint_type,
@@ -1178,14 +1283,29 @@ class SrvValue(object):
             'target': self.target,
         }
 
-    def __cmp__(self, other):
-        if self.priority != other.priority:
-            return cmp(self.priority, other.priority)
-        elif self.weight != other.weight:
-            return cmp(self.weight, other.weight)
-        elif self.port != other.port:
-            return cmp(self.port, other.port)
-        return cmp(self.target, other.target)
+    def __eq__(self, other):
+        return ((self.priority, self.weight, self.port, self.target) ==
+                (other.priority, other.weight, other.port, other.target))
+
+    def __ne__(self, other):
+        return ((self.priority, self.weight, self.port, self.target) !=
+                (other.priority, other.weight, other.port, other.target))
+
+    def __lt__(self, other):
+        return ((self.priority, self.weight, self.port, self.target) <
+                (other.priority, other.weight, other.port, other.target))
+
+    def __le__(self, other):
+        return ((self.priority, self.weight, self.port, self.target) <=
+                (other.priority, other.weight, other.port, other.target))
+
+    def __gt__(self, other):
+        return ((self.priority, self.weight, self.port, self.target) >
+                (other.priority, other.weight, other.port, other.target))
+
+    def __ge__(self, other):
+        return ((self.priority, self.weight, self.port, self.target) >=
+                (other.priority, other.weight, other.port, other.target))
 
     def __repr__(self):
         return "'{} {} {} {}'".format(self.priority, self.weight, self.port,

tests/test_octodns_record.py

@@ -5,12 +5,14 @@
 from __future__ import absolute_import, division, print_function, \
     unicode_literals
 
+from six import text_type
 from unittest import TestCase
 
 from octodns.record import ARecord, AaaaRecord, AliasRecord, CaaRecord, \
-    CnameRecord, Create, Delete, GeoValue, MxRecord, NaptrRecord, NaptrValue, \
-    NsRecord, PtrRecord, Record, SshfpRecord, SpfRecord, SrvRecord, \
-    TxtRecord, Update, ValidationError, _Dynamic, _DynamicPool, _DynamicRule
+    CaaValue, CnameRecord, Create, Delete, GeoValue, MxRecord, MxValue, \
+    NaptrRecord, NaptrValue, NsRecord, PtrRecord, Record, SshfpRecord, \
+    SshfpValue, SpfRecord, SrvRecord, SrvValue, TxtRecord, Update, \
+    ValidationError, _Dynamic, _DynamicPool, _DynamicRule
 from octodns.zone import Zone
 
 from helpers import DynamicProvider, GeoProvider, SimpleProvider
@@ -482,109 +484,112 @@ class TestRecord(TestCase):
         # full sorting
         # equivalent
         b_naptr_value = b.values[0]
-        self.assertEquals(0, b_naptr_value.__cmp__(b_naptr_value))
+        self.assertTrue(b_naptr_value == b_naptr_value)
+        self.assertFalse(b_naptr_value != b_naptr_value)
+        self.assertTrue(b_naptr_value <= b_naptr_value)
+        self.assertTrue(b_naptr_value >= b_naptr_value)
         # by order
-        self.assertEquals(1, b_naptr_value.__cmp__(NaptrValue({
+        self.assertTrue(b_naptr_value > NaptrValue({
             'order': 10,
             'preference': 31,
             'flags': 'M',
             'service': 'N',
             'regexp': 'O',
             'replacement': 'x',
-        })))
-        self.assertEquals(-1, b_naptr_value.__cmp__(NaptrValue({
+        }))
+        self.assertTrue(b_naptr_value < NaptrValue({
             'order': 40,
             'preference': 31,
             'flags': 'M',
             'service': 'N',
             'regexp': 'O',
             'replacement': 'x',
-        })))
+        }))
         # by preference
-        self.assertEquals(1, b_naptr_value.__cmp__(NaptrValue({
+        self.assertTrue(b_naptr_value > NaptrValue({
             'order': 30,
             'preference': 10,
             'flags': 'M',
             'service': 'N',
             'regexp': 'O',
             'replacement': 'x',
-        })))
-        self.assertEquals(-1, b_naptr_value.__cmp__(NaptrValue({
+        }))
+        self.assertTrue(b_naptr_value < NaptrValue({
             'order': 30,
             'preference': 40,
             'flags': 'M',
             'service': 'N',
             'regexp': 'O',
             'replacement': 'x',
-        })))
+        }))
         # by flags
-        self.assertEquals(1, b_naptr_value.__cmp__(NaptrValue({
+        self.assertTrue(b_naptr_value > NaptrValue({
             'order': 30,
             'preference': 31,
             'flags': 'A',
             'service': 'N',
             'regexp': 'O',
             'replacement': 'x',
-        })))
-        self.assertEquals(-1, b_naptr_value.__cmp__(NaptrValue({
+        }))
+        self.assertTrue(b_naptr_value < NaptrValue({
             'order': 30,
             'preference': 31,
             'flags': 'Z',
             'service': 'N',
             'regexp': 'O',
             'replacement': 'x',
-        })))
+        }))
         # by service
-        self.assertEquals(1, b_naptr_value.__cmp__(NaptrValue({
+        self.assertTrue(b_naptr_value > NaptrValue({
             'order': 30,
             'preference': 31,
             'flags': 'M',
             'service': 'A',
             'regexp': 'O',
             'replacement': 'x',
-        })))
-        self.assertEquals(-1, b_naptr_value.__cmp__(NaptrValue({
+        }))
+        self.assertTrue(b_naptr_value < NaptrValue({
             'order': 30,
             'preference': 31,
             'flags': 'M',
             'service': 'Z',
             'regexp': 'O',
             'replacement': 'x',
-        })))
+        }))
         # by regexp
-        self.assertEquals(1, b_naptr_value.__cmp__(NaptrValue({
+        self.assertTrue(b_naptr_value > NaptrValue({
             'order': 30,
             'preference': 31,
             'flags': 'M',
             'service': 'N',
             'regexp': 'A',
             'replacement': 'x',
-        })))
-        self.assertEquals(-1, b_naptr_value.__cmp__(NaptrValue({
+        }))
+        self.assertTrue(b_naptr_value < NaptrValue({
             'order': 30,
             'preference': 31,
             'flags': 'M',
             'service': 'N',
             'regexp': 'Z',
             'replacement': 'x',
-        })))
+        }))
         # by replacement
-        self.assertEquals(1, b_naptr_value.__cmp__(NaptrValue({
+        self.assertTrue(b_naptr_value > NaptrValue({
             'order': 30,
             'preference': 31,
             'flags': 'M',
             'service': 'N',
             'regexp': 'O',
             'replacement': 'a',
-        })))
-        self.assertEquals(-1, b_naptr_value.__cmp__(NaptrValue({
+        }))
+        self.assertTrue(b_naptr_value < NaptrValue({
             'order': 30,
             'preference': 31,
             'flags': 'M',
             'service': 'N',
             'regexp': 'O',
             'replacement': 'z',
-        })))
+        }))
 
         # __repr__ doesn't blow up
         a.__repr__()
@@ -796,6 +801,38 @@ class TestRecord(TestCase):
         self.assertEquals(values, geo.values)
         self.assertEquals(['NA-US', 'NA'], list(geo.parents))
 
+        a = GeoValue('NA-US-CA', values)
+        b = GeoValue('AP-JP', values)
+        c = GeoValue('NA-US-CA', ['2.3.4.5'])
+
+        self.assertEqual(a, a)
+        self.assertEqual(b, b)
+        self.assertEqual(c, c)
+
+        self.assertNotEqual(a, b)
+        self.assertNotEqual(a, c)
+        self.assertNotEqual(b, a)
+        self.assertNotEqual(b, c)
+        self.assertNotEqual(c, a)
+        self.assertNotEqual(c, b)
+
+        self.assertTrue(a > b)
+        self.assertTrue(a < c)
+        self.assertTrue(b < a)
+        self.assertTrue(b < c)
+        self.assertTrue(c > a)
+        self.assertTrue(c > b)
+
+        self.assertTrue(a >= a)
+        self.assertTrue(a >= b)
+        self.assertTrue(a <= c)
+        self.assertTrue(b <= a)
+        self.assertTrue(b <= b)
+        self.assertTrue(b <= c)
+        self.assertTrue(c > a)
+        self.assertTrue(c > b)
+        self.assertTrue(c >= b)
+
     def test_healthcheck(self):
         new = Record.new(self.zone, 'a', {
             'ttl': 44,
@@ -851,6 +888,290 @@ class TestRecord(TestCase):
         })
         self.assertFalse(new.ignored)
 
+    def test_ordering_functions(self):
+        a = Record.new(self.zone, 'a', {
+            'ttl': 44,
+            'type': 'A',
+            'value': '1.2.3.4',
+        })
+        b = Record.new(self.zone, 'b', {
+            'ttl': 44,
+            'type': 'A',
+            'value': '1.2.3.4',
+        })
+        c = Record.new(self.zone, 'c', {
+            'ttl': 44,
+            'type': 'A',
+            'value': '1.2.3.4',
+        })
+        aaaa = Record.new(self.zone, 'a', {
+            'ttl': 44,
+            'type': 'AAAA',
+            'value': '2601:644:500:e210:62f8:1dff:feb8:947a',
+        })
+
+        self.assertEquals(a, a)
+        self.assertEquals(b, b)
+        self.assertEquals(c, c)
+        self.assertEquals(aaaa, aaaa)
+
+        self.assertNotEqual(a, b)
+        self.assertNotEqual(a, c)
+        self.assertNotEqual(a, aaaa)
+        self.assertNotEqual(b, a)
+        self.assertNotEqual(b, c)
+        self.assertNotEqual(b, aaaa)
+        self.assertNotEqual(c, a)
+        self.assertNotEqual(c, b)
+        self.assertNotEqual(c, aaaa)
+        self.assertNotEqual(aaaa, a)
+        self.assertNotEqual(aaaa, b)
+        self.assertNotEqual(aaaa, c)
+
+        self.assertTrue(a < b)
+        self.assertTrue(a < c)
+        self.assertTrue(a < aaaa)
+        self.assertTrue(b > a)
+        self.assertTrue(b < c)
+        self.assertTrue(b > aaaa)
+        self.assertTrue(c > a)
+        self.assertTrue(c > b)
+        self.assertTrue(c > aaaa)
+        self.assertTrue(aaaa > a)
+        self.assertTrue(aaaa < b)
+        self.assertTrue(aaaa < c)
+
+        self.assertTrue(a <= a)
+        self.assertTrue(a <= b)
+        self.assertTrue(a <= c)
+        self.assertTrue(a <= aaaa)
+        self.assertTrue(b >= a)
+        self.assertTrue(b >= b)
+        self.assertTrue(b <= c)
+        self.assertTrue(b >= aaaa)
+        self.assertTrue(c >= a)
+        self.assertTrue(c >= b)
+        self.assertTrue(c >= c)
+        self.assertTrue(c >= aaaa)
+        self.assertTrue(aaaa >= a)
+        self.assertTrue(aaaa <= b)
+        self.assertTrue(aaaa <= c)
+        self.assertTrue(aaaa <= aaaa)
+
+    def test_caa_value(self):
+        a = CaaValue({'flags': 0, 'tag': 'a', 'value': 'v'})
+        b = CaaValue({'flags': 1, 'tag': 'a', 'value': 'v'})
+        c = CaaValue({'flags': 0, 'tag': 'c', 'value': 'v'})
+        d = CaaValue({'flags': 0, 'tag': 'a', 'value': 'z'})
+
+        self.assertEqual(a, a)
+        self.assertEqual(b, b)
+        self.assertEqual(c, c)
+        self.assertEqual(d, d)
+
+        self.assertNotEqual(a, b)
+        self.assertNotEqual(a, c)
+        self.assertNotEqual(a, d)
+        self.assertNotEqual(b, a)
+        self.assertNotEqual(b, c)
+        self.assertNotEqual(b, d)
+        self.assertNotEqual(c, a)
+        self.assertNotEqual(c, b)
+        self.assertNotEqual(c, d)
+
+        self.assertTrue(a < b)
+        self.assertTrue(a < c)
+        self.assertTrue(a < d)
+
+        self.assertTrue(b > a)
+        self.assertTrue(b > c)
+        self.assertTrue(b > d)
+
+        self.assertTrue(c > a)
+        self.assertTrue(c < b)
+        self.assertTrue(c > d)
+
+        self.assertTrue(d > a)
+        self.assertTrue(d < b)
+        self.assertTrue(d < c)
+
+        self.assertTrue(a <= b)
+        self.assertTrue(a <= c)
+        self.assertTrue(a <= d)
+        self.assertTrue(a <= a)
+        self.assertTrue(a >= a)
+
+        self.assertTrue(b >= a)
+        self.assertTrue(b >= c)
+        self.assertTrue(b >= d)
+        self.assertTrue(b >= b)
+        self.assertTrue(b <= b)
+
+        self.assertTrue(c >= a)
+        self.assertTrue(c <= b)
+        self.assertTrue(c >= d)
+        self.assertTrue(c >= c)
+        self.assertTrue(c <= c)
+
+        self.assertTrue(d >= a)
+        self.assertTrue(d <= b)
+        self.assertTrue(d <= c)
+        self.assertTrue(d >= d)
+        self.assertTrue(d <= d)
+
+    def test_mx_value(self):
+        a = MxValue({'preference': 0, 'priority': 'a', 'exchange': 'v',
+                     'value': '1'})
+        b = MxValue({'preference': 10, 'priority': 'a', 'exchange': 'v',
+                     'value': '2'})
+        c = MxValue({'preference': 0, 'priority': 'b', 'exchange': 'z',
+                     'value': '3'})
+
+        self.assertEqual(a, a)
+        self.assertEqual(b, b)
+        self.assertEqual(c, c)
+
+        self.assertNotEqual(a, b)
+        self.assertNotEqual(a, c)
+        self.assertNotEqual(b, a)
+        self.assertNotEqual(b, c)
+        self.assertNotEqual(c, a)
+        self.assertNotEqual(c, b)
+
+        self.assertTrue(a < b)
+        self.assertTrue(a < c)
+
+        self.assertTrue(b > a)
+        self.assertTrue(b > c)
+
+        self.assertTrue(c > a)
+        self.assertTrue(c < b)
+
+        self.assertTrue(a <= b)
+        self.assertTrue(a <= c)
+        self.assertTrue(a <= a)
+        self.assertTrue(a >= a)
+
+        self.assertTrue(b >= a)
+        self.assertTrue(b >= c)
+        self.assertTrue(b >= b)
+        self.assertTrue(b <= b)
+
+        self.assertTrue(c >= a)
+        self.assertTrue(c <= b)
+        self.assertTrue(c >= c)
+        self.assertTrue(c <= c)
+
+    def test_sshfp_value(self):
+        a = SshfpValue({'algorithm': 0, 'fingerprint_type': 0,
+                        'fingerprint': 'abcd'})
+        b = SshfpValue({'algorithm': 1, 'fingerprint_type': 0,
+                        'fingerprint': 'abcd'})
+        c = SshfpValue({'algorithm': 0, 'fingerprint_type': 1,
+                        'fingerprint': 'abcd'})
+        d = SshfpValue({'algorithm': 0, 'fingerprint_type': 0,
+                        'fingerprint': 'bcde'})
+
+        self.assertEqual(a, a)
+        self.assertEqual(b, b)
+        self.assertEqual(c, c)
+        self.assertEqual(d, d)
+
+        self.assertNotEqual(a, b)
+        self.assertNotEqual(a, c)
+        self.assertNotEqual(a, d)
+        self.assertNotEqual(b, a)
+        self.assertNotEqual(b, c)
+        self.assertNotEqual(b, d)
+        self.assertNotEqual(c, a)
+        self.assertNotEqual(c, b)
+        self.assertNotEqual(c, d)
+        self.assertNotEqual(d, a)
+        self.assertNotEqual(d, b)
+        self.assertNotEqual(d, c)
+
+        self.assertTrue(a < b)
+        self.assertTrue(a < c)
+
+        self.assertTrue(b > a)
+        self.assertTrue(b > c)
+
+        self.assertTrue(c > a)
+        self.assertTrue(c < b)
+
+        self.assertTrue(a <= b)
+        self.assertTrue(a <= c)
+        self.assertTrue(a <= a)
+        self.assertTrue(a >= a)
+
+        self.assertTrue(b >= a)
+        self.assertTrue(b >= c)
+        self.assertTrue(b >= b)
+        self.assertTrue(b <= b)
+
+        self.assertTrue(c >= a)
+        self.assertTrue(c <= b)
+        self.assertTrue(c >= c)
+        self.assertTrue(c <= c)
+
+    def test_srv_value(self):
+        a = SrvValue({'priority': 0, 'weight': 0, 'port': 0, 'target': 'foo.'})
+        b = SrvValue({'priority': 1, 'weight': 0, 'port': 0, 'target': 'foo.'})
+        c = SrvValue({'priority': 0, 'weight': 2, 'port': 0, 'target': 'foo.'})
+        d = SrvValue({'priority': 0, 'weight': 0, 'port': 3, 'target': 'foo.'})
+        e = SrvValue({'priority': 0, 'weight': 0, 'port': 0, 'target': 'mmm.'})
+
+        self.assertEqual(a, a)
+        self.assertEqual(b, b)
+        self.assertEqual(c, c)
+        self.assertEqual(d, d)
+        self.assertEqual(e, e)
+
+        self.assertNotEqual(a, b)
+        self.assertNotEqual(a, c)
+        self.assertNotEqual(a, d)
+        self.assertNotEqual(a, e)
+        self.assertNotEqual(b, a)
+        self.assertNotEqual(b, c)
+        self.assertNotEqual(b, d)
+        self.assertNotEqual(b, e)
+        self.assertNotEqual(c, a)
+        self.assertNotEqual(c, b)
+        self.assertNotEqual(c, d)
+        self.assertNotEqual(c, e)
+        self.assertNotEqual(d, a)
+        self.assertNotEqual(d, b)
+        self.assertNotEqual(d, c)
+        self.assertNotEqual(d, e)
+        self.assertNotEqual(e, a)
+        self.assertNotEqual(e, b)
+        self.assertNotEqual(e, c)
+        self.assertNotEqual(e, d)
+
+        self.assertTrue(a < b)
+        self.assertTrue(a < c)
+
+        self.assertTrue(b > a)
+        self.assertTrue(b > c)
+
+        self.assertTrue(c > a)
+        self.assertTrue(c < b)
+
+        self.assertTrue(a <= b)
+        self.assertTrue(a <= c)
+        self.assertTrue(a <= a)
+        self.assertTrue(a >= a)
+
+        self.assertTrue(b >= a)
+        self.assertTrue(b >= c)
+        self.assertTrue(b >= b)
+        self.assertTrue(b <= b)
+
+        self.assertTrue(c >= a)
+        self.assertTrue(c <= b)
+        self.assertTrue(c >= c)
+        self.assertTrue(c <= c)
+
 
 class TestRecordValidation(TestCase):
     zone = Zone('unit.tests.', [])