Implement _Route53Record._value_convert_*

octodns/provider/route53.py

@@ -83,6 +83,15 @@ class _Route53Record(object):
         return '_Route53Record<{} {} {} {}>'.format(self.fqdn, self._type,
                                                     self.ttl, self.values)
 
+    def _value_convert_value(self, value, record):
+        return value
+
+    _value_convert_A = _value_convert_value
+    _value_convert_AAAA = _value_convert_value
+    _value_convert_NS = _value_convert_value
+    _value_convert_CNAME = _value_convert_value
+    _value_convert_PTR = _value_convert_value
+
     def _values_for_values(self, record):
         return record.values
 
@@ -90,9 +99,11 @@ class _Route53Record(object):
     _values_for_AAAA = _values_for_values
     _values_for_NS = _values_for_values
 
+    def _value_convert_CAA(self, value, record):
+        return '{} {} "{}"'.format(value.flags, value.tag, value.value)
+
     def _values_for_CAA(self, record):
-        return ['{} {} "{}"'.format(v.flags, v.tag, v.value)
-                for v in record.values]
+        return [self._value_convert_CAA(v, record) for v in record.values]
 
     def _values_for_value(self, record):
         return [record.value]
@@ -100,18 +111,28 @@ class _Route53Record(object):
     _values_for_CNAME = _values_for_value
     _values_for_PTR = _values_for_value
 
+    def _value_convert_MX(self, value, record):
+        return '{} {}'.format(value.preference, value.exchange)
+
     def _values_for_MX(self, record):
-        return ['{} {}'.format(v.preference, v.exchange)
-                for v in record.values]
+        return [self._value_convert_MX(v, record) for v in record.values]
+
+    def _value_convert_NAPTR(self, value, record):
+        return '{} {} "{}" "{}" "{}" {}' \
+            .format(value.order, value.preference,
+                    value.flags if value.flags else '',
+                    value.service if value.service else '',
+                    value.regexp if value.regexp else '',
+                    value.replacement)
 
     def _values_for_NAPTR(self, record):
-        return ['{} {} "{}" "{}" "{}" {}'
-                .format(v.order, v.preference,
-                        v.flags if v.flags else '',
-                        v.service if v.service else '',
-                        v.regexp if v.regexp else '',
-                        v.replacement)
-                for v in record.values]
+        return [self._value_convert_NAPTR(v, record) for v in record.values]
+
+    def _value_convert_quoted(self, value, record):
+        return record.chunked_value(value)
+
+    _value_convert_SPF = _value_convert_quoted
+    _value_convert_TXT = _value_convert_quoted
 
     def _values_for_quoted(self, record):
         return record.chunked_values
@@ -119,10 +140,12 @@ class _Route53Record(object):
     _values_for_SPF = _values_for_quoted
     _values_for_TXT = _values_for_quoted
 
+    def _value_for_SRV(self, value, record):
+        return '{} {} {} {}'.format(value.priority, value.weight,
+                                    value.port, value.target)
+
     def _values_for_SRV(self, record):
-        return ['{} {} {} {}'.format(v.priority, v.weight, v.port,
-                                     v.target)
-                for v in record.values]
+        return [self._value_for_SRV(v, record) for v in record.values]
 
 
 class _Route53GeoDefault(_Route53Record):

tests/test_octodns_provider_route53.py

@@ -1531,32 +1531,52 @@ class TestRoute53Provider(TestCase):
 
 
 class TestRoute53Records(TestCase):
+    existing = Zone('unit.tests.', [])
+    record_a = Record.new(existing, '', {
+        'geo': {
+            'NA-US': ['2.2.2.2', '3.3.3.3'],
+            'OC': ['4.4.4.4', '5.5.5.5']
+        },
+        'ttl': 99,
+        'type': 'A',
+        'values': ['9.9.9.9']
+    })
 
-    def test_route53_record(self):
-        existing = Zone('unit.tests.', [])
-        record_a = Record.new(existing, '', {
-            'geo': {
-                'NA-US': ['2.2.2.2', '3.3.3.3'],
-                'OC': ['4.4.4.4', '5.5.5.5']
-            },
-            'ttl': 99,
-            'type': 'A',
-            'values': ['9.9.9.9']
+    def test_value_fors(self):
+        route53_record = _Route53Record(None, self.record_a, False)
+
+        for value in (None, '', 'foo', 'bar', '1.2.3.4'):
+            self.assertEquals(value, route53_record
+                              ._value_convert_value(value, self.record_a))
+
+        record_txt = Record.new(self.existing, 'txt', {
+            'ttl': 98,
+            'type': 'TXT',
+            'value': 'Not Important',
         })
-        a = _Route53Record(None, record_a, False)
+
+        # We don't really have to test the details fo chunked_value as that's
+        # tested elsewhere, we just need to make sure that it's plumbed up and
+        # working
+        self.assertEquals('"Not Important"', route53_record
+                          ._value_convert_quoted(record_txt.values[0],
+                                                 record_txt))
+
+    def test_route53_record(self):
+        a = _Route53Record(None, self.record_a, False)
         self.assertEquals(a, a)
-        b = _Route53Record(None, Record.new(existing, '',
+        b = _Route53Record(None, Record.new(self.existing, '',
                                             {'ttl': 32, 'type': 'A',
                                              'values': ['8.8.8.8',
                                                         '1.1.1.1']}),
                            False)
         self.assertEquals(b, b)
-        c = _Route53Record(None, Record.new(existing, 'other',
+        c = _Route53Record(None, Record.new(self.existing, 'other',
                                             {'ttl': 99, 'type': 'A',
                                              'values': ['9.9.9.9']}),
                            False)
         self.assertEquals(c, c)
-        d = _Route53Record(None, Record.new(existing, '',
+        d = _Route53Record(None, Record.new(self.existing, '',
                                             {'ttl': 42, 'type': 'MX',
                                              'value': {
                                                  'preference': 10,
@@ -1572,7 +1592,7 @@ class TestRoute53Records(TestCase):
         self.assertNotEquals(a, c)
 
         # Same everything, different class is not the same
-        e = _Route53GeoDefault(None, record_a, False)
+        e = _Route53GeoDefault(None, self.record_a, False)
         self.assertNotEquals(a, e)
 
         class DummyProvider(object):
@@ -1581,11 +1601,11 @@ class TestRoute53Records(TestCase):
                 return None
 
         provider = DummyProvider()
-        f = _Route53GeoRecord(provider, record_a, 'NA-US',
-                              record_a.geo['NA-US'], False)
+        f = _Route53GeoRecord(provider, self.record_a, 'NA-US',
+                              self.record_a.geo['NA-US'], False)
         self.assertEquals(f, f)
-        g = _Route53GeoRecord(provider, record_a, 'OC',
-                              record_a.geo['OC'], False)
+        g = _Route53GeoRecord(provider, self.record_a, 'OC',
+                              self.record_a.geo['OC'], False)
         self.assertEquals(g, g)
 
         # Geo and non-geo are not the same, using Geo as primary to get it's