cloudstack-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From sanj...@apache.org
Subject git commit: updated refs/heads/4.5 to 2ed76b2
Date Tue, 13 Jan 2015 11:13:37 GMT
Repository: cloudstack
Updated Branches:
  refs/heads/4.5 17e192243 -> 2ed76b2a5


CLOUDSTACK-8143: Corrected a test in BVT test_routers.py


Project: http://git-wip-us.apache.org/repos/asf/cloudstack/repo
Commit: http://git-wip-us.apache.org/repos/asf/cloudstack/commit/2ed76b2a
Tree: http://git-wip-us.apache.org/repos/asf/cloudstack/tree/2ed76b2a
Diff: http://git-wip-us.apache.org/repos/asf/cloudstack/diff/2ed76b2a

Branch: refs/heads/4.5
Commit: 2ed76b2a55f843053e51d243a1545e92307a0012
Parents: 17e1922
Author: Ashutosh K <ashutosh@clogeny.com>
Authored: Tue Jan 6 12:54:49 2015 +0530
Committer: sanjeev <sanjeev@apache.org>
Committed: Tue Jan 13 16:43:01 2015 +0530

----------------------------------------------------------------------
 test/integration/smoke/test_routers.py | 827 ++++++++++++++--------------
 1 file changed, 427 insertions(+), 400 deletions(-)
----------------------------------------------------------------------


http://git-wip-us.apache.org/repos/asf/cloudstack/blob/2ed76b2a/test/integration/smoke/test_routers.py
----------------------------------------------------------------------
diff --git a/test/integration/smoke/test_routers.py b/test/integration/smoke/test_routers.py
index 7d5f267..7940d12 100644
--- a/test/integration/smoke/test_routers.py
+++ b/test/integration/smoke/test_routers.py
@@ -16,22 +16,35 @@
 # under the License.
 """ BVT tests for routers
 """
-#Import Local Modules
-import marvin
+# Import Local Modules
 from marvin.codes import FAILED
-from marvin.cloudstackTestCase import *
-from marvin.cloudstackAPI import *
-from marvin.sshClient import SshClient
-from marvin.lib.utils import *
-from marvin.lib.base import *
-from marvin.lib.common import *
+from marvin.cloudstackTestCase import cloudstackTestCase
+from marvin.cloudstackAPI import (stopRouter,
+                                  restartNetwork,
+                                  startRouter,
+                                  rebootRouter)
+from marvin.lib.utils import (cleanup_resources,
+                              get_process_status,
+                              get_host_credentials)
+from marvin.lib.base import (Account,
+                             ServiceOffering,
+                             VirtualMachine)
+from marvin.lib.common import (get_domain,
+                               get_zone,
+                               get_template,
+                               list_hosts,
+                               list_routers,
+                               list_networks,
+                               list_zones,
+                               list_vlan_ipranges)
 from nose.plugins.attrib import attr
-#Import System modules
+# Import System modules
 import time
 
 
 _multiprocess_shared_ = True
 
+
 class TestRouterServices(cloudstackTestCase):
 
     @classmethod
@@ -46,47 +59,50 @@ class TestRouterServices(cloudstackTestCase):
         cls.zone = get_zone(cls.apiclient, testClient.getZoneForTests())
         cls.services['mode'] = cls.zone.networktype
         template = get_template(
-                            cls.apiclient,
-                            cls.zone.id,
-                            cls.services["ostype"]
-                            )
+            cls.apiclient,
+            cls.zone.id,
+            cls.services["ostype"]
+        )
         if template == FAILED:
-            cls.fail("get_template() failed to return template with description %s" % cls.services["ostype"])
+            cls.fail(
+                "get_template() failed to return template\
+                        with description %s" %
+                cls.services["ostype"])
 
         cls.services["virtual_machine"]["zoneid"] = cls.zone.id
 
-        #Create an account, network, VM and IP addresses
+        # Create an account, network, VM and IP addresses
         cls.account = Account.create(
-                                     cls.apiclient,
-                                     cls.services["account"],
-                                     domainid=cls.domain.id
-                                     )
+            cls.apiclient,
+            cls.services["account"],
+            domainid=cls.domain.id
+        )
         cls.service_offering = ServiceOffering.create(
-                                            cls.apiclient,
-                                            cls.services["service_offerings"]
-                                            )
+            cls.apiclient,
+            cls.services["service_offerings"]
+        )
         cls.vm_1 = VirtualMachine.create(
-                                    cls.apiclient,
-                                    cls.services["virtual_machine"],
-                                    templateid=template.id,
-                                    accountid=cls.account.name,
-                                    domainid=cls.account.domainid,
-                                    serviceofferingid=cls.service_offering.id
-                                    )
+            cls.apiclient,
+            cls.services["virtual_machine"],
+            templateid=template.id,
+            accountid=cls.account.name,
+            domainid=cls.account.domainid,
+            serviceofferingid=cls.service_offering.id
+        )
         cls.cleanup = [
-                       cls.account,
-                       cls.service_offering
-                       ]
+            cls.account,
+            cls.service_offering
+        ]
         return
 
     @classmethod
     def tearDownClass(cls):
         try:
             cls.apiclient = super(
-                                   TestRouterServices,
-                                   cls
-                                   ).getClsTestClient().getApiClient()
-            #Clean up, terminate the created templates
+                TestRouterServices,
+                cls
+            ).getClsTestClient().getApiClient()
+            # Clean up, terminate the created templates
             cleanup_resources(cls.apiclient, cls.cleanup)
 
         except Exception as e:
@@ -98,7 +114,7 @@ class TestRouterServices(cloudstackTestCase):
         self.hypervisor = self.testClient.getHypervisorInfo()
         return
 
-    @attr(tags = ["advanced", "basic", "sg", "smoke"], required_hardware="true")
+    @attr(tags=["advanced", "basic", "sg", "smoke"], required_hardware="true")
     def test_01_router_internal_basic(self):
         """Test router internal basic zone
         """
@@ -120,58 +136,61 @@ class TestRouterServices(cloudstackTestCase):
                 domainid=self.account.domainid
             )
         self.assertEqual(
-                            isinstance(list_router_response, list),
-                            True,
-                            "Check list response returns a valid list"
-                        )
+            isinstance(list_router_response, list),
+            True,
+            "Check list response returns a valid list"
+        )
         router = list_router_response[0]
 
         hosts = list_hosts(
-                           self.apiclient,
-                           zoneid=router.zoneid,
-                           type='Routing',
-                           state='Up',
-                           id=router.hostid
-                           )
+            self.apiclient,
+            zoneid=router.zoneid,
+            type='Routing',
+            state='Up',
+            id=router.hostid
+        )
         self.assertEqual(
-                            isinstance(hosts, list),
-                            True,
-                            "Check list host returns a valid list"
-                        )
+            isinstance(hosts, list),
+            True,
+            "Check list host returns a valid list"
+        )
         host = hosts[0]
 
         self.debug("Router ID: %s, state: %s" % (router.id, router.state))
 
         self.assertEqual(
-                            router.state,
-                            'Running',
-                            "Check list router response for router state"
-                        )
+            router.state,
+            'Running',
+            "Check list router response for router state"
+        )
 
         if self.hypervisor.lower() in ('vmware', 'hyperv'):
-               result = get_process_status(
-                                   self.apiclient.connection.mgtSvr,
-                                   22,
-                               self.apiclient.connection.user,
-                               self.apiclient.connection.passwd,
-                               router.linklocalip,
-                               "service dnsmasq status",
-                                   hypervisor=self.hypervisor
-                               )
+            result = get_process_status(
+                self.apiclient.connection.mgtSvr,
+                22,
+                self.apiclient.connection.user,
+                self.apiclient.connection.passwd,
+                router.linklocalip,
+                "service dnsmasq status",
+                hypervisor=self.hypervisor
+            )
         else:
             try:
-                host.user, host.passwd = get_host_credentials(self.config, host.ipaddress)
+                host.user, host.passwd = get_host_credentials(
+                    self.config, host.ipaddress)
                 result = get_process_status(
-                                    host.ipaddress,
-                                    22,
-                                    host.user,
-                                    host.passwd,
-                                    router.linklocalip,
-                                    "service dnsmasq status"
-                                    )
+                    host.ipaddress,
+                    22,
+                    host.user,
+                    host.passwd,
+                    router.linklocalip,
+                    "service dnsmasq status"
+                )
 
             except KeyError:
-                self.skipTest("Marvin configuration has no host credentials to check router
services")
+                self.skipTest(
+                    "Marvin configuration has no host credentials to\
+                            check router services")
         res = str(result)
         self.debug("Dnsmasq process status: %s" % res)
 
@@ -182,9 +201,7 @@ class TestRouterServices(cloudstackTestCase):
         )
         return
 
-
-
-    @attr(tags = ["advanced", "advancedns"], required_hardware="false")
+    @attr(tags=["advanced", "advancedns"], required_hardware="false")
     def test_02_router_internal_adv(self):
         """Test router internal advanced zone
         """
@@ -195,140 +212,145 @@ class TestRouterServices(cloudstackTestCase):
 
         # Find router associated with user account
         list_router_response = list_routers(
-                                    self.apiclient,
-                                    account=self.account.name,
-                                    domainid=self.account.domainid
-                                    )
+            self.apiclient,
+            account=self.account.name,
+            domainid=self.account.domainid
+        )
         self.assertEqual(
-                            isinstance(list_router_response, list),
-                            True,
-                            "Check list response returns a valid list"
-                        )
+            isinstance(list_router_response, list),
+            True,
+            "Check list response returns a valid list"
+        )
         router = list_router_response[0]
 
         hosts = list_hosts(
-                           self.apiclient,
-                           zoneid=router.zoneid,
-                           type='Routing',
-                           state='Up',
-                           id=router.hostid
-                           )
+            self.apiclient,
+            zoneid=router.zoneid,
+            type='Routing',
+            state='Up',
+            id=router.hostid
+        )
         self.assertEqual(
-                            isinstance(hosts, list),
-                            True,
-                            "Check list response returns a valid list"
-                        )
+            isinstance(hosts, list),
+            True,
+            "Check list response returns a valid list"
+        )
         host = hosts[0]
 
         self.debug("Router ID: %s, state: %s" % (router.id, router.state))
         self.assertEqual(
-                            router.state,
-                            'Running',
-                            "Check list router response for router state"
-                        )
+            router.state,
+            'Running',
+            "Check list router response for router state"
+        )
 
         if self.hypervisor.lower() in ('vmware', 'hyperv'):
-           result = get_process_status(
-                           self.apiclient.connection.mgtSvr,
-                               22,
-                           self.apiclient.connection.user,
-                           self.apiclient.connection.passwd,
-                           router.linklocalip,
-                           "service dnsmasq status",
-                               hypervisor=self.hypervisor
-                           )
+            result = get_process_status(
+                self.apiclient.connection.mgtSvr,
+                22,
+                self.apiclient.connection.user,
+                self.apiclient.connection.passwd,
+                router.linklocalip,
+                "service dnsmasq status",
+                hypervisor=self.hypervisor
+            )
         else:
             try:
-                host.user, host.passwd = get_host_credentials(self.config, host.ipaddress)
+                host.user, host.passwd = get_host_credentials(
+                    self.config, host.ipaddress)
                 result = get_process_status(
-                                    host.ipaddress,
-                                    22,
-                                    host.user,
-                                    host.passwd,
-                                    router.linklocalip,
-                                    "service dnsmasq status"
-                                    )
+                    host.ipaddress,
+                    22,
+                    host.user,
+                    host.passwd,
+                    router.linklocalip,
+                    "service dnsmasq status"
+                )
             except KeyError:
-                self.skipTest("Marvin configuration has no host credentials to check router
services")
+                self.skipTest(
+                    "Marvin configuration has no host credentials\
+                            to check router services")
         res = str(result)
         self.debug("Dnsmasq process status: %s" % res)
         self.assertEqual(
-                            res.count("running"),
-                            1,
-                            "Check dnsmasq service is running or not"
-                        )
+            res.count("running"),
+            1,
+            "Check dnsmasq service is running or not"
+        )
 
         if self.hypervisor.lower() in ('vmware', 'hyperv'):
-           result = get_process_status(
-                               self.apiclient.connection.mgtSvr,
-                           22,
-                           self.apiclient.connection.user,
-                           self.apiclient.connection.passwd,
-                           router.linklocalip,
-                           "service haproxy status",
-                           hypervisor=self.hypervisor
-                           )
+            result = get_process_status(
+                self.apiclient.connection.mgtSvr,
+                22,
+                self.apiclient.connection.user,
+                self.apiclient.connection.passwd,
+                router.linklocalip,
+                "service haproxy status",
+                hypervisor=self.hypervisor
+            )
         else:
             try:
-                host.user, host.passwd = get_host_credentials(self.config, host.ipaddress)
+                host.user, host.passwd = get_host_credentials(
+                    self.config, host.ipaddress)
                 result = get_process_status(
-                                    host.ipaddress,
-                                    22,
-                                    host.user,
-                                    host.passwd,
-                                    router.linklocalip,
-                                    "service haproxy status"
-                                    )
+                    host.ipaddress,
+                    22,
+                    host.user,
+                    host.passwd,
+                    router.linklocalip,
+                    "service haproxy status"
+                )
             except KeyError:
-                self.skipTest("Marvin configuration has no host credentials to check router
services")
+                self.skipTest(
+                    "Marvin configuration has no host credentials\
+                            to check router services")
         res = str(result)
         self.assertEqual(
-                            res.count("running"),
-                            1,
-                            "Check haproxy service is running or not"
-                        )
+            res.count("running"),
+            1,
+            "Check haproxy service is running or not"
+        )
         self.debug("Haproxy process status: %s" % res)
         return
 
-    @attr(tags = ["advanced", "advancedns", "smoke"], required_hardware="false")
+    @attr(tags=["advanced", "advancedns", "smoke"], required_hardware="false")
     def test_03_restart_network_cleanup(self):
         """Test restart network
         """
 
         # Validate the following
         # 1. When cleanup = true, router is destroyed and a new one created
-        # 2. New router will have new publicIp and linkLocalIp and
-        #    all it's services should resume
+        # 2. New router should have the same public IP
 
         # Find router associated with user account
         list_router_response = list_routers(
-                                    self.apiclient,
-                                    account=self.account.name,
-                                    domainid=self.account.domainid
-                                    )
+            self.apiclient,
+            account=self.account.name,
+            domainid=self.account.domainid
+        )
         self.assertEqual(
-                            isinstance(list_router_response, list),
-                            True,
-                            "Check list response returns a valid list"
-                        )
+            isinstance(list_router_response, list),
+            True,
+            "Check list response returns a valid list"
+        )
         router = list_router_response[0]
 
-        #Store old values before restart
-        old_linklocalip = router.linklocalip
+        # Store old values before restart
+        old_publicip = router.publicip
 
         timeout = 10
         # Network should be in Implemented or Setup stage before restart
         while True:
             networks = list_networks(
-                                 self.apiclient,
-                                 account=self.account.name,
-                                 domainid=self.account.domainid
-                                 )
+                self.apiclient,
+                account=self.account.name,
+                domainid=self.account.domainid
+            )
             self.assertEqual(
-                            isinstance(networks, list),
-                            True,
-                            "Check list response returns a valid list"
-                        )
+                isinstance(networks, list),
+                True,
+                "Check list response returns a valid list"
+            )
             network = networks[0]
             if network.state in ["Implemented", "Setup"]:
                 break
@@ -340,9 +362,9 @@ class TestRouterServices(cloudstackTestCase):
 
         self.debug(
             "Restarting network with ID: %s, Network state: %s" % (
-                                                                network.id,
-                                                                network.state
-                                                                ))
+                network.id,
+                network.state
+            ))
         cmd = restartNetwork.restartNetworkCmd()
         cmd.id = network.id
         cmd.cleanup = True
@@ -350,25 +372,25 @@ class TestRouterServices(cloudstackTestCase):
 
         # Get router details after restart
         list_router_response = list_routers(
-                                    self.apiclient,
-                                    account=self.account.name,
-                                    domainid=self.account.domainid
-                                    )
+            self.apiclient,
+            account=self.account.name,
+            domainid=self.account.domainid
+        )
         self.assertEqual(
-                            isinstance(list_router_response, list),
-                            True,
-                            "Check list response returns a valid list"
-                        )
+            isinstance(list_router_response, list),
+            True,
+            "Check list response returns a valid list"
+        )
         router = list_router_response[0]
 
-        self.assertNotEqual(
-                            router.linklocalip,
-                            old_linklocalip,
-                            "Check link-local IP after restart"
-                        )
+        self.assertEqual(
+            router.publicip,
+            old_publicip,
+            "Public IP of the router should remain same after network restart"
+        )
         return
 
-    @attr(tags = ["advanced", "advancedns", "smoke"], required_hardware="true")
+    @attr(tags=["advanced", "advancedns", "smoke"], required_hardware="true")
     def test_04_restart_network_wo_cleanup(self):
         """Test restart network without cleanup
         """
@@ -382,15 +404,15 @@ class TestRouterServices(cloudstackTestCase):
         # Network should be in Implemented or Setup stage before restart
         while True:
             networks = list_networks(
-                                 self.apiclient,
-                                 account=self.account.name,
-                                 domainid=self.account.domainid
-                                 )
+                self.apiclient,
+                account=self.account.name,
+                domainid=self.account.domainid
+            )
             self.assertEqual(
-                            isinstance(networks, list),
-                            True,
-                            "Check list response returns a valid list"
-                        )
+                isinstance(networks, list),
+                True,
+                "Check list response returns a valid list"
+            )
             network = networks[0]
             if network.state in ["Implemented", "Setup"]:
                 break
@@ -402,9 +424,9 @@ class TestRouterServices(cloudstackTestCase):
 
         self.debug(
             "Restarting network with ID: %s, Network state: %s" % (
-                                                                network.id,
-                                                                network.state
-                                                                ))
+                network.id,
+                network.state
+            ))
         cmd = restartNetwork.restartNetworkCmd()
         cmd.id = network.id
         cmd.cleanup = False
@@ -412,78 +434,81 @@ class TestRouterServices(cloudstackTestCase):
 
         # Get router details after restart
         list_router_response = list_routers(
-                                    self.apiclient,
-                                    account=self.account.name,
-                                    domainid=self.account.domainid
-                                    )
+            self.apiclient,
+            account=self.account.name,
+            domainid=self.account.domainid
+        )
         self.assertEqual(
-                            isinstance(list_router_response, list),
-                            True,
-                            "Check list response returns a valid list"
-                        )
+            isinstance(list_router_response, list),
+            True,
+            "Check list response returns a valid list"
+        )
         router = list_router_response[0]
 
         hosts = list_hosts(
-                           self.apiclient,
-                           zoneid=router.zoneid,
-                           type='Routing',
-                           state='Up',
-                           id=router.hostid
-                           )
+            self.apiclient,
+            zoneid=router.zoneid,
+            type='Routing',
+            state='Up',
+            id=router.hostid
+        )
         self.assertEqual(
-                            isinstance(hosts, list),
-                            True,
-                            "Check list response returns a valid list"
-                        )
+            isinstance(hosts, list),
+            True,
+            "Check list response returns a valid list"
+        )
         host = hosts[0]
 
         if self.hypervisor.lower() in ('vmware', 'hyperv'):
-           res = get_process_status(
-                           self.apiclient.connection.mgtSvr,
-                           22,
-                           self.apiclient.connection.user,
-                           self.apiclient.connection.passwd,
-                           router.linklocalip,
-                           "uptime",
-                           hypervisor=self.hypervisor
-                           )
+            res = get_process_status(
+                self.apiclient.connection.mgtSvr,
+                22,
+                self.apiclient.connection.user,
+                self.apiclient.connection.passwd,
+                router.linklocalip,
+                "uptime",
+                hypervisor=self.hypervisor
+            )
         else:
             try:
-                host.user, host.passwd = get_host_credentials(self.config, host.ipaddress)
+                host.user, host.passwd = get_host_credentials(
+                    self.config, host.ipaddress)
                 res = get_process_status(
-                                host.ipaddress,
-                                22,
-                                host.user,
-                                host.passwd,
-                                router.linklocalip,
-                                "uptime"
-                                )
+                    host.ipaddress,
+                    22,
+                    host.user,
+                    host.passwd,
+                    router.linklocalip,
+                    "uptime"
+                )
             except KeyError:
-                self.skipTest("Marvin configuration has no host credentials to check router
services")
+                self.skipTest(
+                    "Marvin configuration has no host credentials\
+                            to check router services")
         # res = 12:37:14 up 1 min,  0 users,  load average: 0.61, 0.22, 0.08
         # Split result to check the uptime
         result = res[0].split()
         self.debug("Router Uptime: %s" % result)
         self.assertEqual(
-                            str(result[1]),
-                            'up',
-                            "Check router is running or not"
-                        )
+            str(result[1]),
+            'up',
+            "Check router is running or not"
+        )
         if str(result[3]) == "min,":
-               self.assertEqual(
-                                (int(result[2]) < 3),
-                                True,
-                                "Check uptime is less than 3 mins or not"
-                                )
+            self.assertEqual(
+                (int(result[2]) < 3),
+                True,
+                "Check uptime is less than 3 mins or not"
+            )
         else:
             self.assertEqual(
-                                str(result[3]),
-                                'sec,',
-                                "Check uptime is in seconds"
-                                )
+                str(result[3]),
+                'sec,',
+                "Check uptime is in seconds"
+            )
         return
 
-    @attr(tags = ["advanced", "advancedns", "smoke"], required_hardware="false")
+    @attr(tags=["advanced", "advancedns", "smoke"], required_hardware="false")
     def test_05_router_basic(self):
         """Test router basic setup
         """
@@ -494,62 +519,62 @@ class TestRouterServices(cloudstackTestCase):
         # 3. router will have a guestIP and a linkLocalIp"
 
         list_router_response = list_routers(
-                                        self.apiclient,
-                                        account=self.account.name,
-                                        domainid=self.account.domainid
-                                        )
+            self.apiclient,
+            account=self.account.name,
+            domainid=self.account.domainid
+        )
         self.assertEqual(
-                            isinstance(list_router_response, list),
-                            True,
-                            "Check list response returns a valid list"
-                        )
+            isinstance(list_router_response, list),
+            True,
+            "Check list response returns a valid list"
+        )
         self.assertNotEqual(
-                             len(list_router_response),
-                             0,
-                             "Check list router response"
-                             )
+            len(list_router_response),
+            0,
+            "Check list router response"
+        )
         for router in list_router_response:
             self.assertEqual(
-                            router.state,
-                            'Running',
-                            "Check list router response for router state"
-                        )
+                router.state,
+                'Running',
+                "Check list router response for router state"
+            )
 
             zones = list_zones(
-                               self.apiclient,
-                               id=router.zoneid
-                               )
+                self.apiclient,
+                id=router.zoneid
+            )
             self.assertEqual(
-                            isinstance(zones, list),
-                            True,
-                            "Check list response returns a valid list"
-                        )
+                isinstance(zones, list),
+                True,
+                "Check list response returns a valid list"
+            )
             zone = zones[0]
 
             self.assertEqual(
-                            router.dns1,
-                            zone.dns1,
-                            "Compare DNS1 of router and zone"
-                        )
+                router.dns1,
+                zone.dns1,
+                "Compare DNS1 of router and zone"
+            )
             self.assertEqual(
-                            router.dns2,
-                            zone.dns2,
-                            "Compare DNS2 of router and zone"
-                        )
+                router.dns2,
+                zone.dns2,
+                "Compare DNS2 of router and zone"
+            )
             self.assertEqual(
-                            hasattr(router, 'guestipaddress'),
-                            True,
-                            "Check whether router has guest IP field"
-                            )
+                hasattr(router, 'guestipaddress'),
+                True,
+                "Check whether router has guest IP field"
+            )
 
             self.assertEqual(
-                            hasattr(router, 'linklocalip'),
-                            True,
-                            "Check whether router has link local IP field"
-                            )
+                hasattr(router, 'linklocalip'),
+                True,
+                "Check whether router has link local IP field"
+            )
         return
 
-    @attr(tags = ["advanced", "advancedns", "smoke"], required_hardware="false")
+    @attr(tags=["advanced", "advancedns", "smoke"], required_hardware="false")
     def test_06_router_advanced(self):
         """Test router advanced setup
         """
@@ -560,79 +585,79 @@ class TestRouterServices(cloudstackTestCase):
         # 3. router will have guest,public and linklocal IPs
 
         list_router_response = list_routers(
-                                    self.apiclient,
-                                    account=self.account.name,
-                                    domainid=self.account.domainid
-                                    )
+            self.apiclient,
+            account=self.account.name,
+            domainid=self.account.domainid
+        )
         self.assertEqual(
-                            isinstance(list_router_response, list),
-                            True,
-                            "Check list response returns a valid list"
-                        )
+            isinstance(list_router_response, list),
+            True,
+            "Check list response returns a valid list"
+        )
         self.assertNotEqual(
-                             len(list_router_response),
-                             0,
-                             "Check list router response"
-                             )
+            len(list_router_response),
+            0,
+            "Check list router response"
+        )
         for router in list_router_response:
             self.assertEqual(
-                            router.state,
-                            'Running',
-                            "Check list router response for router state"
-                        )
+                router.state,
+                'Running',
+                "Check list router response for router state"
+            )
 
             zones = list_zones(
-                               self.apiclient,
-                               id=router.zoneid
-                               )
+                self.apiclient,
+                id=router.zoneid
+            )
             self.assertEqual(
-                            isinstance(zones, list),
-                            True,
-                            "Check list response returns a valid list"
-                        )
+                isinstance(zones, list),
+                True,
+                "Check list response returns a valid list"
+            )
             zone = zones[0]
 
             self.assertEqual(
-                            router.dns1,
-                            zone.dns1,
-                            "Compare DNS1 of router and zone"
-                        )
+                router.dns1,
+                zone.dns1,
+                "Compare DNS1 of router and zone"
+            )
             self.assertEqual(
-                            router.dns2,
-                            zone.dns2,
-                            "Compare DNS2 of router and zone"
-                        )
+                router.dns2,
+                zone.dns2,
+                "Compare DNS2 of router and zone"
+            )
             self.assertEqual(
-                            hasattr(router, 'guestipaddress'),
-                            True,
-                            "Check whether router has guest IP field"
-                            )
+                hasattr(router, 'guestipaddress'),
+                True,
+                "Check whether router has guest IP field"
+            )
 
             self.assertEqual(
-                            hasattr(router, 'linklocalip'),
-                            True,
-                            "Check whether router has link local IP field"
-                            )
+                hasattr(router, 'linklocalip'),
+                True,
+                "Check whether router has link local IP field"
+            )
 
-            #Fetch corresponding ip ranges information from listVlanIpRanges
+            # Fetch corresponding ip ranges information from listVlanIpRanges
             ipranges_response = list_vlan_ipranges(
-                                                   self.apiclient,
-                                                   zoneid=router.zoneid
-                                                   )
+                self.apiclient,
+                zoneid=router.zoneid
+            )
             self.assertEqual(
-                            isinstance(ipranges_response, list),
-                            True,
-                            "Check list response returns a valid list"
-                        )
+                isinstance(ipranges_response, list),
+                True,
+                "Check list response returns a valid list"
+            )
             iprange = ipranges_response[0]
             self.assertEqual(
-                            router.gateway,
-                            iprange.gateway,
-                            "Check gateway with that of corresponding IP range"
-                            )
+                router.gateway,
+                iprange.gateway,
+                "Check gateway with that of corresponding IP range"
+            )
         return
 
-    @attr(tags = ["advanced", "advancedns", "smoke"], required_hardware="false")
+    @attr(tags=["advanced", "advancedns", "smoke"], required_hardware="false")
     def test_07_stop_router(self):
         """Test stop router
         """
@@ -641,41 +666,41 @@ class TestRouterServices(cloudstackTestCase):
         # 1. listRouter should report the router for the account as stopped
 
         list_router_response = list_routers(
-                                    self.apiclient,
-                                    account=self.account.name,
-                                    domainid=self.account.domainid
-                                    )
+            self.apiclient,
+            account=self.account.name,
+            domainid=self.account.domainid
+        )
         self.assertEqual(
-                            isinstance(list_router_response, list),
-                            True,
-                            "Check list response returns a valid list"
-                        )
+            isinstance(list_router_response, list),
+            True,
+            "Check list response returns a valid list"
+        )
         router = list_router_response[0]
         self.debug("Stopping the router with ID: %s" % router.id)
-        #Stop the router
+        # Stop the router
         cmd = stopRouter.stopRouterCmd()
         cmd.id = router.id
         self.apiclient.stopRouter(cmd)
 
-        #List routers to check state of router
+        # List routers to check state of router
         router_response = list_routers(
-                                    self.apiclient,
-                                    id=router.id
-                                    )
+            self.apiclient,
+            id=router.id
+        )
         self.assertEqual(
-                            isinstance(router_response, list),
-                            True,
-                            "Check list response returns a valid list"
-                        )
-        #List router should have router in stopped state
+            isinstance(router_response, list),
+            True,
+            "Check list response returns a valid list"
+        )
+        # List router should have router in stopped state
         self.assertEqual(
-                            router_response[0].state,
-                            'Stopped',
-                            "Check list router response for router state"
-                        )
+            router_response[0].state,
+            'Stopped',
+            "Check list router response for router state"
+        )
         return
 
-    @attr(tags = ["advanced", "advancedns", "smoke"], required_hardware="false")
+    @attr(tags=["advanced", "advancedns", "smoke"], required_hardware="false")
     def test_08_start_router(self):
         """Test start router
         """
@@ -684,50 +709,50 @@ class TestRouterServices(cloudstackTestCase):
         # 1. listRouter should report the router for the account as stopped
 
         list_router_response = list_routers(
-                                    self.apiclient,
-                                    account=self.account.name,
-                                    domainid=self.account.domainid
-                                    )
+            self.apiclient,
+            account=self.account.name,
+            domainid=self.account.domainid
+        )
         self.assertEqual(
-                            isinstance(list_router_response, list),
-                            True,
-                            "Check list response returns a valid list"
-                        )
+            isinstance(list_router_response, list),
+            True,
+            "Check list response returns a valid list"
+        )
         router = list_router_response[0]
 
         self.debug("Starting the router with ID: %s" % router.id)
 
-        #Start the router
+        # Start the router
         cmd = startRouter.startRouterCmd()
         cmd.id = router.id
         self.apiclient.startRouter(cmd)
 
-        #List routers to check state of router
+        # List routers to check state of router
         router_response = list_routers(
-                                    self.apiclient,
-                                    id=router.id
-                                    )
+            self.apiclient,
+            id=router.id
+        )
         self.assertEqual(
-                            isinstance(router_response, list),
-                            True,
-                            "Check list response returns a valid list"
-                        )
-        #List router should have router in running state
+            isinstance(router_response, list),
+            True,
+            "Check list response returns a valid list"
+        )
+        # List router should have router in running state
         self.assertEqual(
-                            router_response[0].state,
-                            'Running',
-                            "Check list router response for router state"
-                        )
+            router_response[0].state,
+            'Running',
+            "Check list router response for router state"
+        )
         return
 
-    def verifyRouterResponse(self,router_response,ip):
-            if (router_response) and (isinstance(router_response, list)) and \
-               (router_response[0].state == "Running") and \
-               (router_response[0].publicip == ip):
-               return True
-            return False
+    def verifyRouterResponse(self, router_response, ip):
+        if (router_response) and (isinstance(router_response, list)) and \
+           (router_response[0].state == "Running") and \
+           (router_response[0].publicip == ip):
+            return True
+        return False
 
-    @attr(tags = ["advanced", "advancedns", "smoke"], required_hardware="false")
+    @attr(tags=["advanced", "advancedns", "smoke"], required_hardware="false")
     def test_09_reboot_router(self):
         """Test reboot router
         """
@@ -736,36 +761,38 @@ class TestRouterServices(cloudstackTestCase):
         # 1. listRouter should report the router for the account as stopped
 
         list_router_response = list_routers(
-                                    self.apiclient,
-                                    account=self.account.name,
-                                    domainid=self.account.domainid
-                                    )
+            self.apiclient,
+            account=self.account.name,
+            domainid=self.account.domainid
+        )
         self.assertEqual(
-                            isinstance(list_router_response, list),
-                            True,
-                            "Check list response returns a valid list"
-                        )
+            isinstance(list_router_response, list),
+            True,
+            "Check list response returns a valid list"
+        )
         router = list_router_response[0]
 
         public_ip = router.publicip
 
         self.debug("Rebooting the router with ID: %s" % router.id)
-        #Reboot the router
+        # Reboot the router
         cmd = rebootRouter.rebootRouterCmd()
         cmd.id = router.id
         self.apiclient.rebootRouter(cmd)
 
-        #List routers to check state of router
+        # List routers to check state of router
         retries_cnt = 6
         while retries_cnt >= 0:
             router_response = list_routers(
-                                    self.apiclient,
-                                    id=router.id
-                                    )
-            if self.verifyRouterResponse(router_response,public_ip):
+                self.apiclient,
+                id=router.id
+            )
+            if self.verifyRouterResponse(router_response, public_ip):
                 self.debug("Router is running successfully after reboot")
                 return
             time.sleep(10)
             retries_cnt = retries_cnt - 1
-        self.fail("Router response after reboot is either is invalid or in stopped state")
+        self.fail(
+            "Router response after reboot is either is invalid\
+                    or in stopped state")
         return


Mime
View raw message