Add test cases for multiple stacks

bootstrap_cfn/fab_tasks.py

@@ -7,8 +7,6 @@
 
 import boto3
 
-import dns.resolver
-
 from fabric.api import env, task
 from fabric.colors import green, red
 from fabric.utils import abort
@@ -361,21 +359,23 @@ def get_stack_name(new=False):
         # know it yet...
         env.stack_name = 'temp'
         zone_name = get_zone_name()
+        zone_id = get_zone_id()
         if not zone_name:
             raise CfnConfigError("No master_zone in yaml, unable to create/find DNS records for stack name")
         logger.info("fab_tasks::get_stack_name: Found master zone '{}' in config...".format(zone_name))
         # get record name in the format of: stack.[stack_tag].[app]-[env]
         record_name = get_tag_record_name(stack_tag)
         dns_name = "{}.{}".format(record_name, zone_name)
+        r53_conn = get_connection(R53)
         try:
             # get stack id
-            stack_suffix = dns.resolver.query(dns_name, 'TXT')[0].to_text().replace('"', "")
+            stack_suffix = r53_conn.get_record(zone_name, zone_id, record_name, 'TXT').replace('"', "")
             logger.info("fab_tasks::get_stack_name: Found stack suffix '{}' "
                         "for dns record '{}'... ".format(stack_suffix, dns_name))
             legacy_name = get_legacy_name()
             env.stack_name = "{0}-{1}".format(legacy_name, stack_suffix)
             logger.info("fab_tasks::get_stack_name: Found stack name '{}'...".format(env.stack_name))
-        except dns.resolver.NXDOMAIN:
+        except:
             raise DNSRecordNotFoundError(dns_name)
 
     return env.stack_name
@@ -411,7 +411,7 @@ def set_stack_name():
     else:
         stack_tag = stack_suffix
         env.tag = stack_tag
-    record = "{}.{}".format(get_tag_record_name(stack_tag), get_zone_name())
+    record = "{}.{}".format(get_tag_record_name(stack_tag), zone_name)
     logger.info("fab_tasks::set_stack_name: "
                 "Creating stack suffix {} "
                 "for record '{}' "

tests/test_fab_tasks.py

@@ -1,10 +1,24 @@
 import unittest
 
-from bootstrap_cfn import fab_tasks  # noqa
+import boto.route53
+
+import yaml
+
 from mock import patch, Mock  # noqa
 
+from bootstrap_cfn import config, errors, fab_tasks, r53
+
 fake_profile = {'lol': {'aws_access_key_id': 'secretz', 'aws_secret_access_key': 'verysecretz'}}
 
+basic_config = {'master_zone': 'dsd.io',
+                'ec2': {},
+                'elb': [{'hosted_zone': 'unittest.dsd.io.',
+                         'name': 'unittest',
+                         'scheme': 'internet-facing'}],
+                'rds': {},
+                's3': {}}
+basic_config_yaml = yaml.dump(basic_config)
+
 
 class TestFabTasks(unittest.TestCase):
 
@@ -16,3 +30,144 @@ def test_loaded(self):
     def test_aws_task(self, mock_botocore):
         mock_botocore.return_value = fake_profile['lol']
         fab_tasks.aws('nonexistent_profile')
+
+    def test_get_all_elbs(self):
+        config_mock = Mock()
+        basic_config_mock = yaml.load(basic_config_yaml)
+        config_mock.return_value = config.ConfigParser(basic_config_mock, "unittest_stack_name", "dev", "test")
+        fab_tasks.get_config = config_mock
+        cfn_config = fab_tasks.get_config()
+
+        all_elbs = [x.get('name')
+                    for x in cfn_config.data.get('elb', {}) if x.get('scheme') == 'internet-facing']
+        real_res = []
+        real_res.append("unittest")
+        self.assertEqual(all_elbs, real_res)
+
+    def test_get_active_stack(self):
+        zone_name = "dsd.io"
+        zone_id = "ASDAKSLDK"
+        active_record = "recordname"
+
+        r53_mock = Mock()
+        r53_connect_result = Mock(name='cf_connect')
+        r53_mock.return_value = r53_connect_result
+        m = Mock(resource_records=['"12345678"'])
+        m.name = 'recordname.dsd.io.'
+        m.type = 'TXT'
+        response = [m]
+        mock_config = {'get_all_rrsets.return_value': response}
+        r53_connect_result.configure_mock(**mock_config)
+        boto.route53.connect_to_region = r53_mock
+        r = r53.R53("profile_name")
+        active_stack_id = r.get_record(zone_name, zone_id, active_record, 'TXT')
+        self.assertTrue(active_stack_id)
+
+        first_public_elb_mock = Mock()
+        first_public_elb_mock.return_value = "unittest_elb"
+        fab_tasks.get_first_public_elb = first_public_elb_mock
+
+        elb = fab_tasks.get_first_public_elb()
+        dns_record_name = '{}-{}'.format(elb, active_stack_id)
+        m = Mock(alias_dns_name='dnsname')
+        m.name = 'unittest_elb.dsd.io.'
+        m.type = 'TXT'
+        response = [m]
+        mock_config = {'get_all_rrsets.return_value': response}
+        r53_connect_result.configure_mock(**mock_config)
+        boto.route53.connect_to_region = r53_mock
+        r = r53.R53("profile_name")
+        dns_record_value = r.get_record(zone_name, zone_id, dns_record_name, 'A')
+        main_record_value = r.get_record(zone_name, zone_id, elb, 'A')
+
+        self.assertEqual(dns_record_value, main_record_value)
+
+        # add test case for no active stack
+
+    def test_set_active_stack(self):
+        self.assertTrue(True)
+
+    def test_cfn_delete(self):
+        self.assertTrue(True)
+
+    def test_cfn_create(self):
+        self.assertTrue(True)
+
+    def test_get_tag_record_name(self):
+        legacy_name_mock = Mock()
+        legacy_name_mock.return_value = "unittest-dev"
+        fab_tasks.get_legacy_name = legacy_name_mock
+        legacy_name = fab_tasks.get_legacy_name()
+        record_name = "stack.tag.{}".format(legacy_name)
+        self.assertEqual(record_name, "stack.tag.unittest-dev")
+
+    def test_get_stack_name(self):
+        zone_name_mock = Mock(return_value="dsd.io")
+        fab_tasks.get_zone_name = zone_name_mock
+        legacy_name_mock = Mock(return_value="unittest-dev")
+        fab_tasks.get_legacy_name = legacy_name_mock
+        tag_record_name_mock = Mock(return_value="unittest-dev-12345678")
+        fab_tasks.get_tag_record_name = tag_record_name_mock
+        zone_id_mock = Mock(return_value="ASDAKSLDK")
+        fab_tasks.get_zone_id = zone_id_mock
+
+        # mock get_connection(R53)
+        r53_mock = Mock()
+        r53_connect_result = Mock(name='cf_connect')
+        r53_mock.return_value = r53_connect_result
+        m = Mock(resource_records=['"12345678"'])
+        m.name = 'unittest-dev-12345678.dsd.io.'
+        m.type = 'TXT'
+        response = [m]
+        mock_config = {'get_all_rrsets.return_value': response}
+        r53_connect_result.configure_mock(**mock_config)
+        boto.route53.connect_to_region = r53_mock
+        r = r53.R53("profile_name")
+        fab_tasks.get_connection = Mock(return_value=r)
+
+        stack_name = fab_tasks.get_stack_name(new=False)
+        self.assertTrue(stack_name)
+        self.assertEqual(stack_name, "unittest-dev-12345678")
+
+    def test_set_stack_name(self):
+        zone_name_mock = Mock(return_value="dsd.io")
+        fab_tasks.get_zone_name = zone_name_mock
+        legacy_name_mock = Mock(return_value="unittest-dev")
+        fab_tasks.get_legacy_name = legacy_name_mock
+        zone_id_mock = Mock(return_value="ASDAKSLDK")
+        fab_tasks.get_zone_id = zone_id_mock
+        tag_record_name_mock = Mock(return_value="unittest-dev-12345678")
+        fab_tasks.get_tag_record_name = tag_record_name_mock
+
+        # mock get_connection(R53)
+        r53_mock = Mock()
+        r53_connect_result = Mock(name='cf_connect')
+        r53_mock.return_value = r53_connect_result
+        m = Mock(resource_records=['"12345678"'])
+        m.name = 'recordname.dsd.io.'
+        m.type = 'TXT'
+        response = [m]
+        mock_config = {'update_dns_record.return_value': response,
+                       'get_all_rrsets.return_value': response}
+        r53_connect_result.configure_mock(**mock_config)
+        boto.route53.connect_to_region = r53_mock
+        r = r53.R53("profile_name")
+        fab_tasks.get_connection = Mock(return_value=r)
+
+        stack_tag_mock = Mock(return_value="test")
+        fab_tasks.env.tag = stack_tag_mock
+        stack_name = fab_tasks.set_stack_name()
+        self.assertTrue(stack_name)
+
+    def test_get_zone_name(self):
+        config_mock = Mock()
+        basic_config_mock = yaml.load(basic_config_yaml)
+        config_mock.return_value = config.ConfigParser(basic_config_mock, "unittest_stack_name", "dev", "test")
+        fab_tasks.get_config = config_mock
+        cfn_config = fab_tasks.get_config()
+
+        zone_name = cfn_config.data.get('master_zone', None)
+        if not zone_name:
+            self.assertRaises(errors.CfnConfigError(
+                "No master_zone in yaml, unable to create/find DNS records for stack name"))
+        self.assertEqual(zone_name, "dsd.io")

tests/test_r53.py

@@ -29,6 +29,15 @@ def test_update_dns_record(self):
         x = r.update_dns_record('blah/blah', 'x.y', 'A', '1.1.1.1')
         self.assertTrue(x)
 
+    def test_delete_dns_record(self):
+        r53_mock = mock.Mock()
+        r53_connect_result = mock.Mock(name='cf_connect')
+        r53_mock.return_value = r53_connect_result
+        boto.route53.connect_to_region = r53_mock
+        r = r53.R53(self.env.aws_profile)
+        x = r.delete_dns_record('blah/blah', 'x.y', 'A', '1.1.1.1')
+        self.assertTrue(x)
+
     def test_get_hosted_zone_id(self):
         r53_mock = mock.Mock()
         r53_connect_result = mock.Mock(name='cf_connect')
@@ -60,6 +69,23 @@ def test_get_record(self):
         x = r.get_record('dsd.io', 'ASDAKSLDK', 'recordname', 'A')
         self.assertEquals(x, 'dnsname')
 
+    def test_get_full_record(self):
+        record_fqdn = "recordname"
+        r53_mock = mock.Mock()
+        r53_connect_result = mock.Mock(name='cf_connect')
+        r53_mock.return_value = r53_connect_result
+        m = mock.Mock(record="unittest")
+        m.name = 'recordname.dsd.io.'
+        m.type = 'A'
+        response = [m]
+        mock_config = {'get_all_rrsets.return_value': response}
+        r53_connect_result.configure_mock(**mock_config)
+        boto.route53.connect_to_region = r53_mock
+        r = r53.R53(self.env.aws_profile)
+
+        rrsets = r.get_full_record('dsd.io', 'ASDAKSLDK', record_fqdn, 'A')
+        self.assertEqual(rrsets.record, m.record)
+
     def test_get_TXT_record(self):
         r53_mock = mock.Mock()
         r53_connect_result = mock.Mock(name='cf_connect')
@@ -75,3 +101,19 @@ def test_get_TXT_record(self):
         r = r53.R53(self.env.aws_profile)
         x = r.get_record('dsd.io', 'ASDAKSLDK', 'blah', 'TXT')
         self.assertEquals(x, 'lollol')
+
+    def test_hastag(self):
+        r53_mock = mock.Mock()
+        r53_connect_result = mock.Mock(name='cf_connect')
+        r53_mock.return_value = r53_connect_result
+
+        m = mock.Mock(resource_records=['"lollol"'])
+        m.name = 'recordname.dsd.io.'
+        m.type = 'TXT'
+        response = [m]
+        mock_config = {'get_all_rrsets.return_value': response}
+        r53_connect_result.configure_mock(**mock_config)
+        boto.route53.connect_to_region = r53_mock
+        r = r53.R53(self.env.aws_profile)
+        x = r.get_record("dsd.io", "ASDAKSLDK", "recordname", 'TXT')
+        self.assertTrue(x)