# Licensed to the Apache Software Foundation (ASF) under one # or more contributor license agreements. See the NOTICE file # distributed with this work for additional information # regarding copyright ownership. The ASF licenses this file # to you under the Apache License, Version 2.0 (the # "License"); you may not use this file except in compliance # with the License. You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, # software distributed under the License is distributed on an # "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY # KIND, either express or implied. See the License for the # specific language governing permissions and limitations # under the License. """ Tests for configuring Internal Load Balancing Rules. """ import logging import math import time from nose.plugins.attrib import attr # Import Local Modules from marvin.cloudstackTestCase import cloudstackTestCase from marvin.codes import FAILED from marvin.lib.base import ( Account, Configurations, VPC, VpcOffering, ServiceOffering, NetworkOffering, Network, PublicIPAddress, NATRule, ApplicationLoadBalancer, VirtualMachine, NetworkACLList ) from marvin.lib.common import ( get_zone, get_domain, get_test_template, list_network_offerings) from marvin.sshClient import SshClient class Services: """Test VPC network services - Port Forwarding Rules Test Data Class. """ 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", }, "host1": None, "host2": None, "compute_offering": { "name": "Tiny Instance", "displaytext": "Tiny Instance", "cpunumber": 1, "cpuspeed": 100, "memory": 128, }, "network_offering": { "name": 'VPC Network offering', "displaytext": 'VPC Network', "guestiptype": 'Isolated', "supportedservices": 'Vpn,Dhcp,Dns,SourceNat,Lb,PortForwarding,UserData,StaticNat,NetworkACL', "traffictype": 'GUEST', "availability": 'Optional', "useVpc": 'on', "serviceProviderList": { "Vpn": 'VpcVirtualRouter', "Dhcp": 'VpcVirtualRouter', "Dns": 'VpcVirtualRouter', "SourceNat": 'VpcVirtualRouter', "Lb": 'VpcVirtualRouter', "PortForwarding": 'VpcVirtualRouter', "UserData": 'VpcVirtualRouter', "StaticNat": 'VpcVirtualRouter', "NetworkACL": 'VpcVirtualRouter' }, }, "network_offering_internal_lb": { "name": 'VPC Network Internal Lb offering', "displaytext": 'VPC Network internal lb', "guestiptype": 'Isolated', "supportedservices": 'Dhcp,Dns,SourceNat,PortForwarding,UserData,StaticNat,NetworkACL,Lb', "traffictype": 'GUEST', "availability": 'Optional', "useVpc": 'on', "serviceCapabilityList": { "Lb": { "SupportedLbIsolation": 'dedicated', "lbSchemes": 'internal' } }, "serviceProviderList": { "Dhcp": 'VpcVirtualRouter', "Dns": 'VpcVirtualRouter', "SourceNat": 'VpcVirtualRouter', "PortForwarding": 'VpcVirtualRouter', "UserData": 'VpcVirtualRouter', "StaticNat": 'VpcVirtualRouter', "NetworkACL": 'VpcVirtualRouter', "Lb": 'InternalLbVm' }, "egress_policy": "true", }, "redundant_vpc_offering": { "name": 'Redundant VPC off', "displaytext": 'Redundant VPC off', "supportedservices": 'Dhcp,Dns,SourceNat,PortForwarding,Vpn,Lb,UserData,StaticNat', "serviceProviderList": { "Vpn": 'VpcVirtualRouter', "Dhcp": 'VpcVirtualRouter', "Dns": 'VpcVirtualRouter', "SourceNat": 'VpcVirtualRouter', "Lb": ["InternalLbVm", "VpcVirtualRouter"], "PortForwarding": 'VpcVirtualRouter', "UserData": 'VpcVirtualRouter', "StaticNat": 'VpcVirtualRouter', "NetworkACL": 'VpcVirtualRouter' }, "serviceCapabilityList": { "SourceNat": { "RedundantRouter": 'true' }, }, }, "vpc_offering": { "name": "VPC off", "displaytext": "VPC off", "supportedservices": "Dhcp,Dns,SourceNat,PortForwarding,Vpn,Lb,UserData,StaticNat,NetworkACL", "serviceProviderList": { "Vpn": 'VpcVirtualRouter', "Dhcp": 'VpcVirtualRouter', "Dns": 'VpcVirtualRouter', "SourceNat": 'VpcVirtualRouter', "Lb": ["InternalLbVm", "VpcVirtualRouter"], "PortForwarding": 'VpcVirtualRouter', "UserData": 'VpcVirtualRouter', "StaticNat": 'VpcVirtualRouter', "NetworkACL": 'VpcVirtualRouter' }, }, "vpc": { "name": "TestVPC", "displaytext": "TestVPC", "cidr": '10.1.0.0/16' }, "network": { "name": "Test Network", "displaytext": "Test Network", "netmask": '255.255.255.0' }, "lbrule": { "name": "SSH", "alg": "roundrobin", # Algorithm used for load balancing "privateport": 22, "publicport": 2222, "openfirewall": False, "startport": 22, "endport": 2222, "protocol": "TCP", "cidrlist": '0.0.0.0/0', }, "lbrule_http": { "name": "HTTP", "alg": "roundrobin", # Algorithm used for load balancing "privateport": 80, "publicport": 80, "openfirewall": False, "startport": 80, "endport": 80, "protocol": "TCP", "cidrlist": '0.0.0.0/0', }, "natrule": { "protocol": "TCP", "cidrlist": '0.0.0.0/0', }, "http_rule": { "privateport": 80, "publicport": 80, "startport": 80, "endport": 80, "cidrlist": '0.0.0.0/0', "protocol": "TCP" }, "virtual_machine": { "displayname": "Test VM", "username": "root", "password": "password", "ssh_port": 22, "privateport": 22, "publicport": 22, "protocol": 'TCP', } } class TestInternalLb(cloudstackTestCase): """Test Internal LB """ @classmethod def setUpClass(cls): cls.logger = logging.getLogger('TestInternalLb') cls.stream_handler = logging.StreamHandler() cls.logger.setLevel(logging.DEBUG) cls.logger.addHandler(cls.stream_handler) testClient = super(TestInternalLb, cls).getClsTestClient() cls.apiclient = testClient.getApiClient() cls.services = Services().services cls.zone = get_zone(cls.apiclient, testClient.getZoneForTests()) cls.domain = get_domain(cls.apiclient) cls._cleanup = [] cls.logger.debug("Creating compute offering: %s" % cls.services["compute_offering"]["name"]) cls.compute_offering = ServiceOffering.create( cls.apiclient, cls.services["compute_offering"] ) cls._cleanup.append(cls.compute_offering) cls.account = Account.create( cls.apiclient, services=cls.services["account"]) cls._cleanup.append(cls.account) cls.hypervisor = testClient.getHypervisorInfo() cls.template = get_test_template( cls.apiclient, cls.zone.id, cls.hypervisor ) if cls.template == FAILED: assert False, "get_test_template() failed to return template" cls.logger.debug("Successfully created account: %s, id: \ %s" % (cls.account.name, cls.account.id)) return def setUp(self): self.cleanup = [] def get_networkoffering_state(self, offering): result = list_network_offerings(self.apiclient, id=offering.id) if result: offering = result[0] return offering.state else: return None def create_and_enable_network_serviceoffering(self, services): try: # Create offering offering = NetworkOffering.create( self.apiclient, services, conservemode=False) self.assertIsNotNone(offering, "Failed to create network offering") self.logger.debug("Created network offering: %s" % offering.id) if offering: # Enable offeringq offering.update(self.apiclient, state="Enabled") self.assertEqual(self.get_networkoffering_state( offering), "Enabled", "Failed to enable network offering") self.logger.debug("Enabled network offering: %s" % offering.id) self.cleanup.insert(0, offering) return offering except Exception as e: self.fail("Failed to create and enable network offering due to %s" % e) def create_vpc(self, vpc_offering): self.logger.debug("Creating VPC using offering ==> ID %s / Name %s" % (vpc_offering.id, vpc_offering.name)) try: vpc = VPC.create( apiclient=self.apiclient, services=self.services["vpc"], networkDomain="vpc.internallb", vpcofferingid=vpc_offering.id, zoneid=self.zone.id, account=self.account.name, domainid=self.domain.id ) self.assertIsNotNone(vpc, "VPC creation failed") self.logger.debug("Created VPC %s" % vpc.id) self.cleanup.append(vpc) return vpc except Exception as e: self.fail("Failed to create VPC due to %s" % e) def create_network_tier(self, name, vpcid, gateway, network_offering): self.services["network"]["name"] = name self.services["network"]["displaytext"] = name default_acl = NetworkACLList.list(self.apiclient, name="default_allow")[0] try: network = Network.create( apiclient=self.apiclient, services=self.services["network"], accountid=self.account.name, domainid=self.domain.id, networkofferingid=network_offering.id, zoneid=self.zone.id, vpcid=vpcid, gateway=gateway, netmask=self.services["network"]["netmask"], aclid=default_acl.id ) self.assertIsNotNone(network, "Network failed to create") self.logger.debug( "Created network %s in VPC %s" % (network.id, vpcid)) self.cleanup.append(network) return network except Exception as e: raise Exception("Create network failed: %s" % e) def deployvm_in_network(self, vpc, networkid): try: self.services["virtual_machine"]["networkids"] = networkid vm = VirtualMachine.create(self.apiclient, services=self.services["virtual_machine"], templateid=self.template.id, zoneid=self.zone.id, accountid=self.account.name, domainid=self.domain.id, serviceofferingid=self.compute_offering.id, hypervisor=self.hypervisor ) self.assertIsNotNone( vm, "Failed to deploy vm in network: %s" % networkid) self.assertTrue(vm.state == 'Running', "VM is not running") self.logger.debug("Deployed VM id: %s in VPC %s" % (vm.id, vpc.id)) self.cleanup.append(vm) return vm except Exception as e: raise Exception("Deployment failed of VM: %s" % e) def create_internal_loadbalancer(self, intport, sport, algorithm, networkid): try: # 5) Create an Internal Load Balancer applb = ApplicationLoadBalancer.create(self.apiclient, services=self.services, name="lbrule", sourceport=sport, instanceport=intport, algorithm=algorithm, scheme="Internal", sourcenetworkid=networkid, networkid=networkid ) self.assertIsNotNone(applb, "Failed to create loadbalancer") self.cleanup.append(applb) self.logger.debug("Created LB %s in VPC" % applb.id) return applb except Exception as e: self.fail(e) def acquire_publicip(self, vpc, network): self.logger.debug( "Associating public IP for network: %s" % network.name) public_ip = PublicIPAddress.create( self.apiclient, accountid=self.account.name, zoneid=self.zone.id, domainid=self.account.domainid, networkid=network.id, vpcid=vpc.id ) self.assertIsNotNone(public_ip, "Failed to acquire public IP") self.cleanup.append(public_ip) self.logger.debug("Associated %s with network %s" % ( public_ip.ipaddress.ipaddress, network.id )) return public_ip def create_natrule(self, vpc, vm, public_port, private_port, public_ip, network, services=None): self.logger.debug("Creating NAT rule in network for vm with public IP") if not services: self.services["natrule"]["privateport"] = private_port self.services["natrule"]["publicport"] = public_port self.services["natrule"]["startport"] = public_port self.services["natrule"]["endport"] = public_port services = self.services["natrule"] nat_rule = NATRule.create( apiclient=self.apiclient, services=services, ipaddressid=public_ip.ipaddress.id, virtual_machine=vm, networkid=network.id ) self.assertIsNotNone( nat_rule, "Failed to create NAT Rule for %s" % public_ip.ipaddress.ipaddress) self.cleanup.append(nat_rule) self.logger.debug( "Adding NetworkACL rules to make NAT rule accessible") vm.ssh_ip = nat_rule.ipaddress vm.public_ip = nat_rule.ipaddress vm.public_port = int(public_port) return nat_rule def get_ssh_client(self, vm, retries): """ Setup ssh client connection and return connection vm requires attributes public_ip, public_port, username, password """ ssh_client = None try: ssh_client = SshClient( vm.public_ip, vm.public_port, vm.username, vm.password, retries ) except Exception as e: self.fail("Unable to create ssh connection: " % e) self.assertIsNotNone( ssh_client, "Failed to setup ssh connection to vm=%s on public_ip=%s" % (vm.name, vm.public_ip)) return ssh_client def setup_http_daemon(self, vm): """ Creates a index.html in /tmp with private ip as content and starts httpd daemon on all interfaces port 80 serving /tmp/ (only tested on the busybox based tiny vm) vm requires attributes public_ip, public_port, username, password """ commands = [ # using ip address instead of hostname "/sbin/ip addr show eth0 |grep 'inet '| cut -f6 -d' ' > /tmp/index.html", "/usr/sbin/httpd -v -p 0.0.0.0:80 -h /tmp/" ] try: ssh_client = self.get_ssh_client(vm, 8) for cmd in commands: ssh_client.execute(cmd) except Exception as e: self.fail("Failed to ssh into vm: %s due to %s" % (vm, e)) def run_ssh_test_accross_hosts(self, clienthost, lb_address, max_requests=30): """ Uses clienthost to run wgets on hosts port 80 expects a unique output from url. returns a list of outputs to evaluate. """ # Setup ssh connection ssh_client = self.get_ssh_client(clienthost, 8) self.logger.debug(ssh_client) results = [] try: for x in range(0, max_requests): cmd_test_http = "curl --connect-timeout 3 -L http://" + \ lb_address + "/ 2>/dev/null" # self.debug( "SSH into VM public address: %s and port: %s" # %(.public_ip, vm.public_port)) results.append(ssh_client.execute(cmd_test_http)[0]) self.logger.debug(results) except Exception as e: self.fail("%s: SSH failed for VM with IP Address: %s" % (e, clienthost.public_ip)) return results def get_std_deviation(self, data): """ Calculates and outputs a mean, variance and standard deviation from an input list of values """ num_val = len(data) mean = sum(data) / num_val sqrt = [math.pow(abs(x - mean), 2) for x in data] variance = (sum(sqrt) / num_val - 1) stddev = math.sqrt(variance) return (mean, variance, stddev) def evaluate_http_responses(self, responses, algorithm): """ Evaluates response values from http test and verifies algorithm used""" if algorithm == 'roundrobin': # get a list of unique values unique_values = set(responses) # count the occurence of each value in the responses dataset = [responses.count(value) for value in unique_values] if len(set(dataset)) == 1: # all values in dataset are equal, perfect result distribution # woohoo! self.logger.debug( "HTTP responses are evenly distributed! SUCCESS!") return True else: # calculate mean, var, stddev on dataset mean, variance, stddev = self.get_std_deviation(dataset) for value in dataset: # determine how much value difference is there from the # mean difference = abs(value - mean) # difference between response count of a host and the mean # should be less than the standard deviation self.assertLess( difference, stddev, "Internal LB RoundRobin test Failed because http responsest are not evenly distributed") self.logger.debug( "Response distribution count: %d difference to mean: %d within standard deviation: %d" % (value, mean, stddev)) return True @attr(tags=["smoke", "advanced"], required_hardware="true") def test_01_internallb_roundrobin_1VPC_3VM_HTTP_port80(self): """ Test create, assign, remove of an Internal LB with roundrobin http traffic to 3 vm's in a Single VPC """ self.logger.debug("Starting test_01_internallb_roundrobin_1VPC_3VM_HTTP_port80") self.logger.debug("Creating a VPC offering..") vpc_offering = VpcOffering.create( self.apiclient, self.services["vpc_offering"]) self.cleanup.append(vpc_offering) self.logger.debug("Enabling the VPC offering created") vpc_offering.update(self.apiclient, state='Enabled') self.execute_internallb_roundrobin_tests(vpc_offering) @attr(tags=["smoke", "advanced"], required_hardware="true") def test_02_internallb_roundrobin_1RVPC_3VM_HTTP_port80(self): """ Test create, assign, remove of an Internal LB with roundrobin http traffic to 3 vm's in a Redundant VPC """ self.logger.debug("Starting test_02_internallb_roundrobin_1RVPC_3VM_HTTP_port80") self.logger.debug("Creating a Redundant VPC offering..") redundant_vpc_offering = VpcOffering.create( self.apiclient, self.services["redundant_vpc_offering"]) self.cleanup.append(redundant_vpc_offering) self.logger.debug("Enabling the Redundant VPC offering created") redundant_vpc_offering.update(self.apiclient, state='Enabled') self.execute_internallb_roundrobin_tests(redundant_vpc_offering) def execute_internallb_roundrobin_tests(self, vpc_offering): max_http_requests = 30 algorithm = "roundrobin" public_lb_port = 80 private_http_port = 80 public_ssh_start_port = 2000 num_app_vms = 3 self.logger.debug("Starting test_01_internallb_roundrobin_1VPC_3VM_HTTP_port80") # Create and enable network offerings network_offering_guestnet = self.create_and_enable_network_serviceoffering( self.services["network_offering"]) network_offering_intlb = self.create_and_enable_network_serviceoffering( self.services["network_offering_internal_lb"]) # Create VPC vpc = self.create_vpc(vpc_offering) # Create network tiers network_guestnet = self.create_network_tier( "guestnet_test01", vpc.id, "10.1.1.1", network_offering_guestnet) network_internal_lb = self.create_network_tier( "intlb_test01", vpc.id, "10.1.2.1", network_offering_intlb) # Create 1 lb client vm in guestnet network tier client_vm = self.deployvm_in_network(vpc, network_guestnet.id) # Create X app vm's in internal lb network tier app_vms = [] for x in range(0, num_app_vms): vm = None vm = self.deployvm_in_network(vpc, network_internal_lb.id) app_vms.append(vm) # Acquire public ip to access guestnet app vms guestnet_public_ip = self.acquire_publicip(vpc, network_guestnet) intlb_public_ip = self.acquire_publicip(vpc, network_internal_lb) # Create nat rule to access client vm self.create_natrule(vpc, client_vm, public_ssh_start_port, 22, guestnet_public_ip, network_guestnet) # Create nat rule to access app vms directly and start a http daemon on # the vm public_port = public_ssh_start_port + 1 for vm in app_vms: self.create_natrule(vpc, vm, public_port, 22, intlb_public_ip, network_internal_lb) public_port += 1 time.sleep(10) # start http daemon on vm's self.setup_http_daemon(vm) # Create a internal loadbalancer in the internal lb network tier applb = self.create_internal_loadbalancer(private_http_port, public_lb_port, algorithm, network_internal_lb.id) # wait for the loadbalancer to boot and be configured time.sleep(10) # Assign the 2 VMs to the Internal Load Balancer self.logger.debug("Assigning virtual machines to LB: %s" % applb.id) try: applb.assign(self.apiclient, vms=app_vms) except Exception as e: self.fail( "Failed to assign virtual machine(s) to loadbalancer: %s" % e) time.sleep(120) # self.logger.debug(dir(applb)) results = self.run_ssh_test_accross_hosts( client_vm, applb.sourceipaddress, max_http_requests) success = self.evaluate_http_responses(results, algorithm) self.assertTrue(success, "Test failed on algorithm: %s" % algorithm) self.logger.debug( "Removing virtual machines and networks for test_01_internallb_roundrobin_2VM_port80") # Remove the virtual machines from the Internal LoadBalancer self.logger.debug("Remove virtual machines from LB: %s" % applb.id) applb.remove(self.apiclient, vms=app_vms) def get_lb_stats_settings(self): self.logger.debug("Retrieving haproxy stats settings") settings = {} try: settings["stats_port"] = Configurations.list( self.apiclient, name="network.loadbalancer.haproxy.stats.port")[0].value settings["stats_uri"] = Configurations.list( self.apiclient, name="network.loadbalancer.haproxy.stats.uri")[0].value # Update global setting network.loadbalancer.haproxy.stats.auth to a known value haproxy_auth = "admin:password" Configurations.update(self.apiclient, "network.loadbalancer.haproxy.stats.auth", haproxy_auth) self.logger.debug( "Updated global setting stats network.loadbalancer.haproxy.stats.auth to %s" % (haproxy_auth)) settings["username"], settings["password"] = haproxy_auth.split(":") settings["visibility"] = Configurations.list( self.apiclient, name="network.loadbalancer.haproxy.stats.visibility")[0].value self.logger.debug(settings) except Exception as e: self.fail("Failed to retrieve stats settings " % e) return settings def verify_lb_stats(self, stats_ip, ssh_client, settings): word_to_verify = "uptime" url = "http://" + stats_ip + ":" + \ settings["stats_port"] + settings["stats_uri"] get_contents = "curl --connect-timeout 3 -L --user %s:%s %s" \ % (settings["username"], settings["password"], url) try: self.logger.debug( "Trying to connect to the haproxy stats url %s" % url) result = ssh_client.execute(get_contents) except Exception as e: self.fail("Failed to verify admin stats url %s from: %s" % (url, ssh_client)) finally: del ssh_client found = any(word_to_verify in word for word in result) if found: return True else: return False @attr(tags=["smoke", "advanced"], required_hardware="true") def test_03_vpc_internallb_haproxy_stats_on_all_interfaces(self): """ Test to verify access to loadbalancer haproxy admin stats page when global setting network.loadbalancer.haproxy.stats.visibility is set to 'all' with credentials from global setting network.loadbalancer.haproxy.stats.auth using the uri from global setting network.loadbalancer.haproxy.stats.uri. It uses a Single Router VPC """ self.logger.debug("Starting test_03_vpc_internallb_haproxy_stats_on_all_interfaces") self.logger.debug("Creating a VPC offering..") vpc_offering = VpcOffering.create( self.apiclient, self.services["vpc_offering"]) self.cleanup.append(vpc_offering) self.logger.debug("Enabling the VPC offering created") vpc_offering.update(self.apiclient, state='Enabled') self.execute_internallb_haproxy_tests(vpc_offering) @attr(tags=["smoke", "advanced"], required_hardware="true") def test_04_rvpc_internallb_haproxy_stats_on_all_interfaces(self): """ Test to verify access to loadbalancer haproxy admin stats page when global setting network.loadbalancer.haproxy.stats.visibility is set to 'all' with credentials from global setting network.loadbalancer.haproxy.stats.auth using the uri from global setting network.loadbalancer.haproxy.stats.uri. It uses a Redundant Routers VPC """ self.logger.debug("Starting test_04_rvpc_internallb_haproxy_stats_on_all_interfaces") self.logger.debug("Creating a Redundant VPC offering..") redundant_vpc_offering = VpcOffering.create( self.apiclient, self.services["redundant_vpc_offering"]) self.cleanup.append(redundant_vpc_offering) self.logger.debug("Enabling the Redundant VPC offering created") redundant_vpc_offering.update(self.apiclient, state='Enabled') self.execute_internallb_haproxy_tests(redundant_vpc_offering) def execute_internallb_haproxy_tests(self, vpc_offering): settings = self.get_lb_stats_settings() dummy_port = 90 network_gw = "10.1.2.1" default_visibility = "global" # Update global setting if it is not set to our test default if settings["visibility"] != default_visibility: config_update = Configurations.update( self.apiclient, "network.loadbalancer.haproxy.stats.visibility", default_visibility) self.logger.debug( "Updated global setting stats haproxy.stats.visibility to %s" % (default_visibility)) settings = self.get_lb_stats_settings() # Create and enable network offering network_offering_intlb = self.create_and_enable_network_serviceoffering( self.services["network_offering_internal_lb"]) # Create VPC vpc = self.create_vpc(vpc_offering) # Create network tier with internal lb service enabled network_internal_lb = self.create_network_tier( "intlb_test02", vpc.id, network_gw, network_offering_intlb) # Create 1 lb vm in internal lb network tier vm = self.deployvm_in_network(vpc, network_internal_lb.id) # Acquire 1 public ip and attach to the internal lb network tier public_ip = self.acquire_publicip(vpc, network_internal_lb) # Create an internal loadbalancer in the internal lb network tier applb = self.create_internal_loadbalancer( dummy_port, dummy_port, "leastconn", network_internal_lb.id) # Assign the 1 VM to the Internal Load Balancer self.logger.debug("Assigning virtual machines to LB: %s" % applb.id) try: applb.assign(self.apiclient, vms=[vm]) except Exception as e: self.fail( "Failed to assign virtual machine(s) to loadbalancer: %s" % e) # Create nat rule to access client vm self.create_natrule( vpc, vm, "22", "22", public_ip, network_internal_lb) # Verify access to and the contents of the admin stats page on the # private address via a vm in the internal lb tier stats = self.verify_lb_stats( applb.sourceipaddress, self.get_ssh_client(vm, 5), settings) self.assertTrue(stats, "Failed to verify LB HAProxy stats") @classmethod def tearDownClass(cls): super(TestInternalLb, cls).tearDownClass() def tearDown(self): super(TestInternalLb, self).tearDown()