Added method to OpenStackHeatStack to return OpenStackRouter objects.

Continuation of the story SNAPS-153 for adding creator/state machine
instances for OpenStack objects deployed via Heat.

JIRA: SNAPS-173

Change-Id: Iac9138ef7827c10db1637447d3a909e714a0301b
Signed-off-by: spisarski <s.pisarski@cablelabs.com>

4 files changed, 220 insertions, 86 deletions

diff --git a/snaps/openstack/tests/create_network_tests.py b/snaps/openstack/tests/create_network_tests.py
index 9cee130..49ad6ab 100644
--- a/snaps/openstack/tests/create_network_tests.py
+++ b/snaps/openstack/tests/create_network_tests.py
@@ -248,7 +248,6 @@ class PortSettingsUnitTests(unittest.TestCase):
         self.assertIsNone(settings.project_name)
         self.assertIsNone(settings.mac_address)
         self.assertIsNone(settings.ip_addrs)
-        self.assertIsNone(settings.fixed_ips)
         self.assertIsNone(settings.security_groups)
         self.assertIsNone(settings.allowed_address_pairs)
         self.assertIsNone(settings.opt_value)
@@ -264,7 +263,6 @@ class PortSettingsUnitTests(unittest.TestCase):
         self.assertIsNone(settings.project_name)
         self.assertIsNone(settings.mac_address)
         self.assertIsNone(settings.ip_addrs)
-        self.assertIsNone(settings.fixed_ips)
         self.assertIsNone(settings.security_groups)
         self.assertIsNone(settings.allowed_address_pairs)
         self.assertIsNone(settings.opt_value)
@@ -274,14 +272,12 @@ class PortSettingsUnitTests(unittest.TestCase):
 
     def test_all(self):
         ip_addrs = [{'subnet_name', 'foo-sub', 'ip', '10.0.0.10'}]
-        fixed_ips = {'sub_id', '10.0.0.10'}
         allowed_address_pairs = {'10.0.0.101', '1234.5678'}
 
         settings = PortSettings(name='foo', network_name='bar',
                                 admin_state_up=False,
                                 project_name='foo-project',
                                 mac_address='1234', ip_addrs=ip_addrs,
-                                fixed_ips=fixed_ips,
                                 security_groups=['foo_grp_id'],
                                 allowed_address_pairs=allowed_address_pairs,
                                 opt_value='opt value', opt_name='opt name',
@@ -293,7 +289,6 @@ class PortSettingsUnitTests(unittest.TestCase):
         self.assertEqual('foo-project', settings.project_name)
         self.assertEqual('1234', settings.mac_address)
         self.assertEqual(ip_addrs, settings.ip_addrs)
-        self.assertEqual(fixed_ips, settings.fixed_ips)
         self.assertEqual(1, len(settings.security_groups))
         self.assertEqual('foo_grp_id', settings.security_groups[0])
         self.assertEqual(allowed_address_pairs, settings.allowed_address_pairs)
@@ -304,25 +299,21 @@ class PortSettingsUnitTests(unittest.TestCase):
 
     def test_config_all(self):
         ip_addrs = [{'subnet_name', 'foo-sub', 'ip', '10.0.0.10'}]
-        fixed_ips = {'sub_id', '10.0.0.10'}
         allowed_address_pairs = {'10.0.0.101', '1234.5678'}
 
         settings = PortSettings(
             **{'name': 'foo', 'network_name': 'bar', 'admin_state_up': False,
                'project_name': 'foo-project', 'mac_address': '1234',
-               'ip_addrs': ip_addrs,
-               'fixed_ips': fixed_ips, 'security_groups': ['foo_grp_id'],
+               'ip_addrs': ip_addrs, 'security_groups': ['foo_grp_id'],
                'allowed_address_pairs': allowed_address_pairs,
-               'opt_value': 'opt value',
-               'opt_name': 'opt name', 'device_owner': 'owner',
-               'device_id': 'device number'})
+               'opt_value': 'opt value', 'opt_name': 'opt name',
+               'device_owner': 'owner', 'device_id': 'device number'})
         self.assertEqual('foo', settings.name)
         self.assertEqual('bar', settings.network_name)
         self.assertFalse(settings.admin_state_up)
         self.assertEqual('foo-project', settings.project_name)
         self.assertEqual('1234', settings.mac_address)
         self.assertEqual(ip_addrs, settings.ip_addrs)
-        self.assertEqual(fixed_ips, settings.fixed_ips)
         self.assertEqual(1, len(settings.security_groups))
         self.assertEqual('foo_grp_id', settings.security_groups[0])
         self.assertEqual(allowed_address_pairs, settings.allowed_address_pairs)
diff --git a/snaps/openstack/tests/create_router_tests.py b/snaps/openstack/tests/create_router_tests.py
index db3170e..d0f0a9f 100644
--- a/snaps/openstack/tests/create_router_tests.py
+++ b/snaps/openstack/tests/create_router_tests.py
@@ -23,7 +23,7 @@ from snaps.openstack.create_network import OpenStackNetwork
 from snaps.openstack.create_router import (
     RouterSettings, RouterSettingsError)
 from snaps.openstack.tests.os_source_file_test import OSIntegrationTestCase
-from snaps.openstack.utils import neutron_utils
+from snaps.openstack.utils import neutron_utils, settings_utils
 
 __author__ = 'mmakati'
 
@@ -51,9 +51,8 @@ class RouterSettingsUnitTests(unittest.TestCase):
         self.assertEqual('foo', settings.name)
         self.assertIsNone(settings.project_name)
         self.assertIsNone(settings.external_gateway)
-        self.assertIsNone(settings.admin_state_up)
+        self.assertTrue(settings.admin_state_up)
         self.assertIsNone(settings.enable_snat)
-        self.assertIsNone(settings.external_fixed_ips)
         self.assertIsNotNone(settings.internal_subnets)
         self.assertTrue(isinstance(settings.internal_subnets, list))
         self.assertEqual(0, len(settings.internal_subnets))
@@ -66,9 +65,8 @@ class RouterSettingsUnitTests(unittest.TestCase):
         self.assertEqual('foo', settings.name)
         self.assertIsNone(settings.project_name)
         self.assertIsNone(settings.external_gateway)
-        self.assertIsNone(settings.admin_state_up)
+        self.assertTrue(settings.admin_state_up)
         self.assertIsNone(settings.enable_snat)
-        self.assertIsNone(settings.external_fixed_ips)
         self.assertIsNotNone(settings.internal_subnets)
         self.assertTrue(isinstance(settings.internal_subnets, list))
         self.assertEqual(0, len(settings.internal_subnets))
@@ -80,14 +78,13 @@ class RouterSettingsUnitTests(unittest.TestCase):
         port_settings = PortSettings(name='foo', network_name='bar')
         settings = RouterSettings(
             name='foo', project_name='bar', external_gateway='foo_gateway',
-            admin_state_up=True, enable_snat=False, external_fixed_ips=['ip1'],
+            admin_state_up=True, enable_snat=False,
             internal_subnets=['10.0.0.1/24'], interfaces=[port_settings])
         self.assertEqual('foo', settings.name)
         self.assertEqual('bar', settings.project_name)
         self.assertEqual('foo_gateway', settings.external_gateway)
         self.assertTrue(settings.admin_state_up)
         self.assertFalse(settings.enable_snat)
-        self.assertEqual(['ip1'], settings.external_fixed_ips)
         self.assertIsNotNone(settings.internal_subnets)
         self.assertTrue(isinstance(settings.internal_subnets, list))
         self.assertEqual(1, len(settings.internal_subnets))
@@ -98,8 +95,7 @@ class RouterSettingsUnitTests(unittest.TestCase):
         settings = RouterSettings(
             **{'name': 'foo', 'project_name': 'bar',
                'external_gateway': 'foo_gateway', 'admin_state_up': True,
-               'enable_snat': False, 'external_fixed_ips': ['ip1'],
-               'internal_subnets': ['10.0.0.1/24'],
+               'enable_snat': False, 'internal_subnets': ['10.0.0.1/24'],
                'interfaces':
                    [{'port': {'name': 'foo-port',
                               'network_name': 'bar-net'}}]})
@@ -108,7 +104,6 @@ class RouterSettingsUnitTests(unittest.TestCase):
         self.assertEqual('foo_gateway', settings.external_gateway)
         self.assertTrue(settings.admin_state_up)
         self.assertFalse(settings.enable_snat)
-        self.assertEqual(['ip1'], settings.external_fixed_ips)
         self.assertIsNotNone(settings.internal_subnets)
         self.assertTrue(isinstance(settings.internal_subnets, list))
         self.assertEqual(1, len(settings.internal_subnets))
@@ -166,8 +161,9 @@ class CreateRouterSuccessTests(OSIntegrationTestCase):
                                           router_settings=router_settings)
         self.assertIsNotNone(router)
 
-        self.assertTrue(verify_router_attributes(
-            router, self.router_creator, ext_gateway=self.ext_net_name))
+        self.assertEqual(self.router_creator.get_router(), router)
+
+        self.check_router_recreation(router, router_settings)
 
     def test_create_router_admin_user_to_new_project(self):
         """
@@ -186,8 +182,9 @@ class CreateRouterSuccessTests(OSIntegrationTestCase):
                                           router_settings=router_settings)
         self.assertIsNotNone(router)
 
-        self.assertTrue(verify_router_attributes(
-            router, self.router_creator, ext_gateway=self.ext_net_name))
+        self.assertEqual(self.router_creator.get_router(), router)
+
+        self.check_router_recreation(router, router_settings)
 
     def test_create_router_new_user_to_admin_project(self):
         """
@@ -206,8 +203,9 @@ class CreateRouterSuccessTests(OSIntegrationTestCase):
                                           router_settings=router_settings)
         self.assertIsNotNone(router)
 
-        self.assertTrue(verify_router_attributes(
-            router, self.router_creator, ext_gateway=self.ext_net_name))
+        self.assertEqual(self.router_creator.get_router(), router)
+
+        self.check_router_recreation(router, router_settings)
 
     def test_create_delete_router(self):
         """
@@ -249,26 +247,28 @@ class CreateRouterSuccessTests(OSIntegrationTestCase):
                                           router_settings=router_settings)
         self.assertIsNotNone(router)
 
-        self.assertTrue(verify_router_attributes(router, self.router_creator,
-                                                 admin_state=False))
+        self.assertEqual(self.router_creator.get_router(), router)
+
+        self.check_router_recreation(router, router_settings)
 
     def test_create_router_admin_state_True(self):
         """
         Test creation of a basic router with admin state Up.
         """
-        router_settings = RouterSettings(name=self.guid + '-pub-router',
-                                         admin_state_up=True)
+        router_settings = RouterSettings(
+            name=self.guid + '-pub-router', admin_state_up=True)
 
-        self.router_creator = create_router.OpenStackRouter(self.os_creds,
-                                                            router_settings)
+        self.router_creator = create_router.OpenStackRouter(
+            self.os_creds, router_settings)
         self.router_creator.create()
 
-        router = neutron_utils.get_router(self.neutron,
-                                          router_settings=router_settings)
+        router = neutron_utils.get_router(
+            self.neutron, router_settings=router_settings)
         self.assertIsNotNone(router)
 
-        self.assertTrue(verify_router_attributes(router, self.router_creator,
-                                                 admin_state=True))
+        self.assertEqual(self.router_creator.get_router(), router)
+
+        self.check_router_recreation(router, router_settings)
 
     def test_create_router_private_network(self):
         """
@@ -321,10 +321,10 @@ class CreateRouterSuccessTests(OSIntegrationTestCase):
                                                             router_settings)
         self.router_creator.create()
 
-        router = neutron_utils.get_router(self.neutron,
-                                          router_settings=router_settings)
+        router = neutron_utils.get_router(
+            self.neutron, router_settings=router_settings)
 
-        self.assertTrue(verify_router_attributes(router, self.router_creator))
+        self.assertEqual(router, self.router_creator.get_router())
 
         # Instantiate second identical creator to ensure a second router
         # has not been created
@@ -333,6 +333,8 @@ class CreateRouterSuccessTests(OSIntegrationTestCase):
         router2 = router_creator2.create()
         self.assertIsNotNone(self.router_creator.get_router(), router2)
 
+        self.check_router_recreation(router2, router_settings)
+
     def test_create_router_external_network(self):
         """
         Test creation of a router connected to an external network and a
@@ -360,15 +362,52 @@ class CreateRouterSuccessTests(OSIntegrationTestCase):
         router_settings = RouterSettings(
             name=self.guid + '-pub-router', external_gateway=self.ext_net_name,
             port_settings=port_settings)
-        self.router_creator = create_router.OpenStackRouter(self.os_creds,
-                                                            router_settings)
+        self.router_creator = create_router.OpenStackRouter(
+            self.os_creds, router_settings)
         self.router_creator.create()
 
-        router = neutron_utils.get_router(self.neutron,
-                                          router_settings=router_settings)
+        router = neutron_utils.get_router(
+            self.neutron, router_settings=router_settings)
+
+        self.assertEquals(router, self.router_creator.get_router())
 
-        self.assertTrue(verify_router_attributes(
-            router, self.router_creator, ext_gateway=self.ext_net_name))
+        self.check_router_recreation(router, router_settings)
+
+    def check_router_recreation(self, router, orig_settings):
+        """
+        Validates the derived RouterSettings with the original
+        :param router: the Router domain object to test
+        :param orig_settings: the original RouterSettings object that was
+                              responsible for creating the router
+        :return: the derived RouterSettings object
+        """
+        derived_settings = settings_utils.create_router_settings(
+            self.neutron, router)
+        self.assertIsNotNone(derived_settings)
+        self.assertEqual(
+            orig_settings.enable_snat, derived_settings.enable_snat)
+        self.assertEqual(orig_settings.external_gateway,
+                         derived_settings.external_gateway)
+        self.assertEqual(orig_settings.name, derived_settings.name)
+        self.assertEqual(orig_settings.internal_subnets,
+                         derived_settings.internal_subnets)
+
+        if orig_settings.external_gateway:
+            self.assertEqual(len(orig_settings.port_settings),
+                             len(derived_settings.port_settings))
+        else:
+            self.assertEqual(len(orig_settings.port_settings),
+                             len(derived_settings.port_settings))
+
+        if len(orig_settings.port_settings) > 0:
+            self.assertEqual(orig_settings.port_settings[0].name,
+                             derived_settings.port_settings[0].name)
+
+        if len(orig_settings.port_settings) > 1:
+            self.assertEqual(orig_settings.port_settings[1].name,
+                             derived_settings.port_settings[1].name)
+
+        return derived_settings
 
 
 class CreateRouterNegativeTests(OSIntegrationTestCase):
@@ -415,42 +454,3 @@ class CreateRouterNegativeTests(OSIntegrationTestCase):
             self.router_creator = create_router.OpenStackRouter(
                 self.os_creds, router_settings)
             self.router_creator.create()
-
-
-def verify_router_attributes(router_operational, router_creator,
-                             admin_state=True, ext_gateway=None):
-    """
-    Helper function to validate the attributes of router created with the one
-    operational
-    :param router_operational: Operational Router object returned from neutron
-                               utils of type snaps.domain.Router
-    :param router_creator: router_creator object returned from creating a
-                           router in the router test functions
-    :param admin_state: True if router is expected to be Up, else False
-    :param ext_gateway: None if router is not connected to external gateway
-    :return:
-    """
-
-    router = router_creator.get_router()
-
-    if not router_operational:
-        return False
-    elif not router_creator:
-        return False
-    elif not (router_operational.name == router_creator.router_settings.name):
-        return False
-    elif not (router_operational.id == router.id):
-        return False
-    elif not (router_operational.status == router.status):
-        return False
-    elif not (router_operational.tenant_id == router.tenant_id):
-        return False
-    elif not (admin_state == router_operational.admin_state_up):
-        return False
-    elif (ext_gateway is None) and \
-            (router_operational.external_gateway_info is not None):
-        return False
-    elif ext_gateway is not None:
-        if router_operational.external_gateway_info is None:
-            return False
-    return True
diff --git a/snaps/openstack/tests/create_stack_tests.py b/snaps/openstack/tests/create_stack_tests.py
index 94085a0..daf114b 100644
--- a/snaps/openstack/tests/create_stack_tests.py
+++ b/snaps/openstack/tests/create_stack_tests.py
@@ -493,6 +493,80 @@ class CreateStackFloatingIpTests(OSIntegrationTestCase):
                 self.assertEqual(0, len(vm_settings.floating_ip_settings))
 
 
+class CreateStackRouterTests(OSIntegrationTestCase):
+    """
+    Tests for the CreateStack class defined in create_stack.py where the
+    target is a Network, Subnet, and Router
+    """
+
+    def setUp(self):
+        """
+        Instantiates the CreateStack object that is responsible for downloading
+        and creating an OS stack file within OpenStack
+        """
+        super(self.__class__, self).__start__()
+
+        self.guid = self.__class__.__name__ + '-' + str(uuid.uuid4())
+
+        self.heat_creds = self.admin_os_creds
+        self.heat_creds.project_name = self.admin_os_creds.project_name
+
+        self.heat_cli = heat_utils.heat_client(self.heat_creds)
+        self.neutron = neutron_utils.neutron_client(self.os_creds)
+        self.stack_creator = None
+
+        self.net_name = self.guid + '-net'
+        self.subnet_name = self.guid + '-subnet'
+        self.router_name = self.guid + '-router'
+
+        self.env_values = {
+            'net_name': self.net_name,
+            'subnet_name': self.subnet_name,
+            'router_name': self.router_name,
+            'external_net_name': self.ext_net_name}
+
+        self.heat_tmplt_path = pkg_resources.resource_filename(
+            'snaps.openstack.tests.heat', 'router_heat_template.yaml')
+
+        stack_settings = StackSettings(
+            name=self.__class__.__name__ + '-' + str(self.guid) + '-stack',
+            template_path=self.heat_tmplt_path,
+            env_values=self.env_values)
+        self.stack_creator = create_stack.OpenStackHeatStack(
+            self.heat_creds, stack_settings)
+        self.created_stack = self.stack_creator.create()
+        self.assertIsNotNone(self.created_stack)
+
+    def tearDown(self):
+        """
+        Cleans the stack and downloaded stack file
+        """
+        if self.stack_creator:
+            try:
+                self.stack_creator.clean()
+            except:
+                pass
+
+        super(self.__class__, self).__clean__()
+
+    def test_retrieve_router_creator(self):
+        """
+        Tests the creation of an OpenStack stack from Heat template file and
+        the retrieval of an OpenStackRouter creator/state machine instance
+        """
+        router_creators = self.stack_creator.get_router_creators()
+        self.assertEqual(1, len(router_creators))
+
+        creator = router_creators[0]
+        self.assertEqual(self.router_name, creator.router_settings.name)
+
+        router = creator.get_router()
+
+        ext_net = neutron_utils.get_network(
+            self.neutron, network_name=self.ext_net_name)
+        self.assertEqual(ext_net.id, router.external_network_id)
+
+
 class CreateStackVolumeTests(OSIntegrationTestCase):
     """
     Tests for the CreateStack class as they pertain to volumes
diff --git a/snaps/openstack/tests/heat/router_heat_template.yaml b/snaps/openstack/tests/heat/router_heat_template.yaml
new file mode 100644
index 0000000..ee7f60c
--- /dev/null
+++ b/snaps/openstack/tests/heat/router_heat_template.yaml
@@ -0,0 +1,69 @@
+##############################################################################
+# Copyright (c) 2017 Cable Television Laboratories, Inc. ("CableLabs")
+#                    and others.  All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at:
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+##############################################################################
+heat_template_version: 2015-04-30
+
+description: >
+  Sample template with two VMs instantiated against different images and
+  flavors on the same network and the first one has a floating IP
+
+parameters:
+  net_name:
+    type: string
+    label: Test network name
+    description: The name of the stack's network
+    default: test_net
+  subnet_name:
+    type: string
+    label: Test subnet name
+    description: The name of the stack's subnet
+    default: test_subnet
+  router_name:
+    type: string
+    label: Test router name
+    description: The name of the stack's router
+    default: mgmt_router
+  external_net_name:
+    type: string
+    description: Name of the external network which management network will connect to
+    default: external
+
+resources:
+  network:
+    type: OS::Neutron::Net
+    properties:
+      name: { get_param: net_name }
+
+  subnet:
+    type: OS::Neutron::Subnet
+    properties:
+      name: { get_param: subnet_name }
+      ip_version: 4
+      cidr: 10.1.2.0/24
+      network: { get_resource: network }
+
+  management_router:
+    type: OS::Neutron::Router
+    properties:
+      name: { get_param: router_name }
+      external_gateway_info:
+        network: { get_param: external_net_name }
+
+  management_router_interface:
+    type: OS::Neutron::RouterInterface
+    properties:
+      router: { get_resource: management_router }
+      subnet: { get_resource: subnet }