cloudstack-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From tall...@apache.org
Subject [2/4] git commit: updated refs/heads/master to 684268f
Date Tue, 25 Nov 2014 13:00:46 GMT
http://git-wip-us.apache.org/repos/asf/cloudstack/blob/684268f4/test/integration/component/test_netscaler_lb_algo.py
----------------------------------------------------------------------
diff --git a/test/integration/component/test_netscaler_lb_algo.py b/test/integration/component/test_netscaler_lb_algo.py
index 0d571b4..bafecd0 100644
--- a/test/integration/component/test_netscaler_lb_algo.py
+++ b/test/integration/component/test_netscaler_lb_algo.py
@@ -31,83 +31,8 @@ from marvin.lib.base import (Account,
 from marvin.lib.common import (get_zone,
                                get_domain,
                                get_template,
-                               list_configurations,
-                               GetNetscalerInfoFromConfig,
                                add_netscaler)
 from marvin.sshClient import SshClient
-import time
-
-
-class Services:
-
-    """Test netscaler services
-    """
-
-    def __init__(self):
-        self.services = {
-            "account": {
-                "email": "test@test.com",
-                "firstname": "Test",
-                "lastname": "User",
-                "username": "test",
-                # Random characters are appended for unique
-                # username
-                "password": "password",
-            },
-            "service_offering": {
-                "name": "Tiny Instance",
-                "displaytext": "Tiny Instance",
-                "cpunumber": 1,
-                "cpuspeed": 100,  # in MHz
-                "memory": 128,  # In MBs
-            },
-            "virtual_machine": {
-                "displayname": "TestVM",
-                "username": "root",
-                "password": "password",
-                "ssh_port": 22,
-                "hypervisor": 'XenServer',
-                "privateport": 22,
-                "publicport": 22,
-                "protocol": 'TCP',
-            },
-            "network_offering": {
-                "name": 'Netscaler',
-                "displaytext": 'Netscaler',
-                "guestiptype": 'Isolated',
-                "supportedservices": 'Dhcp,Dns,SourceNat,PortForwarding,Vpn,Firewall,Lb,UserData,StaticNat',
-                "traffictype": 'GUEST',
-                "availability": 'Optional',
-                "serviceProviderList": {
-                    "Dhcp": 'VirtualRouter',
-                    "Dns": 'VirtualRouter',
-                    "SourceNat": 'VirtualRouter',
-                    "PortForwarding": 'VirtualRouter',
-                    "Vpn": 'VirtualRouter',
-                    "Firewall": 'VirtualRouter',
-                    "Lb": 'Netscaler',
-                    "UserData": 'VirtualRouter',
-                    "StaticNat": 'VirtualRouter',
-                },
-            },
-            "network": {
-                "name": "Netscaler",
-                "displaytext": "Netscaler"
-            },
-            "lbrule": {
-                "name": "SSH",
-                "alg": "leastconn",
-                # Algorithm used for load balancing
-                "privateport": 22,
-                "publicport": 22,
-                "openfirewall": False,
-            },
-            "ostype": 'CentOS 5.3 (64-bit)',
-            # Cent OS 5.3 (64 bit)
-            "sleep": 60,
-            "timeout": 10,
-            "mode": 'advanced'
-        }
 
 
 class TestLbWithRoundRobin(cloudstackTestCase):
@@ -118,40 +43,37 @@ class TestLbWithRoundRobin(cloudstackTestCase):
         cls.testClient = super(TestLbWithRoundRobin, cls).getClsTestClient()
         cls.api_client = cls.testClient.getApiClient()
 
-        cls.services = Services().services
+        # Fill testdata from the external config file
+        cls.testdata = cls.testClient.getParsedTestDataConfig()
         # Get Zone, Domain and templates
         cls.domain = get_domain(cls.api_client)
         cls.zone = get_zone(cls.api_client, cls.testClient.getZoneForTests())
         cls.template = get_template(
             cls.api_client,
             cls.zone.id,
-            cls.services["ostype"]
+            cls.testdata["ostype"]
         )
 
-        response = GetNetscalerInfoFromConfig(
-            cls.config
-        )
-        assert response[0] is not None, response[1]
-        cls.services["netscaler"] = response[0]
-        cls.services["netscaler"]["lbdevicededicated"] = False
+        cls.testdata["configurableData"]["netscaler"]["lbdevicededicated"] = False
 
         cls._cleanup = []
         try:
-            cls.netscaler = add_netscaler(cls.api_client, cls.zone.id, cls.services["netscaler"])
+            cls.netscaler = add_netscaler(cls.api_client, cls.zone.id, cls.testdata["configurableData"]["netscaler"])
             cls._cleanup.append(cls.netscaler)
+
             cls.network_offering = NetworkOffering.create(
                 cls.api_client,
-                cls.services["network_offering"],
-                conservemode=True
+                cls.testdata["nw_off_isolated_netscaler"],
+                conservemode="True"
             )
             # Enable Network offering
             cls.network_offering.update(cls.api_client, state='Enabled')
-            cls.services["virtual_machine"]["zoneid"] = cls.zone.id
-            cls.services["virtual_machine"]["template"] = cls.template.id
+            cls.testdata["small"]["zoneid"] = cls.zone.id
+            cls.testdata["small"]["template"] = cls.template.id
 
             cls.service_offering = ServiceOffering.create(
                 cls.api_client,
-                cls.services["service_offering"]
+                cls.testdata["service_offering"]
             )
         except Exception as e:
             cls.tearDownClass()
@@ -172,7 +94,7 @@ class TestLbWithRoundRobin(cloudstackTestCase):
         self.dbclient = self.testClient.getDbConnection()
         self.account = Account.create(
             self.apiclient,
-            self.services["account"],
+            self.testdata["account"],
             admin=True,
             domainid=self.domain.id
         )
@@ -184,17 +106,6 @@ class TestLbWithRoundRobin(cloudstackTestCase):
             self.debug("Cleaning up the resources")
             # Clean up, terminate the created network offerings
             cleanup_resources(self.apiclient, self.cleanup)
-            interval = list_configurations(
-                self.apiclient,
-                name='network.gc.interval'
-            )
-            wait = list_configurations(
-                self.apiclient,
-                name='network.gc.wait'
-            )
-            # Sleep to ensure that all resources are deleted
-            time.sleep(int(interval[0].value) + int(wait[0].value))
-            self.debug("Cleanup complete!")
         except Exception as e:
             raise Exception("Warning: Exception during cleanup : %s" % e)
         return
@@ -217,7 +128,7 @@ class TestLbWithRoundRobin(cloudstackTestCase):
                    self.network_offering.id)
         self.network = Network.create(
             self.apiclient,
-            self.services["network"],
+            self.testdata["network"],
             accountid=self.account.name,
             domainid=self.account.domainid,
             networkofferingid=self.network_offering.id,
@@ -230,7 +141,7 @@ class TestLbWithRoundRobin(cloudstackTestCase):
         # Spawn an instance in that network
         self.virtual_machine = VirtualMachine.create(
             self.apiclient,
-            self.services["virtual_machine"],
+            self.testdata["small"],
             accountid=self.account.name,
             domainid=self.account.domainid,
             serviceofferingid=self.service_offering.id,
@@ -277,10 +188,10 @@ class TestLbWithRoundRobin(cloudstackTestCase):
             "Creating LB rule for IP address: %s with round robin algo" %
             ip_with_lb_rule.ipaddress.ipaddress)
 
-        self.services["lbrule"]["alg"] = 'roundrobin'
+        self.testdata["lbrule"]["alg"] = 'roundrobin'
         lb_rule = LoadBalancerRule.create(
             self.apiclient,
-            self.services["lbrule"],
+            self.testdata["lbrule"],
             ipaddressid=ip_with_lb_rule.ipaddress.id,
             accountid=self.account.name,
             networkid=self.network.id
@@ -304,13 +215,13 @@ class TestLbWithRoundRobin(cloudstackTestCase):
         self.debug(
             "SSH into Netscaler to check whether algorithm is configured properly or not?")
         self.debug("SSH into netscaler: %s" %
-                   self.services["netscaler"]["ipaddress"])
+                   self.testdata["configurableData"]["netscaler"]["ipaddress"])
         try:
             ssh_client = SshClient(
-                self.services["netscaler"]["ipaddress"],
-                self.services["netscaler"]["port"],
-                self.services["netscaler"]["username"],
-                self.services["netscaler"]["password"],
+                self.testdata["configurableData"]["netscaler"]["ipaddress"],
+                self.testdata["configurableData"]["netscaler"]["port"],
+                self.testdata["configurableData"]["netscaler"]["username"],
+                self.testdata["configurableData"]["netscaler"]["password"],
             )
             cmd = "show lb vserver Cloud-VirtualServer-%s-%s" % (
                 ip_with_lb_rule.ipaddress.ipaddress,
@@ -328,7 +239,7 @@ class TestLbWithRoundRobin(cloudstackTestCase):
 
         except Exception as e:
             self.fail("SSH Access failed for %s: %s" %
-                      (self.services["netscaler"]["ipaddress"], e))
+                      (self.testdata["configurableData"]["netscaler"]["ipaddress"], e))
         return
 
 
@@ -340,41 +251,37 @@ class TestLbWithLeastConn(cloudstackTestCase):
         cls.testClient = super(TestLbWithLeastConn, cls).getClsTestClient()
         cls.api_client = cls.testClient.getApiClient()
 
-        cls.services = Services().services
+        # Fill testdata from the external config file
+        cls.testdata = cls.testClient.getParsedTestDataConfig()
         # Get Zone, Domain and templates
         cls.domain = get_domain(cls.api_client)
         cls.zone = get_zone(cls.api_client, cls.testClient.getZoneForTests())
         cls.template = get_template(
             cls.api_client,
             cls.zone.id,
-            cls.services["ostype"]
+            cls.testdata["ostype"]
         )
 
-        response = GetNetscalerInfoFromConfig(
-            cls.config
-        )
-        assert response[0] is not None, response[1]
-        cls.services["netscaler"] = response[0]
-        cls.services["netscaler"]["lbdevicededicated"] = False
+        cls.testdata["configurableData"]["netscaler"]["lbdevicededicated"] = False
 
         try:
-            cls.netscaler = add_netscaler(cls.api_client, cls.zone.id, cls.services["netscaler"])
+            cls.netscaler = add_netscaler(cls.api_client, cls.zone.id, cls.testdata["configurableData"]["netscaler"])
             cls._cleanup.append(cls.netscaler)
             cls.network_offering = NetworkOffering.create(
                 cls.api_client,
-                cls.services["network_offering"],
-                conservemode=True
+                cls.testdata["nw_off_isolated_netscaler"],
+                conservemode="True"
             )
             cls._cleanup.append(cls.network_offering)
             # Enable Network offering
             cls.network_offering.update(cls.api_client, state='Enabled')
 
-            cls.services["virtual_machine"]["zoneid"] = cls.zone.id
-            cls.services["virtual_machine"]["template"] = cls.template.id
+            cls.testdata["small"]["zoneid"] = cls.zone.id
+            cls.testdata["small"]["template"] = cls.template.id
 
             cls.service_offering = ServiceOffering.create(
                 cls.api_client,
-                cls.services["service_offering"]
+                cls.testdata["service_offering"]
             )
             cls._cleanup.append(cls.service_offering)
         except Exception as e:
@@ -397,7 +304,7 @@ class TestLbWithLeastConn(cloudstackTestCase):
         self.dbclient = self.testClient.getDbConnection()
         self.account = Account.create(
             self.apiclient,
-            self.services["account"],
+            self.testdata["account"],
             admin=True,
             domainid=self.domain.id
         )
@@ -409,17 +316,6 @@ class TestLbWithLeastConn(cloudstackTestCase):
             self.debug("Cleaning up the resources")
             # Clean up, terminate the created network offerings
             cleanup_resources(self.apiclient, self.cleanup)
-            interval = list_configurations(
-                self.apiclient,
-                name='network.gc.interval'
-            )
-            wait = list_configurations(
-                self.apiclient,
-                name='network.gc.wait'
-            )
-            # Sleep to ensure that all resources are deleted
-            time.sleep(int(interval[0].value) + int(wait[0].value))
-            self.debug("Cleanup complete!")
         except Exception as e:
             raise Exception("Warning: Exception during cleanup : %s" % e)
         return
@@ -442,7 +338,7 @@ class TestLbWithLeastConn(cloudstackTestCase):
                    self.network_offering.id)
         self.network = Network.create(
             self.apiclient,
-            self.services["network"],
+            self.testdata["network"],
             accountid=self.account.name,
             domainid=self.account.domainid,
             networkofferingid=self.network_offering.id,
@@ -455,7 +351,7 @@ class TestLbWithLeastConn(cloudstackTestCase):
         # Spawn an instance in that network
         self.virtual_machine = VirtualMachine.create(
             self.apiclient,
-            self.services["virtual_machine"],
+            self.testdata["small"],
             accountid=self.account.name,
             domainid=self.account.domainid,
             serviceofferingid=self.service_offering.id,
@@ -509,10 +405,10 @@ class TestLbWithLeastConn(cloudstackTestCase):
             "Creating LB rule for IP address: %s with round robin algo" %
             ip_with_lb_rule.ipaddress.ipaddress)
 
-        self.services["lbrule"]["alg"] = 'leastconn'
+        self.testdata["lbrule"]["alg"] = 'leastconn'
         lb_rule = LoadBalancerRule.create(
             self.apiclient,
-            self.services["lbrule"],
+            self.testdata["lbrule"],
             ipaddressid=ip_with_lb_rule.ipaddress.id,
             accountid=self.account.name,
             networkid=self.network.id
@@ -537,13 +433,13 @@ class TestLbWithLeastConn(cloudstackTestCase):
         self.debug(
             "SSH into Netscaler to check whether algorithm is configured properly or not?")
         self.debug("SSH into netscaler: %s" %
-                   self.services["netscaler"]["ipaddress"])
+                   self.testdata["configurableData"]["netscaler"]["ipaddress"])
         try:
             ssh_client = SshClient(
-                self.services["netscaler"]["ipaddress"],
-                self.services["netscaler"]["port"],
-                self.services["netscaler"]["username"],
-                self.services["netscaler"]["password"],
+                self.testdata["configurableData"]["netscaler"]["ipaddress"],
+                self.testdata["configurableData"]["netscaler"]["port"],
+                self.testdata["configurableData"]["netscaler"]["username"],
+                self.testdata["configurableData"]["netscaler"]["password"],
             )
             cmd = "show lb vserver Cloud-VirtualServer-%s-%s" % (
                 ip_with_lb_rule.ipaddress.ipaddress,
@@ -561,7 +457,7 @@ class TestLbWithLeastConn(cloudstackTestCase):
 
         except Exception as e:
             self.fail("SSH Access failed for %s: %s" %
-                      (self.services["netscaler"]["ipaddress"], e))
+                      (self.testdata["configurableData"]["netscaler"]["ipaddress"], e))
         return
 
 
@@ -572,41 +468,37 @@ class TestLbWithSourceIp(cloudstackTestCase):
         cls.testClient = super(TestLbWithSourceIp, cls).getClsTestClient()
         cls.api_client = cls.testClient.getApiClient()
 
-        cls.services = Services().services
+        # Fill testdata from the external config file
+        cls.testdata = cls.testClient.getParsedTestDataConfig()
         # Get Zone, Domain and templates
         cls.domain = get_domain(cls.api_client)
         cls.zone = get_zone(cls.api_client, cls.testClient.getZoneForTests())
         cls.template = get_template(
             cls.api_client,
             cls.zone.id,
-            cls.services["ostype"]
+            cls.testdata["ostype"]
         )
 
-        response = GetNetscalerInfoFromConfig(
-            cls.config
-        )
-        assert response[0] is not None, response[1]
-        cls.services["netscaler"] = response[0]
-        cls.services["netscaler"]["lbdevicededicated"] = False
+        cls.testdata["configurableData"]["netscaler"]["lbdevicededicated"] = False
 
         cls._cleanup = []
         try:
-            cls.netscaler = add_netscaler(cls.api_client, cls.zone.id, cls.services["netscaler"])
+            cls.netscaler = add_netscaler(cls.api_client, cls.zone.id, cls.testdata["configurableData"]["netscaler"])
             cls._cleanup.append(cls.netscaler)
             cls.network_offering = NetworkOffering.create(
                 cls.api_client,
-                cls.services["network_offering"],
-                conservemode=True
+                cls.testdata["nw_off_isolated_netscaler"],
+                conservemode="True"
             )
             cls._cleanup.append(cls.network_offering)
             # Enable Network offering
             cls.network_offering.update(cls.api_client, state='Enabled')
-            cls.services["virtual_machine"]["zoneid"] = cls.zone.id
-            cls.services["virtual_machine"]["template"] = cls.template.id
+            cls.testdata["small"]["zoneid"] = cls.zone.id
+            cls.testdata["small"]["template"] = cls.template.id
 
             cls.service_offering = ServiceOffering.create(
                 cls.api_client,
-                cls.services["service_offering"]
+                cls.testdata["service_offering"]
             )
             cls._cleanup.append(cls.service_offering)
         except Exception as e:
@@ -628,7 +520,7 @@ class TestLbWithSourceIp(cloudstackTestCase):
         self.dbclient = self.testClient.getDbConnection()
         self.account = Account.create(
             self.apiclient,
-            self.services["account"],
+            self.testdata["account"],
             admin=True,
             domainid=self.domain.id
         )
@@ -640,17 +532,6 @@ class TestLbWithSourceIp(cloudstackTestCase):
             self.debug("Cleaning up the resources")
             # Clean up, terminate the created network offerings
             cleanup_resources(self.apiclient, self.cleanup)
-            interval = list_configurations(
-                self.apiclient,
-                name='network.gc.interval'
-            )
-            wait = list_configurations(
-                self.apiclient,
-                name='network.gc.wait'
-            )
-            # Sleep to ensure that all resources are deleted
-            time.sleep(int(interval[0].value) + int(wait[0].value))
-            self.debug("Cleanup complete!")
         except Exception as e:
             raise Exception("Warning: Exception during cleanup : %s" % e)
         return
@@ -673,7 +554,7 @@ class TestLbWithSourceIp(cloudstackTestCase):
                    self.network_offering.id)
         self.network = Network.create(
             self.apiclient,
-            self.services["network"],
+            self.testdata["network"],
             accountid=self.account.name,
             domainid=self.account.domainid,
             networkofferingid=self.network_offering.id,
@@ -686,7 +567,7 @@ class TestLbWithSourceIp(cloudstackTestCase):
         # Spawn an instance in that network
         self.virtual_machine = VirtualMachine.create(
             self.apiclient,
-            self.services["virtual_machine"],
+            self.testdata["small"],
             accountid=self.account.name,
             domainid=self.account.domainid,
             serviceofferingid=self.service_offering.id,
@@ -733,10 +614,10 @@ class TestLbWithSourceIp(cloudstackTestCase):
             "Creating LB rule for IP address: %s with round robin algo" %
             ip_with_lb_rule.ipaddress.ipaddress)
 
-        self.services["lbrule"]["alg"] = 'source'
+        self.testdata["lbrule"]["alg"] = 'source'
         lb_rule = LoadBalancerRule.create(
             self.apiclient,
-            self.services["lbrule"],
+            self.testdata["lbrule"],
             ipaddressid=ip_with_lb_rule.ipaddress.id,
             accountid=self.account.name,
             networkid=self.network.id
@@ -761,13 +642,13 @@ class TestLbWithSourceIp(cloudstackTestCase):
         self.debug(
             "SSH into Netscaler to check whether algorithm is configured properly or not?")
         self.debug("SSH into netscaler: %s" %
-                   self.services["netscaler"]["ipaddress"])
+                   self.testdata["configurableData"]["netscaler"]["ipaddress"])
         try:
             ssh_client = SshClient(
-                self.services["netscaler"]["ipaddress"],
-                self.services["netscaler"]["port"],
-                self.services["netscaler"]["username"],
-                self.services["netscaler"]["password"],
+                self.testdata["configurableData"]["netscaler"]["ipaddress"],
+                self.testdata["configurableData"]["netscaler"]["port"],
+                self.testdata["configurableData"]["netscaler"]["username"],
+                self.testdata["configurableData"]["netscaler"]["password"],
             )
             cmd = "show lb vserver Cloud-VirtualServer-%s-%s" % (
                 ip_with_lb_rule.ipaddress.ipaddress,
@@ -785,7 +666,7 @@ class TestLbWithSourceIp(cloudstackTestCase):
 
         except Exception as e:
             self.fail("SSH Access failed for %s: %s" %
-                      (self.services["netscaler"]["ipaddress"], e))
+                      (self.testdata["configurableData"]["netscaler"]["ipaddress"], e))
         return
 
 
@@ -797,62 +678,58 @@ class TestLbAlgoRrLc(cloudstackTestCase):
         cls.testClient = super(TestLbAlgoRrLc, cls).getClsTestClient()
         cls.api_client = cls.testClient.getApiClient()
 
-        cls.services = Services().services
+        # Fill testdata from the external config file
+        cls.testdata = cls.testClient.getParsedTestDataConfig()
         # Get Zone, Domain and templates
         cls.domain = get_domain(cls.api_client)
         cls.zone = get_zone(cls.api_client, cls.testClient.getZoneForTests())
         cls.template = get_template(
             cls.api_client,
             cls.zone.id,
-            cls.services["ostype"]
+            cls.testdata["ostype"]
         )
 
-        response = GetNetscalerInfoFromConfig(
-            cls.config
-        )
-        assert response[0] is not None, response[1]
-        cls.services["netscaler"] = response[0]
-        cls.services["netscaler"]["lbdevicededicated"] = False
+        cls.testdata["configurableData"]["netscaler"]["lbdevicededicated"] = False
 
         try:
-            cls.netscaler = add_netscaler(cls.api_client, cls.zone.id, cls.services["netscaler"])
+            cls.netscaler = add_netscaler(cls.api_client, cls.zone.id, cls.testdata["configurableData"]["netscaler"])
             cls._cleanup.append(cls.netscaler)
             cls.network_offering = NetworkOffering.create(
                 cls.api_client,
-                cls.services["network_offering"],
-                conservemode=True
+                cls.testdata["nw_off_isolated_netscaler"],
+                conservemode="True"
             )
             cls._cleanup.append(cls.network_offering)
             # Enable Network offering
             cls.network_offering.update(cls.api_client, state='Enabled')
             cls.account = Account.create(
                 cls.api_client,
-                cls.services["account"],
+                cls.testdata["account"],
                 admin=True,
                 domainid=cls.domain.id
             )
             cls._cleanup.insert(0, cls.account)
             cls.network = Network.create(
                 cls.api_client,
-                cls.services["network"],
+                cls.testdata["network"],
                 accountid=cls.account.name,
                 domainid=cls.account.domainid,
                 networkofferingid=cls.network_offering.id,
                 zoneid=cls.zone.id
             )
-            cls.services["virtual_machine"]["zoneid"] = cls.zone.id
-            cls.services["virtual_machine"]["template"] = cls.template.id
+            cls.testdata["small"]["zoneid"] = cls.zone.id
+            cls.testdata["small"]["template"] = cls.template.id
 
             cls.service_offering = ServiceOffering.create(
                 cls.api_client,
-                cls.services["service_offering"]
+                cls.testdata["service_offering"]
             )
             cls._cleanup.append(cls.service_offering)
 
             # Spawn an instance in that network
             cls.virtual_machine = VirtualMachine.create(
                 cls.api_client,
-                cls.services["virtual_machine"],
+                cls.testdata["small"],
                 accountid=cls.account.name,
                 domainid=cls.account.domainid,
                 serviceofferingid=cls.service_offering.id,
@@ -914,10 +791,10 @@ class TestLbAlgoRrLc(cloudstackTestCase):
             "Creating LB rule for IP address: %s with round robin algo" %
             self.public_ip.ipaddress.ipaddress)
 
-        self.services["lbrule"]["alg"] = 'roundrobin'
+        self.testdata["lbrule"]["alg"] = 'roundrobin'
         lb_rule = LoadBalancerRule.create(
             self.apiclient,
-            self.services["lbrule"],
+            self.testdata["lbrule"],
             ipaddressid=self.public_ip.ipaddress.id,
             accountid=self.account.name,
             networkid=self.network.id
@@ -944,13 +821,13 @@ class TestLbAlgoRrLc(cloudstackTestCase):
         self.debug(
             "SSH into Netscaler to check whether algorithm is configured properly or not?")
         self.debug("SSH into netscaler: %s" %
-                   self.services["netscaler"]["ipaddress"])
+                   self.testdata["configurableData"]["netscaler"]["ipaddress"])
         try:
             ssh_client = SshClient(
-                self.services["netscaler"]["ipaddress"],
-                self.services["netscaler"]["port"],
-                self.services["netscaler"]["username"],
-                self.services["netscaler"]["password"],
+                self.testdata["configurableData"]["netscaler"]["ipaddress"],
+                self.testdata["configurableData"]["netscaler"]["port"],
+                self.testdata["configurableData"]["netscaler"]["username"],
+                self.testdata["configurableData"]["netscaler"]["password"],
             )
             cmd = "show lb vserver Cloud-VirtualServer-%s-%s" % (
                 self.public_ip.ipaddress.ipaddress,
@@ -967,7 +844,7 @@ class TestLbAlgoRrLc(cloudstackTestCase):
             )
         except Exception as e:
             self.fail("SSH Access failed for %s: %s" %
-                      (self.services["netscaler"]["ipaddress"], e))
+                      (self.testdata["configurableData"]["netscaler"]["ipaddress"], e))
 
         self.debug(
             "Updating LB rule: %s with new algorithm: %s" % (
@@ -978,13 +855,13 @@ class TestLbAlgoRrLc(cloudstackTestCase):
         self.debug(
             "SSH into Netscaler to check whether algorithm is configured properly or not?")
         self.debug("SSH into netscaler: %s" %
-                   self.services["netscaler"]["ipaddress"])
+                   self.testdata["configurableData"]["netscaler"]["ipaddress"])
         try:
             ssh_client = SshClient(
-                self.services["netscaler"]["ipaddress"],
-                self.services["netscaler"]["port"],
-                self.services["netscaler"]["username"],
-                self.services["netscaler"]["password"],
+                self.testdata["configurableData"]["netscaler"]["ipaddress"],
+                self.testdata["configurableData"]["netscaler"]["port"],
+                self.testdata["configurableData"]["netscaler"]["username"],
+                self.testdata["configurableData"]["netscaler"]["password"],
             )
             cmd = "show lb vserver Cloud-VirtualServer-%s-%s" % (
                 self.public_ip.ipaddress.ipaddress,
@@ -1001,7 +878,7 @@ class TestLbAlgoRrLc(cloudstackTestCase):
             )
         except Exception as e:
             self.fail("SSH Access failed for %s: %s" %
-                      (self.services["netscaler"]["ipaddress"], e))
+                      (self.testdata["configurableData"]["netscaler"]["ipaddress"], e))
         return
 
 
@@ -1013,62 +890,58 @@ class TestLbAlgoLcRr(cloudstackTestCase):
         cls.testClient = super(TestLbAlgoLcRr, cls).getClsTestClient()
         cls.api_client = cls.testClient.getApiClient()
 
-        cls.services = Services().services
+        # Fill testdata from the external config file
+        cls.testdata = cls.testClient.getParsedTestDataConfig()
         # Get Zone, Domain and templates
         cls.domain = get_domain(cls.api_client)
         cls.zone = get_zone(cls.api_client, cls.testClient.getZoneForTests())
         cls.template = get_template(
             cls.api_client,
             cls.zone.id,
-            cls.services["ostype"]
+            cls.testdata["ostype"]
         )
 
-        response = GetNetscalerInfoFromConfig(
-            cls.config
-        )
-        assert response[0] is not None, response[1]
-        cls.services["netscaler"] = response[0]
-        cls.services["netscaler"]["lbdevicededicated"] = False
+        cls.testdata["configurableData"]["netscaler"]["lbdevicededicated"] = False
 
         try:
-            cls.netscaler = add_netscaler(cls.api_client, cls.zone.id, cls.services["netscaler"])
+            cls.netscaler = add_netscaler(cls.api_client, cls.zone.id, cls.testdata["configurableData"]["netscaler"])
             cls._cleanup.append(cls.netscaler)
             cls.network_offering = NetworkOffering.create(
                 cls.api_client,
-                cls.services["network_offering"],
-                conservemode=True
+                cls.testdata["nw_off_isolated_netscaler"],
+                conservemode="True"
             )
             cls._cleanup.append(cls.network_offering)
             # Enable Network offering
             cls.network_offering.update(cls.api_client, state='Enabled')
             cls.account = Account.create(
                 cls.api_client,
-                cls.services["account"],
+                cls.testdata["account"],
                 admin=True,
                 domainid=cls.domain.id
             )
             cls._cleanup.insert(0, cls.account)
             cls.network = Network.create(
                 cls.api_client,
-                cls.services["network"],
+                cls.testdata["network"],
                 accountid=cls.account.name,
                 domainid=cls.account.domainid,
                 networkofferingid=cls.network_offering.id,
                 zoneid=cls.zone.id
             )
-            cls.services["virtual_machine"]["zoneid"] = cls.zone.id
-            cls.services["virtual_machine"]["template"] = cls.template.id
+            cls.testdata["small"]["zoneid"] = cls.zone.id
+            cls.testdata["small"]["template"] = cls.template.id
 
             cls.service_offering = ServiceOffering.create(
                 cls.api_client,
-                cls.services["service_offering"]
+                cls.testdata["service_offering"]
             )
             cls._cleanup.append(cls.service_offering)
 
             # Spawn an instance in that network
             cls.virtual_machine = VirtualMachine.create(
                 cls.api_client,
-                cls.services["virtual_machine"],
+                cls.testdata["small"],
                 accountid=cls.account.name,
                 domainid=cls.account.domainid,
                 serviceofferingid=cls.service_offering.id,
@@ -1106,7 +979,6 @@ class TestLbAlgoLcRr(cloudstackTestCase):
             self.debug("Cleaning up the resources")
             # Clean up, terminate the created network offerings
             cleanup_resources(self.apiclient, self.cleanup)
-            self.debug("Cleanup complete!")
         except Exception as e:
             raise Exception("Warning: Exception during cleanup : %s" % e)
         return
@@ -1130,10 +1002,10 @@ class TestLbAlgoLcRr(cloudstackTestCase):
             "Creating LB rule for IP address: %s with least conn algo" %
             self.public_ip.ipaddress.ipaddress)
 
-        self.services["lbrule"]["alg"] = 'leastconn'
+        self.testdata["lbrule"]["alg"] = 'leastconn'
         lb_rule = LoadBalancerRule.create(
             self.apiclient,
-            self.services["lbrule"],
+            self.testdata["lbrule"],
             ipaddressid=self.public_ip.ipaddress.id,
             accountid=self.account.name,
             networkid=self.network.id
@@ -1158,13 +1030,13 @@ class TestLbAlgoLcRr(cloudstackTestCase):
         self.debug(
             "SSH into Netscaler to check whether algorithm is configured properly or not?")
         self.debug("SSH into netscaler: %s" %
-                   self.services["netscaler"]["ipaddress"])
+                   self.testdata["configurableData"]["netscaler"]["ipaddress"])
         try:
             ssh_client = SshClient(
-                self.services["netscaler"]["ipaddress"],
-                self.services["netscaler"]["port"],
-                self.services["netscaler"]["username"],
-                self.services["netscaler"]["password"],
+                self.testdata["configurableData"]["netscaler"]["ipaddress"],
+                self.testdata["configurableData"]["netscaler"]["port"],
+                self.testdata["configurableData"]["netscaler"]["username"],
+                self.testdata["configurableData"]["netscaler"]["password"],
             )
             cmd = "show lb vserver Cloud-VirtualServer-%s-%s" % (
                 self.public_ip.ipaddress.ipaddress,
@@ -1181,7 +1053,7 @@ class TestLbAlgoLcRr(cloudstackTestCase):
             )
         except Exception as e:
             self.fail("SSH Access failed for %s: %s" %
-                      (self.services["netscaler"]["ipaddress"], e))
+                      (self.testdata["configurableData"]["netscaler"]["ipaddress"], e))
 
         self.debug(
             "Updating LB rule: %s with new algorithm: %s" % (
@@ -1191,13 +1063,13 @@ class TestLbAlgoLcRr(cloudstackTestCase):
         self.debug(
             "SSH into Netscaler to check whether algorithm is configured properly or not?")
         self.debug("SSH into netscaler: %s" %
-                   self.services["netscaler"]["ipaddress"])
+                   self.testdata["configurableData"]["netscaler"]["ipaddress"])
         try:
             ssh_client = SshClient(
-                self.services["netscaler"]["ipaddress"],
-                self.services["netscaler"]["port"],
-                self.services["netscaler"]["username"],
-                self.services["netscaler"]["password"],
+                self.testdata["configurableData"]["netscaler"]["ipaddress"],
+                self.testdata["configurableData"]["netscaler"]["port"],
+                self.testdata["configurableData"]["netscaler"]["username"],
+                self.testdata["configurableData"]["netscaler"]["password"],
             )
             cmd = "show lb vserver Cloud-VirtualServer-%s-%s" % (
                 self.public_ip.ipaddress.ipaddress,
@@ -1214,7 +1086,7 @@ class TestLbAlgoLcRr(cloudstackTestCase):
             )
         except Exception as e:
             self.fail("SSH Access failed for %s: %s" %
-                      (self.services["netscaler"]["ipaddress"], e))
+                      (self.testdata["configurableData"]["netscaler"]["ipaddress"], e))
         return
 
 
@@ -1226,62 +1098,58 @@ class TestLbAlgoRrSb(cloudstackTestCase):
         cls.testClient = super(TestLbAlgoRrSb, cls).getClsTestClient()
         cls.api_client = cls.testClient.getApiClient()
 
-        cls.services = Services().services
+        # Fill testdata from the external config file
+        cls.testdata = cls.testClient.getParsedTestDataConfig()
         # Get Zone, Domain and templates
         cls.domain = get_domain(cls.api_client)
         cls.zone = get_zone(cls.api_client, cls.testClient.getZoneForTests())
         cls.template = get_template(
             cls.api_client,
             cls.zone.id,
-            cls.services["ostype"]
+            cls.testdata["ostype"]
         )
 
-        response = GetNetscalerInfoFromConfig(
-            cls.config
-        )
-        assert response[0] is not None, response[1]
-        cls.services["netscaler"] = response[0]
-        cls.services["netscaler"]["lbdevicededicated"] = False
+        cls.testdata["configurableData"]["netscaler"]["lbdevicededicated"] = False
 
         try:
-            cls.netscaler = add_netscaler(cls.api_client, cls.zone.id, cls.services["netscaler"])
+            cls.netscaler = add_netscaler(cls.api_client, cls.zone.id, cls.testdata["configurableData"]["netscaler"])
             cls._cleanup.append(cls.netscaler)
             cls.network_offering = NetworkOffering.create(
                 cls.api_client,
-                cls.services["network_offering"],
-                conservemode=True
+                cls.testdata["nw_off_isolated_netscaler"],
+                conservemode="True"
             )
             cls._cleanup.append(cls.network_offering)
             # Enable Network offering
             cls.network_offering.update(cls.api_client, state='Enabled')
             cls.account = Account.create(
                 cls.api_client,
-                cls.services["account"],
+                cls.testdata["account"],
                 admin=True,
                 domainid=cls.domain.id
             )
             cls._cleanup.insert(0, cls.account)
             cls.network = Network.create(
                 cls.api_client,
-                cls.services["network"],
+                cls.testdata["network"],
                 accountid=cls.account.name,
                 domainid=cls.account.domainid,
                 networkofferingid=cls.network_offering.id,
                 zoneid=cls.zone.id
             )
-            cls.services["virtual_machine"]["zoneid"] = cls.zone.id
-            cls.services["virtual_machine"]["template"] = cls.template.id
+            cls.testdata["small"]["zoneid"] = cls.zone.id
+            cls.testdata["small"]["template"] = cls.template.id
 
             cls.service_offering = ServiceOffering.create(
                 cls.api_client,
-                cls.services["service_offering"]
+                cls.testdata["service_offering"]
             )
             cls._cleanup.append(cls.service_offering)
 
             # Spawn an instance in that network
             cls.virtual_machine = VirtualMachine.create(
                 cls.api_client,
-                cls.services["virtual_machine"],
+                cls.testdata["small"],
                 accountid=cls.account.name,
                 domainid=cls.account.domainid,
                 serviceofferingid=cls.service_offering.id,
@@ -1320,7 +1188,6 @@ class TestLbAlgoRrSb(cloudstackTestCase):
             self.debug("Cleaning up the resources")
             # Clean up, terminate the created network offerings
             cleanup_resources(self.apiclient, self.cleanup)
-            self.debug("Cleanup complete!")
         except Exception as e:
             raise Exception("Warning: Exception during cleanup : %s" % e)
         return
@@ -1344,10 +1211,10 @@ class TestLbAlgoRrSb(cloudstackTestCase):
             "Creating LB rule for IP address: %s with round robin algo" %
             self.public_ip.ipaddress.ipaddress)
 
-        self.services["lbrule"]["alg"] = 'roundrobin'
+        self.testdata["lbrule"]["alg"] = 'roundrobin'
         lb_rule = LoadBalancerRule.create(
             self.apiclient,
-            self.services["lbrule"],
+            self.testdata["lbrule"],
             ipaddressid=self.public_ip.ipaddress.id,
             accountid=self.account.name,
             networkid=self.network.id
@@ -1372,13 +1239,13 @@ class TestLbAlgoRrSb(cloudstackTestCase):
         self.debug(
             "SSH into Netscaler to check whether algorithm is configured properly or not?")
         self.debug("SSH into netscaler: %s" %
-                   self.services["netscaler"]["ipaddress"])
+                   self.testdata["configurableData"]["netscaler"]["ipaddress"])
         try:
             ssh_client = SshClient(
-                self.services["netscaler"]["ipaddress"],
-                self.services["netscaler"]["port"],
-                self.services["netscaler"]["username"],
-                self.services["netscaler"]["password"],
+                self.testdata["configurableData"]["netscaler"]["ipaddress"],
+                self.testdata["configurableData"]["netscaler"]["port"],
+                self.testdata["configurableData"]["netscaler"]["username"],
+                self.testdata["configurableData"]["netscaler"]["password"],
             )
             cmd = "show lb vserver Cloud-VirtualServer-%s-%s" % (
                 self.public_ip.ipaddress.ipaddress,
@@ -1395,7 +1262,7 @@ class TestLbAlgoRrSb(cloudstackTestCase):
             )
         except Exception as e:
             self.fail("SSH Access failed for %s: %s" %
-                      (self.services["netscaler"]["ipaddress"], e))
+                      (self.testdata["configurableData"]["netscaler"]["ipaddress"], e))
 
         self.debug(
             "Updating LB rule: %s with new algorithm: %s" % (
@@ -1406,13 +1273,13 @@ class TestLbAlgoRrSb(cloudstackTestCase):
         self.debug(
             "SSH into Netscaler to check whether algorithm is configured properly or not?")
         self.debug("SSH into netscaler: %s" %
-                   self.services["netscaler"]["ipaddress"])
+                   self.testdata["configurableData"]["netscaler"]["ipaddress"])
         try:
             ssh_client = SshClient(
-                self.services["netscaler"]["ipaddress"],
-                self.services["netscaler"]["port"],
-                self.services["netscaler"]["username"],
-                self.services["netscaler"]["password"],
+                self.testdata["configurableData"]["netscaler"]["ipaddress"],
+                self.testdata["configurableData"]["netscaler"]["port"],
+                self.testdata["configurableData"]["netscaler"]["username"],
+                self.testdata["configurableData"]["netscaler"]["password"],
             )
             cmd = "show lb vserver Cloud-VirtualServer-%s-%s" % (
                 self.public_ip.ipaddress.ipaddress,
@@ -1430,7 +1297,7 @@ class TestLbAlgoRrSb(cloudstackTestCase):
 
         except Exception as e:
             self.fail("SSH Access failed for %s: %s" %
-                      (self.services["netscaler"]["ipaddress"], e))
+                      (self.testdata["configurableData"]["netscaler"]["ipaddress"], e))
         return
 
 
@@ -1442,30 +1309,28 @@ class TestLbAlgoSbRr(cloudstackTestCase):
         cls.testClient = super(TestLbAlgoSbRr, cls).getClsTestClient()
         cls.api_client = cls.testClient.getApiClient()
 
-        cls.services = Services().services
+        # Fill testdata from the external config file
+        cls.testdata = cls.testClient.getParsedTestDataConfig()
+        # Get Zone, Domain and templates
+
         # Get Zone, Domain and templates
         cls.domain = get_domain(cls.api_client)
         cls.zone = get_zone(cls.api_client, cls.testClient.getZoneForTests())
         cls.template = get_template(
             cls.api_client,
             cls.zone.id,
-            cls.services["ostype"]
+            cls.testdata["ostype"]
         )
 
-        response = GetNetscalerInfoFromConfig(
-            cls.config
-        )
-        assert response[0] is not None, response[1]
-        cls.services["netscaler"] = response[0]
-        cls.services["netscaler"]["lbdevicededicated"] = False
+        cls.testdata["configurableData"]["netscaler"]["lbdevicededicated"] = False
 
         try:
-            cls.netscaler = add_netscaler(cls.api_client, cls.zone.id, cls.services["netscaler"])
+            cls.netscaler = add_netscaler(cls.api_client, cls.zone.id, cls.testdata["configurableData"]["netscaler"])
             cls._cleanup.append(cls.netscaler)
             cls.network_offering = NetworkOffering.create(
                 cls.api_client,
-                cls.services["network_offering"],
-                conservemode=True
+                cls.testdata["nw_off_isolated_netscaler"],
+                conservemode="True"
             )
             cls._cleanup.append(cls.network_offering)
             # Enable Network offering
@@ -1473,32 +1338,32 @@ class TestLbAlgoSbRr(cloudstackTestCase):
 
             cls.account = Account.create(
                 cls.api_client,
-                cls.services["account"],
+                cls.testdata["account"],
                 admin=True,
                 domainid=cls.domain.id
             )
             cls._cleanup.insert(0, cls.account)
             cls.network = Network.create(
                 cls.api_client,
-                cls.services["network"],
+                cls.testdata["network"],
                 accountid=cls.account.name,
                 domainid=cls.account.domainid,
                 networkofferingid=cls.network_offering.id,
                 zoneid=cls.zone.id
             )
-            cls.services["virtual_machine"]["zoneid"] = cls.zone.id
-            cls.services["virtual_machine"]["template"] = cls.template.id
+            cls.testdata["small"]["zoneid"] = cls.zone.id
+            cls.testdata["small"]["template"] = cls.template.id
 
             cls.service_offering = ServiceOffering.create(
                 cls.api_client,
-                cls.services["service_offering"]
+                cls.testdata["service_offering"]
             )
             cls._cleanup.append(cls.service_offering)
 
             # Spawn an instance in that network
             cls.virtual_machine = VirtualMachine.create(
                 cls.api_client,
-                cls.services["virtual_machine"],
+                cls.testdata["small"],
                 accountid=cls.account.name,
                 domainid=cls.account.domainid,
                 serviceofferingid=cls.service_offering.id,
@@ -1537,7 +1402,6 @@ class TestLbAlgoSbRr(cloudstackTestCase):
             self.debug("Cleaning up the resources")
             # Clean up, terminate the created network offerings
             cleanup_resources(self.apiclient, self.cleanup)
-            self.debug("Cleanup complete!")
         except Exception as e:
             raise Exception("Warning: Exception during cleanup : %s" % e)
         return
@@ -1561,10 +1425,10 @@ class TestLbAlgoSbRr(cloudstackTestCase):
             "Creating LB rule for IP address: %s with source algo" %
             self.public_ip.ipaddress.ipaddress)
 
-        self.services["lbrule"]["alg"] = 'source'
+        self.testdata["lbrule"]["alg"] = 'source'
         lb_rule = LoadBalancerRule.create(
             self.apiclient,
-            self.services["lbrule"],
+            self.testdata["lbrule"],
             ipaddressid=self.public_ip.ipaddress.id,
             accountid=self.account.name,
             networkid=self.network.id
@@ -1591,13 +1455,13 @@ class TestLbAlgoSbRr(cloudstackTestCase):
         self.debug(
             "SSH into Netscaler to check whether algorithm is configured properly or not?")
         self.debug("SSH into netscaler: %s" %
-                   self.services["netscaler"]["ipaddress"])
+                   self.testdata["configurableData"]["netscaler"]["ipaddress"])
         try:
             ssh_client = SshClient(
-                self.services["netscaler"]["ipaddress"],
-                self.services["netscaler"]["port"],
-                self.services["netscaler"]["username"],
-                self.services["netscaler"]["password"],
+                self.testdata["configurableData"]["netscaler"]["ipaddress"],
+                self.testdata["configurableData"]["netscaler"]["port"],
+                self.testdata["configurableData"]["netscaler"]["username"],
+                self.testdata["configurableData"]["netscaler"]["password"],
             )
             cmd = "show lb vserver Cloud-VirtualServer-%s-%s" % (
                 self.public_ip.ipaddress.ipaddress,
@@ -1615,7 +1479,7 @@ class TestLbAlgoSbRr(cloudstackTestCase):
 
         except Exception as e:
             self.fail("SSH Access failed for %s: %s" %
-                      (self.services["netscaler"]["ipaddress"], e))
+                      (self.testdata["configurableData"]["netscaler"]["ipaddress"], e))
 
         self.debug(
             "Updating LB rule: %s with new algorithm: %s" % (
@@ -1626,13 +1490,13 @@ class TestLbAlgoSbRr(cloudstackTestCase):
         self.debug(
             "SSH into Netscaler to check whether algorithm is configured properly or not?")
         self.debug("SSH into netscaler: %s" %
-                   self.services["netscaler"]["ipaddress"])
+                   self.testdata["configurableData"]["netscaler"]["ipaddress"])
         try:
             ssh_client = SshClient(
-                self.services["netscaler"]["ipaddress"],
-                self.services["netscaler"]["port"],
-                self.services["netscaler"]["username"],
-                self.services["netscaler"]["password"],
+                self.testdata["configurableData"]["netscaler"]["ipaddress"],
+                self.testdata["configurableData"]["netscaler"]["port"],
+                self.testdata["configurableData"]["netscaler"]["username"],
+                self.testdata["configurableData"]["netscaler"]["password"],
             )
             cmd = "show lb vserver Cloud-VirtualServer-%s-%s" % (
                 self.public_ip.ipaddress.ipaddress,
@@ -1649,7 +1513,7 @@ class TestLbAlgoSbRr(cloudstackTestCase):
             )
         except Exception as e:
             self.fail("SSH Access failed for %s: %s" %
-                      (self.services["netscaler"]["ipaddress"], e))
+                      (self.testdata["configurableData"]["netscaler"]["ipaddress"], e))
         return
 
 
@@ -1661,30 +1525,26 @@ class TestLbAlgoSbLc(cloudstackTestCase):
         cls.testClient = super(TestLbAlgoSbLc, cls).getClsTestClient()
         cls.api_client = cls.testClient.getApiClient()
 
-        cls.services = Services().services
+        # Fill testdata from the external config file
+        cls.testdata = cls.testClient.getParsedTestDataConfig()
         # Get Zone, Domain and templates
         cls.domain = get_domain(cls.api_client)
         cls.zone = get_zone(cls.api_client, cls.testClient.getZoneForTests())
         cls.template = get_template(
             cls.api_client,
             cls.zone.id,
-            cls.services["ostype"]
+            cls.testdata["ostype"]
         )
 
-        response = GetNetscalerInfoFromConfig(
-            cls.config
-        )
-        assert response[0] is not None, response[1]
-        cls.services["netscaler"] = response[0]
-        cls.services["netscaler"]["lbdevicededicated"] = False
+        cls.testdata["configurableData"]["netscaler"]["lbdevicededicated"] = False
 
         try:
-            cls.netscaler = add_netscaler(cls.api_client, cls.zone.id, cls.services["netscaler"])
+            cls.netscaler = add_netscaler(cls.api_client, cls.zone.id, cls.testdata["configurableData"]["netscaler"])
             cls._cleanup.append(cls.netscaler)
             cls.network_offering = NetworkOffering.create(
                 cls.api_client,
-                cls.services["network_offering"],
-                conservemode=True
+                cls.testdata["nw_off_isolated_netscaler"],
+                conservemode="True"
             )
             cls._cleanup.append(cls.network_offering)
             # Enable Network offering
@@ -1692,32 +1552,32 @@ class TestLbAlgoSbLc(cloudstackTestCase):
 
             cls.account = Account.create(
                 cls.api_client,
-                cls.services["account"],
+                cls.testdata["account"],
                 admin=True,
                 domainid=cls.domain.id
             )
             cls._cleanup.insert(0, cls.account)
             cls.network = Network.create(
                 cls.api_client,
-                cls.services["network"],
+                cls.testdata["network"],
                 accountid=cls.account.name,
                 domainid=cls.account.domainid,
                 networkofferingid=cls.network_offering.id,
                 zoneid=cls.zone.id
             )
-            cls.services["virtual_machine"]["zoneid"] = cls.zone.id
-            cls.services["virtual_machine"]["template"] = cls.template.id
+            cls.testdata["small"]["zoneid"] = cls.zone.id
+            cls.testdata["small"]["template"] = cls.template.id
 
             cls.service_offering = ServiceOffering.create(
                 cls.api_client,
-                cls.services["service_offering"]
+                cls.testdata["service_offering"]
             )
             cls._cleanup.append(cls.service_offering)
 
             # Spawn an instance in that network
             cls.virtual_machine = VirtualMachine.create(
                 cls.api_client,
-                cls.services["virtual_machine"],
+                cls.testdata["small"],
                 accountid=cls.account.name,
                 domainid=cls.account.domainid,
                 serviceofferingid=cls.service_offering.id,
@@ -1756,7 +1616,6 @@ class TestLbAlgoSbLc(cloudstackTestCase):
             self.debug("Cleaning up the resources")
             # Clean up, terminate the created network offerings
             cleanup_resources(self.apiclient, self.cleanup)
-            self.debug("Cleanup complete!")
         except Exception as e:
             raise Exception("Warning: Exception during cleanup : %s" % e)
         return
@@ -1780,10 +1639,10 @@ class TestLbAlgoSbLc(cloudstackTestCase):
             "Creating LB rule for IP address: %s with source algo" %
             self.public_ip.ipaddress.ipaddress)
 
-        self.services["lbrule"]["alg"] = 'source'
+        self.testdata["lbrule"]["alg"] = 'source'
         lb_rule = LoadBalancerRule.create(
             self.apiclient,
-            self.services["lbrule"],
+            self.testdata["lbrule"],
             ipaddressid=self.public_ip.ipaddress.id,
             accountid=self.account.name,
             networkid=self.network.id
@@ -1810,13 +1669,13 @@ class TestLbAlgoSbLc(cloudstackTestCase):
         self.debug(
             "SSH into Netscaler to check whether algorithm is configured properly or not?")
         self.debug("SSH into netscaler: %s" %
-                   self.services["netscaler"]["ipaddress"])
+                   self.testdata["configurableData"]["netscaler"]["ipaddress"])
         try:
             ssh_client = SshClient(
-                self.services["netscaler"]["ipaddress"],
-                self.services["netscaler"]["port"],
-                self.services["netscaler"]["username"],
-                self.services["netscaler"]["password"],
+                self.testdata["configurableData"]["netscaler"]["ipaddress"],
+                self.testdata["configurableData"]["netscaler"]["port"],
+                self.testdata["configurableData"]["netscaler"]["username"],
+                self.testdata["configurableData"]["netscaler"]["password"],
             )
             cmd = "show lb vserver Cloud-VirtualServer-%s-%s" % (
                 self.public_ip.ipaddress.ipaddress,
@@ -1834,7 +1693,7 @@ class TestLbAlgoSbLc(cloudstackTestCase):
 
         except Exception as e:
             self.fail("SSH Access failed for %s: %s" %
-                      (self.services["netscaler"]["ipaddress"], e))
+                      (self.testdata["configurableData"]["netscaler"]["ipaddress"], e))
         self.debug(
             "Updating LB rule: %s with new algorithm: %s" % (
                 lb_rule.name,
@@ -1844,13 +1703,13 @@ class TestLbAlgoSbLc(cloudstackTestCase):
         self.debug(
             "SSH into Netscaler to check whether algorithm is configured properly or not?")
         self.debug("SSH into netscaler: %s" %
-                   self.services["netscaler"]["ipaddress"])
+                   self.testdata["configurableData"]["netscaler"]["ipaddress"])
         try:
             ssh_client = SshClient(
-                self.services["netscaler"]["ipaddress"],
-                self.services["netscaler"]["port"],
-                self.services["netscaler"]["username"],
-                self.services["netscaler"]["password"],
+                self.testdata["configurableData"]["netscaler"]["ipaddress"],
+                self.testdata["configurableData"]["netscaler"]["port"],
+                self.testdata["configurableData"]["netscaler"]["username"],
+                self.testdata["configurableData"]["netscaler"]["password"],
             )
             cmd = "show lb vserver Cloud-VirtualServer-%s-%s" % (
                 self.public_ip.ipaddress.ipaddress,
@@ -1867,7 +1726,7 @@ class TestLbAlgoSbLc(cloudstackTestCase):
             )
         except Exception as e:
             self.fail("SSH Access failed for %s: %s" %
-                      (self.services["netscaler"]["ipaddress"], e))
+                      (self.testdata["configurableData"]["netscaler"]["ipaddress"], e))
         return
 
 
@@ -1879,30 +1738,28 @@ class TestLbAlgoLcSb(cloudstackTestCase):
         cls.testClient = super(TestLbAlgoLcSb, cls).getClsTestClient()
         cls.api_client = cls.testClient.getApiClient()
 
-        cls.services = Services().services
+        # Fill testdata from the external config file
+        cls.testdata = cls.testClient.getParsedTestDataConfig()
+        # Get Zone, Domain and templates
+
         # Get Zone, Domain and templates
         cls.domain = get_domain(cls.api_client)
         cls.zone = get_zone(cls.api_client, cls.testClient.getZoneForTests())
         cls.template = get_template(
             cls.api_client,
             cls.zone.id,
-            cls.services["ostype"]
+            cls.testdata["ostype"]
         )
 
-        response = GetNetscalerInfoFromConfig(
-            cls.config
-        )
-        assert response[0] is not None, response[1]
-        cls.services["netscaler"] = response[0]
-        cls.services["netscaler"]["lbdevicededicated"] = False
+        cls.testdata["configurableData"]["netscaler"]["lbdevicededicated"] = False
 
         try:
-            cls.netscaler = add_netscaler(cls.api_client, cls.zone.id, cls.services["netscaler"])
+            cls.netscaler = add_netscaler(cls.api_client, cls.zone.id, cls.testdata["configurableData"]["netscaler"])
             cls._cleanup.append(cls.netscaler)
             cls.network_offering = NetworkOffering.create(
                 cls.api_client,
-                cls.services["network_offering"],
-                conservemode=True
+                cls.testdata["nw_off_isolated_netscaler"],
+                conservemode="True"
             )
             cls._cleanup.append(cls.network_offering)
             # Enable Network offering
@@ -1910,32 +1767,32 @@ class TestLbAlgoLcSb(cloudstackTestCase):
 
             cls.account = Account.create(
                 cls.api_client,
-                cls.services["account"],
+                cls.testdata["account"],
                 admin=True,
                 domainid=cls.domain.id
             )
             cls._cleanup.insert(0, cls.account)
             cls.network = Network.create(
                 cls.api_client,
-                cls.services["network"],
+                cls.testdata["network"],
                 accountid=cls.account.name,
                 domainid=cls.account.domainid,
                 networkofferingid=cls.network_offering.id,
                 zoneid=cls.zone.id
             )
-            cls.services["virtual_machine"]["zoneid"] = cls.zone.id
-            cls.services["virtual_machine"]["template"] = cls.template.id
+            cls.testdata["small"]["zoneid"] = cls.zone.id
+            cls.testdata["small"]["template"] = cls.template.id
 
             cls.service_offering = ServiceOffering.create(
                 cls.api_client,
-                cls.services["service_offering"]
+                cls.testdata["service_offering"]
             )
             cls._cleanup.append(cls.service_offering)
 
             # Spawn an instance in that network
             cls.virtual_machine = VirtualMachine.create(
                 cls.api_client,
-                cls.services["virtual_machine"],
+                cls.testdata["small"],
                 accountid=cls.account.name,
                 domainid=cls.account.domainid,
                 serviceofferingid=cls.service_offering.id,
@@ -1973,7 +1830,6 @@ class TestLbAlgoLcSb(cloudstackTestCase):
             self.debug("Cleaning up the resources")
             # Clean up, terminate the created network offerings
             cleanup_resources(self.apiclient, self.cleanup)
-            self.debug("Cleanup complete!")
         except Exception as e:
             raise Exception("Warning: Exception during cleanup : %s" % e)
         return
@@ -1997,10 +1853,10 @@ class TestLbAlgoLcSb(cloudstackTestCase):
             "Creating LB rule for IP address: %s with leastconn algo" %
             self.public_ip.ipaddress.ipaddress)
 
-        self.services["lbrule"]["alg"] = 'leastconn'
+        self.testdata["lbrule"]["alg"] = 'leastconn'
         lb_rule = LoadBalancerRule.create(
             self.apiclient,
-            self.services["lbrule"],
+            self.testdata["lbrule"],
             ipaddressid=self.public_ip.ipaddress.id,
             accountid=self.account.name,
             networkid=self.network.id
@@ -2026,13 +1882,13 @@ class TestLbAlgoLcSb(cloudstackTestCase):
         self.debug(
             "SSH into Netscaler to check whether algorithm is configured properly or not?")
         self.debug("SSH into netscaler: %s" %
-                   self.services["netscaler"]["ipaddress"])
+                   self.testdata["configurableData"]["netscaler"]["ipaddress"])
         try:
             ssh_client = SshClient(
-                self.services["netscaler"]["ipaddress"],
-                self.services["netscaler"]["port"],
-                self.services["netscaler"]["username"],
-                self.services["netscaler"]["password"],
+                self.testdata["configurableData"]["netscaler"]["ipaddress"],
+                self.testdata["configurableData"]["netscaler"]["port"],
+                self.testdata["configurableData"]["netscaler"]["username"],
+                self.testdata["configurableData"]["netscaler"]["password"],
             )
             cmd = "show lb vserver Cloud-VirtualServer-%s-%s" % (
                 self.public_ip.ipaddress.ipaddress,
@@ -2049,7 +1905,7 @@ class TestLbAlgoLcSb(cloudstackTestCase):
             )
         except Exception as e:
             self.fail("SSH Access failed for %s: %s" %
-                      (self.services["netscaler"]["ipaddress"], e))
+                      (self.testdata["configurableData"]["netscaler"]["ipaddress"], e))
 
         self.debug(
             "Updating LB rule: %s with new algorithm: %s" % (
@@ -2060,13 +1916,13 @@ class TestLbAlgoLcSb(cloudstackTestCase):
         self.debug(
             "SSH into Netscaler to check whether algorithm is configured properly or not?")
         self.debug("SSH into netscaler: %s" %
-                   self.services["netscaler"]["ipaddress"])
+                   self.testdata["configurableData"]["netscaler"]["ipaddress"])
         try:
             ssh_client = SshClient(
-                self.services["netscaler"]["ipaddress"],
-                self.services["netscaler"]["port"],
-                self.services["netscaler"]["username"],
-                self.services["netscaler"]["password"],
+                self.testdata["configurableData"]["netscaler"]["ipaddress"],
+                self.testdata["configurableData"]["netscaler"]["port"],
+                self.testdata["configurableData"]["netscaler"]["username"],
+                self.testdata["configurableData"]["netscaler"]["password"],
             )
             cmd = "show lb vserver Cloud-VirtualServer-%s-%s" % (
                 self.public_ip.ipaddress.ipaddress,
@@ -2084,5 +1940,5 @@ class TestLbAlgoLcSb(cloudstackTestCase):
 
         except Exception as e:
             self.fail("SSH Access failed for %s: %s" %
-                      (self.services["netscaler"]["ipaddress"], e))
+                      (self.testdata["configurableData"]["netscaler"]["ipaddress"], e))
         return


Mime
View raw message