def test_update(self): old_pool = test_base.FakePool('TCP', 'LEAST_CONNECTIONS', None, True) pool = test_base.FakePool('TCP', 'ROUND_ROBIN', None, True) self.a.pool.update(None, old_pool, pool) self.print_mocks() self.a.last_client.slb.service_group.create( pool.id, lb_method=self.a.last_client.slb.service_group.ROUND_ROBIN, protocol=self.a.last_client.slb.service_group.TCP)
def test_update(self): pers1 = None pers2 = None old_pool = test_base.FakePool('TCP', 'LEAST_CONNECTIONS', pers1, True) pool = test_base.FakePool('TCP', 'ROUND_ROBIN', pers2, True) self.a.pool.update(None, pool, old_pool) self.print_mocks() self.a.last_client.slb.service_group.update.assert_called_with( pool.id, axapi_args={"service_group": {}}, lb_method=mock.ANY, protocol=mock.ANY)
def test_delete(self): members = [[], [test_base.FakeMember()]] hms = [None, test_base.FakeHM('PING')] persistences = [None, 'SOURCE_IP', 'HTTP_COOKIE'] listeners = [False, True] for m in members: for hm in hms: for pers in persistences: for lst in listeners: self.a.reset_mocks() pool = test_base.FakePool('TCP', 'ROUND_ROBIN', pers, lst, members=m, hm=hm) self.a.pool.delete(None, pool) self.print_mocks() (self.a.last_client.slb.service_group.delete. assert_called_with(pool.id)) if pers == 'SOURCE_IP': (self.a.last_client.slb.template. src_ip_persistence.delete. assert_called_with(pool.id)) elif pers == 'HTTP_COOKIE': (self.a.last_client.slb.template. cookie_persistence.delete. assert_called_with(pool.id))
def _test_create_ipinip(self, api_ver="3.0", ip_in_ip=False): ipinip_expected = None expected_tuple = axapi_mappings.ipinip_dictionary.get(api_ver) saw_exception = False for k, v in self.a.config.get_devices().items(): v['ipinip'] = ip_in_ip v['api_version'] = api_ver if expected_tuple is not None: key, transform = expected_tuple else: key = None transform = None if ip_in_ip and key and transform: ipinip_format = "'{0}': {1}" ipinip_expected = ipinip_format.format(key, transform(ip_in_ip)) p = 'TCP' lb = test_base.FakeLoadBalancer() pool = test_base.FakePool(p, 'ROUND_ROBIN', None) m = test_base.FakeListener(p, 2222, pool=pool, loadbalancer=lb) self.a.listener.create(None, m) self.print_mocks() if not saw_exception: s = str(self.a.last_client.mock_calls) self.assertIn("vport.create", s) if ipinip_expected is not None: self.assertIn(ipinip_expected, s)
def test_create(self): methods = { 'ROUND_ROBIN': self.a.last_client.slb.service_group.ROUND_ROBIN, 'LEAST_CONNECTIONS': self.a.last_client.slb.service_group.LEAST_CONNECTION, 'SOURCE_IP': self.a.last_client.slb.service_group.WEIGHTED_LEAST_CONNECTION, } protocols = { 'TCP': self.a.last_client.slb.service_group.TCP, 'UDP': self.a.last_client.slb.service_group.UDP, } persistences = [None, 'SOURCE_IP', 'HTTP_COOKIE', 'APP_COOKIE'] listeners = [False, True] for p in protocols.keys(): for m in methods.keys(): for pers in persistences: for listener in listeners: self.a.reset_mocks() saw_exception = False pool = test_base.FakePool(p, m, pers, listener) try: self.a.pool.create(None, pool) except a10_ex.UnsupportedFeature as e: if pers == 'APP_COOKIE': saw_exception = True else: raise e self.print_mocks() # (self.a.last_client.slb.service_group.create. # assert_called_with( # pool.id, # axapi_args={"service_group": {}}, # lb_method=methods(m), # protocol=protocols(p))) if not saw_exception: n = str(self.a.last_client.mock_calls).index( 'slb.service_group.create') self.assertTrue(n >= 0) if pers == 'SOURCE_IP': (self.a.last_client.slb.template. src_ip_persistence.create. assert_called_with(pool.id)) elif pers == 'HTTP_COOKIE': (self.a.last_client.slb.template. cookie_persistence.create. assert_called_with(pool.id)) elif pers == 'APP_COOKIE': (self.a.last_client.slb.template. cookie_persistence.create. assert_called_with(pool.id))
def test_create(self): admin_states = [True, False] persistences = [None, 'SOURCE_IP', 'HTTP_COOKIE', 'APP_COOKIE'] protocols = ['TCP', 'UDP', 'HTTP', 'HTTPS'] lb = test_base.FakeLoadBalancer() for a in admin_states: for pers in persistences: for p in protocols: self.a.reset_mocks() pool = test_base.FakePool(p, 'ROUND_ROBIN', pers) m = test_base.FakeListener(p, 2222, pool=pool, loadbalancer=lb) pool.listener = m saw_exception = False try: self.a.listener.create(None, m) except a10_ex.UnsupportedFeature as e: if pers == 'APP_COOKIE': saw_exception = True else: raise e self.print_mocks() if not saw_exception: s = str(self.a.last_client.mock_calls) self.assertTrue('vport.create' in s) self.assertTrue('fake-lb-id-001' in s) self.assertTrue('fake-listen-id-001' in s) self.assertTrue('port=2222' in s) test_prot = p if p in ('HTTPS', constants.PROTOCOL_TERMINATED_HTTPS): test_prot = 'TCP' self.assertTrue(test_prot in s) if pers == 'SOURCE_IP': self.assertTrue('s_pers_name=None' not in s) pass elif pers == 'HTTP_COOKIE': self.assertTrue('s_pers=HTTP_COOKIE') self.assertTrue('c_pers_name=None' not in s) pass elif pers == 'APP_COOKIE': self.assertTrue('s_pers=APP_COOKIE') self.assertTrue('c_pers_name=None' not in s) pass else: self.assertTrue('c_pers_name=None' in s) self.assertTrue('s_pers_name=None' in s)
def test_dissociate_calls_service_group_update(self): fake_pool = test_base.FakePool() fake_hm = test_base.FakeHM() fake_hm["id"] = "id1" fake_hm["pools"] = [] fake_hm["pools"].append(fake_pool) fake_hm['tenant_id'] = "tenv1" self.a.hm.dissociate(self.a.last_client, None, fake_hm, fake_pool.id) self.a.last_client.slb.service_group.update.assert_called( fake_pool.id, health_monitor="", health_check_disable=True)
def test_dissociate_calls_hm_delete(self): fake_pool = test_base.FakePool() fake_hm = test_base.FakeHM() fake_pool["health_monitor_status"] = [{"monitor_id": fake_hm.id}] fake_hm["id"] = "id1" fake_hm["pools"] = [] fake_hm["pools"].append(fake_pool) fake_hm['tenant_id'] = "tenv1" self.a.hm.dissociate(self.a.last_client, None, fake_hm, fake_pool.id) self.a.last_client.hm.service_group.delete.assert_called( self.a.hm._meta_name(fake_hm))
def test_delete(self): expected = test_base.FakePool() fakehm = test_base.FakeHM() fakehm['tenant_id'] = 'tenv1' fakehm['id'] = 'fedcba' fakehm.pools.append(expected) self.a.hm.openstack_driver.plugin.get_pool.return_value = expected self.a.hm.openstack_driver._hm_binding_count.return_value = 1 self.a.hm.delete(None, fakehm, 'p01') self.a.last_client.slb.hm.delete.assert_called_with(fakehm["id"])
def test_barbican_client_not_null(self, certmgr): """This tests that the barbican_client dependency is always there.""" handler = self.a.listener handler.barbican_client = None pool = test_base.FakePool(constants.PROTOCOL_TERMINATED_HTTPS, constants.LB_METHOD_ROUND_ROBIN, None) lb = test_base.FakeLoadBalancer() m = test_base.FakeListener(constants.PROTOCOL_TERMINATED_HTTPS, 2222, pool=pool, loadbalancer=lb) pool.listener = m handler.create(None, m) self.assertTrue(handler.barbican_client is not None)
def _test_create_ipinip(self, ip_in_ip=False): for k, v in self.a.config.devices.items(): v['ipinip'] = ip_in_ip p = 'TCP' lb = test_base.FakeLoadBalancer() pool = test_base.FakePool(p, 'ROUND_ROBIN', None) m = test_base.FakeListener(p, 2222, pool=pool, loadbalancer=lb) self.a.listener.create(None, m) self.print_mocks() s = str(self.a.last_client.mock_calls) self.assertEqual(ip_in_ip, "ipinip" in s)
def test_delete(self): pool = test_base.FakePool('HTTP', 'ROUND_ROBIN', None) lb = test_base.FakeLoadBalancer() m = test_base.FakeListener('HTTP', 2222, pool=pool, loadbalancer=lb) pool.listener = m self.a.listener.delete(None, m) s = str(self.a.last_client.mock_calls) self.assertTrue('vport.delete' in s) self.assertTrue('fake-lb-id-001' in s) self.assertTrue('fake-listen-id-001' in s) self.assertTrue('port=2222' in s) self.assertTrue('HTTP' in s)
def _tls_container_shared(self): certmgr = FakeCertManager() certmgr.certificate = "CERTDATA" certmgr.private_key = "PRIVATEKEY" certmgr.private_key_passphrase = "SECRETPASSWORD" handler = self.a.listener handler.barbican_client = certmgr pool = test_base.FakePool(constants.PROTOCOL_TERMINATED_HTTPS, constants.LB_METHOD_ROUND_ROBIN, None) lb = test_base.FakeLoadBalancer() m = test_base.FakeListener(constants.PROTOCOL_TERMINATED_HTTPS, 2222, pool=pool, loadbalancer=lb) return (certmgr, m, pool, handler)
def test_create_with_listeners(self): pool = test_base.FakePool('HTTP', 'ROUND_ROBIN', None) m = test_base.FakeLoadBalancer() for x in [1, 2, 3]: z = test_base.FakeListener('TCP', 2222+x, pool=pool, loadbalancer=m) m.listeners.append(z) self.a.lb.create(None, m) s = str(self.a.last_client.mock_calls) self.assertTrue('call.slb.virtual_server.create' in s) self.assertTrue('fake-lb-id-001' in s) self.assertTrue('5.5.5.5' in s) self.assertTrue('UP' in s) self.assertTrue('vport.create' in s) for x in [1, 2, 3]: self.assertTrue(str(2222+x) in s)
def _test_create_autosnat(self, api_ver=None, autosnat=None): saw_exception = False """ Due to how the config is pulled in, we can't override the config version here and just expect it to work. """ for k, v in self.a.config.devices.items(): v['api_version'] = api_ver v['autosnat'] = autosnat # self.a.device_info["api_version"] = api_ver # self.a.device_info["autosnat"] = autosnat p = 'TCP' lb = test_base.FakeLoadBalancer() pool = test_base.FakePool(p, 'ROUND_ROBIN', None) m = test_base.FakeListener(p, 2222, pool=pool, loadbalancer=lb) auto_expected = None expected_tuple = a10_common.auto_dictionary.get(api_ver, None) if expected_tuple is not None: key = expected_tuple[0] transform = expected_tuple[1] else: key = None transform = None if autosnat and key is not None and transform is not None: auto_format = "'{0}': {1}" auto_expected = auto_format.format(key, transform(autosnat)) try: self.a.listener.create(None, m) except Exception as e: saw_exception = True raise e if not saw_exception: s = str(self.a.last_client.mock_calls) self.assertTrue('vport.create' in s) if auto_expected is not None: self.assertTrue(auto_expected in s)
def test_create_protocol_terminated_https(self): pool = test_base.FakePool(constants.PROTOCOL_TERMINATED_HTTPS, constants.LB_METHOD_ROUND_ROBIN, None) lb = test_base.FakeLoadBalancer() m = test_base.FakeListener(constants.PROTOCOL_TERMINATED_HTTPS, 2222, pool=pool, loadbalancer=lb) m.default_tls_container_id = "CONTAINERID" pool.listener = m certmgr = FakeCertManager() self.a.barbican_client = certmgr self.a.listener.create(None, m) s = str(self.a.last_client.mock_calls) self.assertTrue('HTTPS' in s)
def test_delete_updates_pool_health_monitor(self): expected = test_base.FakePool() fakehm = test_base.FakeHM() fakehm['tenant_id'] = 'tenv1' fakehm['id'] = 'fedcba' fakehm['pools'] = [] fakehm['pools'].append(expected) self.a.hm.openstack_driver._pool_get_hm.return_value = fakehm self.a.hm.openstack_driver.plugin.get_pool.return_value = expected self.a.hm.openstack_driver._hm_binding_count.return_value = 1 pool_name = self.a.hm._pool_name(None, 'p01') self.a.hm.delete(None, fakehm, 'p01') self.a.last_client.slb.service_group.update.assert_called_with( pool_name, health_monitor='', health_check_disable=True)
def test_delete(self): pool = test_base.FakePool(constants.PROTOCOL_TERMINATED_HTTPS, constants.LB_METHOD_ROUND_ROBIN, None) lb = test_base.FakeLoadBalancer() m = test_base.FakeListener(constants.PROTOCOL_TERMINATED_HTTPS, 2222, pool=pool, loadbalancer=lb) pool.listener = m self.a.listener.delete(None, m) self.print_mocks() s = str(self.a.last_client.mock_calls) LOG.debug("DELETE RESULT %s" % s) self.assertTrue('vport.delete' in s) self.assertTrue('fake-lb-id-001' in s) self.assertTrue('fake-listen-id-001' in s) self.assertTrue('port=2222' in s) self.assertTrue('HTTPS' in s)
def test_update(self): pool = test_base.FakePool(constants.PROTOCOL_TERMINATED_HTTPS, constants.LB_METHOD_ROUND_ROBIN, None) lb = test_base.FakeLoadBalancer() m = test_base.FakeListener(constants.PROTOCOL_TERMINATED_HTTPS, 2222, pool=pool, loadbalancer=lb) certmgr = FakeCertManager() self.a.barbican_client = certmgr # self.a.listener.set_certmgr(certmgr) pool.listener = m self.a.listener.update(None, m, m) self.print_mocks() s = str(self.a.last_client.mock_calls) self.assertTrue('vport.update' in s) self.assertTrue('fake-lb-id-001' in s) self.assertTrue('fake-listen-id-001' in s) self.assertTrue('port=2222' in s) self.assertTrue('HTTPS' in s)
def _test_stats(self): pool = test_base.FakePool('TCP', 'ROUND_ROBIN', None, False) actual = self.a.pool.stats(None, pool) return pool, actual