def test_update_router(self): scenario = utils.NeutronScenario(context=self.context) scenario._generate_random_name = mock.Mock() expected_router = { "router": { "name": scenario._generate_random_name.return_value, "admin_state_up": False, "fakearg": "fake" } } self.clients("neutron").update_router.return_value = expected_router router = { "router": { "id": "router-id", "name": "router-name", "admin_state_up": True } } router_update_args = { "name": "foo", "admin_state_up": False, "fakearg": "fake" } result_router = scenario._update_router(router, router_update_args) self.clients("neutron").update_router.assert_called_once_with( router["router"]["id"], expected_router) self.assertEqual(result_router, expected_router) self._test_atomic_action_timer(scenario.atomic_actions(), "neutron.update_router")
def test_create_subnet(self, mock__generate_random_name): scenario = utils.NeutronScenario(self.context) network_id = "fake-id" start_cidr = "192.168.0.0/24" network = {"network": {"id": network_id}} expected_subnet_data = { "subnet": { "network_id": network_id, "cidr": start_cidr, "ip_version": scenario.SUBNET_IP_VERSION, "name": mock__generate_random_name.return_value } } # Default options subnet_data = {"network_id": network_id} scenario._create_subnet(network, subnet_data, start_cidr) self.clients("neutron").create_subnet.assert_called_once_with( expected_subnet_data) self._test_atomic_action_timer(scenario.atomic_actions(), "neutron.create_subnet") self.clients("neutron").create_subnet.reset_mock() # Custom options extras = {"cidr": "192.168.16.0/24", "allocation_pools": []} subnet_data.update(extras) expected_subnet_data["subnet"].update(extras) scenario._create_subnet(network, subnet_data) self.clients("neutron").create_subnet.assert_called_once_with( expected_subnet_data)
def test_update_subnet(self): scenario = utils.NeutronScenario(context=self.context) scenario._generate_random_name = mock.Mock() expected_subnet = { "subnet": { "name": scenario._generate_random_name.return_value, "enable_dhcp": False, "fakearg": "fake" } } self.clients("neutron").update_subnet.return_value = expected_subnet subnet = {"subnet": {"name": "subnet-name", "id": "subnet-id"}} subnet_update_args = { "name": "foo", "enable_dhcp": False, "fakearg": "fake" } result_subnet = scenario._update_subnet(subnet, subnet_update_args) self.clients("neutron").update_subnet.assert_called_once_with( subnet["subnet"]["id"], expected_subnet) self.assertEqual(result_subnet, expected_subnet) self._test_atomic_action_timer(scenario.atomic_actions(), "neutron.update_subnet")
def test_update_port(self): scenario = utils.NeutronScenario(context=self.context) scenario._generate_random_name = mock.Mock() expected_port = { "port": { "name": scenario._generate_random_name.return_value, "admin_state_up": False, "fakearg": "fake" } } self.clients("neutron").update_port.return_value = expected_port port = { "port": { "id": "port-id", "name": "port-name", "admin_state_up": True } } port_update_args = { "name": "_updated", "admin_state_up": False, "fakearg": "fake" } result_port = scenario._update_port(port, port_update_args) self.clients("neutron").update_port.assert_called_once_with( port["port"]["id"], expected_port) self.assertEqual(result_port, expected_port) self._test_atomic_action_timer(scenario.atomic_actions(), "neutron.update_port")
def test_create_network_and_subnets(self, mock__create_network, mock__create_subnet): scenario = utils.NeutronScenario(context=self.context) network_create_args = {} subnet_create_args = {} subnets_per_network = 4 # Default options scenario._create_network_and_subnets( network_create_args=network_create_args, subnet_create_args=subnet_create_args, subnets_per_network=subnets_per_network) mock__create_network.assert_called_once_with({}) mock__create_subnet.assert_has_calls( [mock.call({"network": { "id": "fake-id" }}, {}, "1.0.0.0/24")] * subnets_per_network) mock__create_network.reset_mock() mock__create_subnet.reset_mock() # Custom options scenario._create_network_and_subnets( network_create_args=network_create_args, subnet_create_args={"allocation_pools": []}, subnet_cidr_start="10.10.10.0/24", subnets_per_network=subnets_per_network) mock__create_network.assert_called_once_with({}) mock__create_subnet.assert_has_calls([ mock.call({"network": { "id": "fake-id" }}, {"allocation_pools": []}, "10.10.10.0/24") ] * subnets_per_network)
def test_create_network(self, mock__generate_random_name): neutron_scenario = utils.NeutronScenario() explicit_name = "explicit_name" random_name = "random_name" mock__generate_random_name.return_value = random_name self.clients("neutron").create_network.return_value = self.network # Network name is specified network_data = {"name": explicit_name, "admin_state_up": False} expected_network_data = {"network": network_data} network = neutron_scenario._create_network(network_data) self.clients("neutron").create_network.assert_called_once_with( expected_network_data) self.assertEqual(self.network, network) self._test_atomic_action_timer(neutron_scenario.atomic_actions(), "neutron.create_network") self.clients("neutron").create_network.reset_mock() # Network name is random generated network_data = {"admin_state_up": False} expected_network_data["network"]["name"] = random_name network = neutron_scenario._create_network(network_data) self.clients("neutron").create_network.assert_called_once_with( expected_network_data)
def test_update_port(self): scenario = utils.NeutronScenario() expected_port = { "port": { "name": "port-name_updated", "admin_state_up": False, "device_id": "dummy_id", "device_owner": "dummy_owner" } } self.clients("neutron").update_port.return_value = expected_port port = { "port": { "id": "port-id", "name": "port-name", "admin_state_up": True } } port_update_args = { "name": "_updated", "admin_state_up": False, "device_id": "dummy_id", "device_owner": "dummy_owner" } result_port = scenario._update_port(port, port_update_args) self.clients("neutron").update_port.assert_called_once_with( port["port"]["id"], expected_port) self.assertEqual(result_port, expected_port) self._test_atomic_action_timer(scenario.atomic_actions(), "neutron.update_port")
def test_create_router(self, mock__generate_random_name): scenario = utils.NeutronScenario() router = mock.Mock() explicit_name = "explicit_name" random_name = "random_name" mock__generate_random_name.return_value = random_name self.clients("neutron").create_router.return_value = router # Default options result_router = scenario._create_router({}) self.clients("neutron").create_router.assert_called_once_with( {"router": { "name": random_name }}) self.assertEqual(result_router, router) self._test_atomic_action_timer(scenario.atomic_actions(), "neutron.create_router") self.clients("neutron").create_router.reset_mock() # Custom options router_data = {"name": explicit_name, "admin_state_up": True} result_router = scenario._create_router(router_data) self.clients("neutron").create_router.assert_called_once_with( {"router": router_data})
def test_update_router(self): scenario = utils.NeutronScenario() expected_router = { "router": { "name": "router-name_updated", "admin_state_up": False } } self.clients("neutron").update_router.return_value = expected_router router = { "router": { "id": "router-id", "name": "router-name", "admin_state_up": True } } router_update_args = {"name": "_updated", "admin_state_up": False} result_router = scenario._update_router(router, router_update_args) self.clients("neutron").update_router.assert_called_once_with( router["router"]["id"], expected_router) self.assertEqual(result_router, expected_router) self._test_atomic_action_timer(scenario.atomic_actions(), "neutron.update_router")
def test_update_network(self): scenario = utils.NeutronScenario(context=self.context) scenario._generate_random_name = mock.Mock() expected_network = { "network": { "name": scenario._generate_random_name.return_value, "admin_state_up": False, "fakearg": "fake" } } self.clients("neutron").update_network.return_value = expected_network network = {"network": {"name": "network-name", "id": "network-id"}} network_update_args = { "name": "foo", "admin_state_up": False, "fakearg": "fake" } result_network = scenario._update_network(network, network_update_args) self.clients("neutron").update_network.assert_called_once_with( network["network"]["id"], expected_network) self.assertEqual(result_network, expected_network) self._test_atomic_action_timer(scenario.atomic_actions(), "neutron.update_network")
def test_update_security_group(self): scenario = utils.NeutronScenario() security_group = { "security_group": { "id": "security-group-id", "description": "Not updated" } } expected_security_group = { "security_group": { "id": "security-group-id", "description": "Updated" } } security_group_update_args = {"description": "Updated"} security_group_update_data = { "security_group": security_group_update_args } self.clients("neutron").update_security_group = mock.Mock( return_value=expected_security_group) result_security_group = scenario._update_security_group( security_group, **security_group_update_args) self.clients("neutron").update_security_group.assert_called_once_with( security_group["security_group"]["id"], security_group_update_data) self.assertEqual(result_security_group, expected_security_group) self._test_atomic_action_timer(scenario.atomic_actions(), "neutron.update_security_group")
def test_create_security_group(self, mock_generate_random_name): neutron_scenario = utils.NeutronScenario(self.context) random_name = "random_name" security_group_create_args = {"description": "Fake security group"} expected_security_group = { "security_group": { "id": "fake-id", "name": random_name, "description": "Fake security group" } } mock_generate_random_name.return_value = random_name self.clients("neutron").create_security_group = mock.Mock( return_value=expected_security_group) security_group_data = { "security_group": { "name": "random_name", "description": "Fake security group" } } resultant_security_group = neutron_scenario._create_security_group( **security_group_create_args) self.assertEqual(expected_security_group, resultant_security_group) self.clients("neutron").create_security_group.assert_called_once_with( security_group_data) self._test_atomic_action_timer(neutron_scenario.atomic_actions(), "neutron.create_security_group")
def test__get_network_id(self): neutron_scenario = utils.NeutronScenario() networks = [{ "id": "foo-id", "name": "foo-network" }, { "id": "bar-id", "name": "bar-network" }] network_id = "foo-id" # Valid network-name network = "foo-network" neutron_scenario._list_networks = mock.Mock(return_value=networks) resultant_network_id = neutron_scenario._get_network_id(network) self.assertEqual(network_id, resultant_network_id) neutron_scenario._list_networks.assert_called_once_with( atomic_action=False) neutron_scenario._list_networks.reset_mock() # Valid network-id network = "foo-id" resultant_network_id = neutron_scenario._get_network_id(network) self.assertEqual(network_id, resultant_network_id) neutron_scenario._list_networks.assert_called_once_with( atomic_action=False) neutron_scenario._list_networks.reset_mock() # Invalid network-name network = "absent-network" self.assertRaises(exceptions.NotFoundException, neutron_scenario._get_network_id, network) neutron_scenario._list_networks.assert_called_once_with( atomic_action=False)
def test__create_lb_pool(self, subnet_id=None, atomic_action=True, pool_create_args=None): neutron_scenario = utils.NeutronScenario(self.context) pool = {"pool": {"id": "pool-id"}} pool_create_args = pool_create_args or {} if pool_create_args.get("name") is None: neutron_scenario._generate_random_name = mock.Mock( return_value="random_name") self.clients("neutron").create_pool.return_value = pool args = { "lb_method": "ROUND_ROBIN", "protocol": "HTTP", "name": "random_name", "subnet_id": subnet_id } args.update(pool_create_args) expected_pool_data = {"pool": args} resultant_pool = neutron_scenario._create_lb_pool( subnet_id=subnet_id, atomic_action=atomic_action, **pool_create_args) self.assertEqual(resultant_pool, pool) self.clients("neutron").create_pool.assert_called_once_with( expected_pool_data) if atomic_action: self._test_atomic_action_timer(neutron_scenario.atomic_actions(), "neutron.create_pool")
def test_list_ports(self): scenario = utils.NeutronScenario(context=self.context) ports = [{"name": "port1"}, {"name": "port2"}] self.clients("neutron").list_ports.return_value = {"ports": ports} self.assertEqual(ports, scenario._list_ports()) self._test_atomic_action_timer(scenario.atomic_actions(), "neutron.list_ports")
def test_create_port(self): scenario = utils.NeutronScenario(self.context) scenario._generate_random_name = mock.Mock() net_id = "network-id" net = {"network": {"id": net_id}} expected_port_args = { "port": { "network_id": net_id, "name": scenario._generate_random_name.return_value } } # Defaults port_create_args = {} scenario._create_port(net, port_create_args) self.clients("neutron").create_port.assert_called_once_with( expected_port_args) self._test_atomic_action_timer(scenario.atomic_actions(), "neutron.create_port") self.clients("neutron").create_port.reset_mock() # Custom options port_args = {"admin_state_up": True} expected_port_args["port"].update(port_args) scenario._create_port(net, port_args) self.clients("neutron").create_port.assert_called_once_with( expected_port_args)
def test_update_pool(self): scenario = utils.NeutronScenario(context=self.context) scenario._generate_random_name = mock.Mock() expected_pool = { "pool": { "name": scenario._generate_random_name.return_value, "admin_state_up": False, "fakearg": "fake" } } self.clients("neutron").update_pool.return_value = expected_pool pool = {"pool": {"name": "pool-name", "id": "pool-id"}} pool_update_args = { "name": "foo", "admin_state_up": False, "fakearg": "fake" } result_pool = scenario._update_v1_pool(pool, **pool_update_args) self.assertEqual(result_pool, expected_pool) self.clients("neutron").update_pool.assert_called_once_with( pool["pool"]["id"], expected_pool) self._test_atomic_action_timer(scenario.atomic_actions(), "neutron.update_pool")
def test_delete_v1_healthmonitor(self): scenario = utils.NeutronScenario() healthmonitor = {"health_monitor": {"id": "fake-id"}} scenario._delete_v1_healthmonitor(healthmonitor["health_monitor"]) self.clients("neutron").delete_health_monitor.assert_called_once_with( healthmonitor["health_monitor"]["id"]) self._test_atomic_action_timer(scenario.atomic_actions(), "neutron.delete_healthmonitor")
def test_delete_network(self): scenario = utils.NeutronScenario(context=self.context) network_create_args = {} network = scenario._create_network(network_create_args) scenario._delete_network(network) self._test_atomic_action_timer(scenario.atomic_actions(), "neutron.delete_network")
def test_delete_router(self): scenario = utils.NeutronScenario(context=self.context) router = scenario._create_router({}) scenario._delete_router(router) self.clients("neutron").delete_router.assert_called_once_with( router["router"]["id"]) self._test_atomic_action_timer(scenario.atomic_actions(), "neutron.delete_router")
def setUp(self): super(NeutronScenarioTestCase, self).setUp() self.network = mock.Mock() self.scenario = utils.NeutronScenario(self.context) self.random_name = "random_name" self.scenario.generate_random_name = mock.Mock( return_value=self.random_name)
def test_list_routers(self): scenario = utils.NeutronScenario(context=self.context) routers = [mock.Mock()] self.clients("neutron").list_routers.return_value = { "routers": routers} self.assertEqual(routers, scenario._list_routers()) self._test_atomic_action_timer(scenario.atomic_actions(), "neutron.list_routers")
def test_delete_subnet(self): scenario = utils.NeutronScenario() network = scenario._create_network({}) subnet = scenario._create_subnet(network, {}) scenario._delete_subnet(subnet) self._test_atomic_action_timer(scenario.atomic_actions(), "neutron.delete_subnet")
def test_delete_v1_vip(self): scenario = utils.NeutronScenario() vip = {"vip": {"id": "fake-id"}} scenario._delete_v1_vip(vip["vip"]) self.clients("neutron").delete_vip.assert_called_once_with( vip["vip"]["id"]) self._test_atomic_action_timer(scenario.atomic_actions(), "neutron.delete_vip")
def test_list_networks(self): scenario = utils.NeutronScenario() networks_list = [] networks_dict = {"networks": networks_list} self.clients("neutron").list_networks.return_value = networks_dict return_networks_list = scenario._list_networks() self.assertEqual(networks_list, return_networks_list) self._test_atomic_action_timer(scenario.atomic_actions(), "neutron.list_networks")
def test_list_v1_vips(self): scenario = utils.NeutronScenario() vips_list = [] vips_dict = {"vips": vips_list} self.clients("neutron").list_vips.return_value = vips_dict return_vips_dict = scenario._list_v1_vips() self.assertEqual(vips_dict, return_vips_dict) self._test_atomic_action_timer(scenario.atomic_actions(), "neutron.list_vips")
def test_list_v1_pools(self): scenario = utils.NeutronScenario(context=self.context) pools_list = [] pools_dict = {"pools": pools_list} self.clients("neutron").list_pools.return_value = pools_dict return_pools_dict = scenario._list_v1_pools() self.assertEqual(pools_dict, return_pools_dict) self._test_atomic_action_timer(scenario.atomic_actions(), "neutron.list_pools")
def test_delete_port(self): scenario = utils.NeutronScenario(context=self.context) network = scenario._create_network({}) port = scenario._create_port(network, {}) scenario._delete_port(port) self._test_atomic_action_timer(scenario.atomic_actions(), "neutron.create_port")
def test_delete_v1_pool(self): scenario = utils.NeutronScenario(context=self.context) pool = {"pool": {"id": "fake-id"}} scenario._delete_v1_pool(pool["pool"]) self.clients("neutron").delete_pool.assert_called_once_with( pool["pool"]["id"]) self._test_atomic_action_timer(scenario.atomic_actions(), "neutron.delete_pool")
def test_list_floating_ips(self): scenario = utils.NeutronScenario() fips_list = [{"id": "floating-ip-id"}] fips_dict = {"floatingips": fips_list} self.clients("neutron").list_floatingips.return_value = fips_dict self.assertEqual(scenario._list_floating_ips(), self.clients("neutron").list_floatingips.return_value) self._test_atomic_action_timer(scenario.atomic_actions(), "neutron.list_floating_ips")