Merge branch 'master' into gcore-provider

tests/test_octodns_provider_azuredns.py

@@ -999,6 +999,51 @@ class TestAzureDnsProvider(TestCase):
                 'Collision in Traffic Manager'
             ))
 
+    @patch(
+        'octodns.provider.azuredns.AzureProvider._generate_traffic_managers')
+    def test_extra_changes_non_last_fallback_contains_default(self, mock_gtm):
+        provider = self._get_provider()
+
+        desired = Zone(zone.name, sub_zones=[])
+        record = Record.new(desired, 'foo', {
+            'type': 'CNAME',
+            'ttl': 60,
+            'value': 'default.unit.tests.',
+            'dynamic': {
+                'pools': {
+                    'one': {
+                        'values': [{'value': 'one.unit.tests.'}],
+                        'fallback': 'def',
+                    },
+                    'def': {
+                        'values': [{'value': 'default.unit.tests.'}],
+                        'fallback': 'two',
+                    },
+                    'two': {
+                        'values': [{'value': 'two.unit.tests.'}],
+                    },
+                },
+                'rules': [
+                    {'pool': 'one'},
+                ]
+            }
+        })
+        desired.add_record(record)
+        changes = [Create(record)]
+
+        # assert that no exception is raised
+        provider._extra_changes(zone, desired, changes)
+
+        # simulate duplicate endpoint and assert exception
+        endpoint = Endpoint(target='dup.unit.tests.')
+        mock_gtm.return_value = [Profile(
+            name='test-profile',
+            endpoints=[endpoint, endpoint],
+        )]
+        with self.assertRaises(AzureException) as ctx:
+            provider._extra_changes(zone, desired, changes)
+            self.assertTrue('duplicate endpoint' in text_type(ctx))
+
     def test_extra_changes_invalid_dynamic_A(self):
         provider = self._get_provider()
 
@@ -1642,6 +1687,12 @@ class TestAzureDnsProvider(TestCase):
             'value': 'default.unit.tests.',
             'dynamic': {
                 'pools': {
+                    'sto': {
+                        'values': [
+                            {'value': 'sto.unit.tests.'},
+                        ],
+                        'fallback': 'iad',
+                    },
                     'iad': {
                         'values': [
                             {'value': 'iad.unit.tests.'},
@@ -1657,13 +1708,14 @@ class TestAzureDnsProvider(TestCase):
                 'rules': [
                     {'geos': ['EU'], 'pool': 'iad'},
                     {'geos': ['EU-GB'], 'pool': 'lhr'},
+                    {'geos': ['EU-SE'], 'pool': 'sto'},
                     {'pool': 'lhr'},
                 ],
             }
         })
         profiles = provider._generate_traffic_managers(record)
 
-        self.assertEqual(len(profiles), 3)
+        self.assertEqual(len(profiles), 4)
         self.assertTrue(_profile_is_match(profiles[-1], Profile(
             name='foo--unit--tests',
             traffic_routing_method='Geographic',
@@ -1683,6 +1735,12 @@ class TestAzureDnsProvider(TestCase):
                     target_resource_id=profiles[1].id,
                     geo_mapping=['GB', 'WORLD'],
                 ),
+                Endpoint(
+                    name='rule-sto',
+                    type=nested,
+                    target_resource_id=profiles[2].id,
+                    geo_mapping=['SE'],
+                ),
             ],
         )))
 

tests/test_octodns_provider_ns1.py

@@ -1034,7 +1034,7 @@ class TestNs1ProviderDynamic(TestCase):
         rule0 = record.data['dynamic']['rules'][0]
         rule1 = record.data['dynamic']['rules'][1]
         rule0['geos'] = ['AF', 'EU']
-        rule1['geos'] = ['NA']
+        rule1['geos'] = ['AS']
         ret, monitor_ids = provider._params_for_A(record)
         self.assertEquals(10, len(ret['answers']))
         self.assertEquals(ret['filters'],
@@ -1048,7 +1048,7 @@ class TestNs1ProviderDynamic(TestCase):
             },
             'iad__georegion': {
                 'meta': {
-                    'georegion': ['US-CENTRAL', 'US-EAST', 'US-WEST'],
+                    'georegion': ['ASIAPAC'],
                     'note': 'rule-order:1'
                 }
             },
@@ -1150,7 +1150,7 @@ class TestNs1ProviderDynamic(TestCase):
         rule0 = record.data['dynamic']['rules'][0]
         rule1 = record.data['dynamic']['rules'][1]
         rule0['geos'] = ['AF', 'EU', 'NA-US-CA']
-        rule1['geos'] = ['NA', 'NA-US']
+        rule1['geos'] = ['AS', 'AS-IN']
         ret, _ = provider._params_for_A(record)
 
         self.assertEquals(17, len(ret['answers']))
@@ -1210,13 +1210,13 @@ class TestNs1ProviderDynamic(TestCase):
             },
             'iad__country': {
                 'meta': {
-                    'country': ['US'],
+                    'country': ['IN'],
                     'note': 'rule-order:1'
                 }
             },
             'iad__georegion': {
                 'meta': {
-                    'georegion': ['US-CENTRAL', 'US-EAST', 'US-WEST'],
+                    'georegion': ['ASIAPAC'],
                     'note': 'rule-order:1'
                 }
             },
@@ -1562,6 +1562,24 @@ class TestNs1ProviderDynamic(TestCase):
             self.assertTrue(
                 'OC-{}'.format(c) in data4['dynamic']['rules'][0]['geos'])
 
+        # NA test cases
+        # 1. Full list of countries should return 'NA' in geos
+        na_countries = Ns1Provider._CONTINENT_TO_LIST_OF_COUNTRIES['NA']
+        del ns1_record['regions']['lhr__country']['meta']['us_state']
+        ns1_record['regions']['lhr__country']['meta']['country'] = \
+            list(na_countries)
+        data5 = provider._data_for_A('A', ns1_record)
+        self.assertTrue('NA' in data5['dynamic']['rules'][0]['geos'])
+
+        # 2. Partial list of countries should return just those
+        partial_na_cntry_list = list(na_countries)[:5] + ['SX', 'UM']
+        ns1_record['regions']['lhr__country']['meta']['country'] = \
+            partial_na_cntry_list
+        data6 = provider._data_for_A('A', ns1_record)
+        for c in partial_na_cntry_list:
+            self.assertTrue(
+                'NA-{}'.format(c) in data6['dynamic']['rules'][0]['geos'])
+
         # Test out fallback only pools and new-style notes
         ns1_record = {
             'answers': [{

tests/test_octodns_provider_ultra.py

@@ -1,8 +1,11 @@
+from __future__ import unicode_literals
+
 from mock import Mock, call
 from os.path import dirname, join
 from requests import HTTPError
 from requests_mock import ANY, mock as requests_mock
 from six import text_type
+from six.moves.urllib import parse
 from unittest import TestCase
 from json import load as json_load
 
@@ -55,7 +58,8 @@ class TestUltraProvider(TestCase):
             self.assertEquals(1, mock.call_count)
             expected_payload = "grant_type=password&username=user&"\
                                "password=rightpass"
-            self.assertEquals(mock.last_request.text, expected_payload)
+            self.assertEquals(parse.parse_qs(mock.last_request.text),
+                              parse.parse_qs(expected_payload))
 
     def test_get_zones(self):
         provider = _get_provider()

tests/test_octodns_source_envvar.py

@@ -1,6 +1,6 @@
+from mock import patch
 from six import text_type
 from unittest import TestCase
-from unittest.mock import patch
 
 from octodns.source.envvar import EnvVarSource
 from octodns.source.envvar import EnvironmentVariableNotFoundException