def test_update_router(self, mock_clients): scenario = utils.NeutronScenario() expected_router = { "router": { "name": "router-name_updated", "admin_state_up": False } } mock_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) mock_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_list_ports(self, mock_clients): scenario = utils.NeutronScenario() ports = [{"name": "port1"}, {"name": "port2"}] mock_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, mock_clients, mock_rand_name): scenario = utils.NeutronScenario() net_id = "network-id" net = {"network": {"id": net_id}} rand_name = "random-name" mock_rand_name.return_value = rand_name expected_port_args = { "port": { "network_id": net_id, "name": rand_name } } # Defaults port_create_args = {} scenario._create_port(net, port_create_args) mock_clients("neutron").create_port.assert_called_once_with( expected_port_args) self._test_atomic_action_timer(scenario.atomic_actions(), "neutron.create_port") mock_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) mock_clients("neutron").create_port.assert_called_once_with( expected_port_args)
def test_create_subnet(self, mock_clients, mock_cidr): network_id = "fake-id" subnet_cidr = "192.168.0.0/24" mock_cidr.return_value = subnet_cidr scenario = utils.NeutronScenario() network = {"network": {"id": network_id}} expected_subnet_data = { "subnet": { "network_id": network_id, "cidr": subnet_cidr, "ip_version": scenario.SUBNET_IP_VERSION } } # No extra options subnet_data = {"network_id": network_id} scenario._create_subnet(network, subnet_data) mock_clients("neutron")\ .create_subnet.assert_called_once_with(expected_subnet_data) self._test_atomic_action_timer(scenario.atomic_actions(), "neutron.create_subnet") mock_clients("neutron").create_subnet.reset_mock() # Extra options are specified 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) mock_clients("neutron")\ .create_subnet.assert_called_once_with(expected_subnet_data)
def test_create_network(self, mock_clients, mock_random_name): neutron_scenario = utils.NeutronScenario() explicit_name = "explicit_name" random_name = "random_name" mock_random_name.return_value = random_name mock_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) mock_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") mock_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) mock_clients("neutron").create_network.assert_called_once_with( expected_network_data)
def test_update_port(self, mock_clients): scenario = utils.NeutronScenario() expected_port = { "port": { "name": "port-name_updated", "admin_state_up": False, "device_id": "dummy_id", "device_owner": "dummy_owner" } } mock_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) mock_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_subnet(self, mock_clients, mock_random_name): scenario = utils.NeutronScenario() 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_random_name.return_value } } # Default options subnet_data = {"network_id": network_id} scenario._create_subnet(network, subnet_data, start_cidr) mock_clients("neutron").create_subnet.assert_called_once_with( expected_subnet_data) self._test_atomic_action_timer(scenario.atomic_actions(), "neutron.create_subnet") mock_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) mock_clients("neutron").create_subnet.assert_called_once_with( expected_subnet_data)
def test_create_router(self, mock_clients, mock_random_name): scenario = utils.NeutronScenario() router = mock.Mock() explicit_name = "explicit_name" random_name = "random_name" mock_random_name.return_value = random_name mock_clients("neutron").create_router.return_value = router # Default options result_router = scenario._create_router({}) mock_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") mock_clients("neutron").create_router.reset_mock() # Custom options router_data = {"name": explicit_name, "admin_state_up": True} result_router = scenario._create_router(router_data) mock_clients("neutron").create_router.assert_called_once_with( {"router": router_data})
def test_list_routers(self, mock_clients): scenario = utils.NeutronScenario() routers = [mock.Mock()] mock_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_router(self, mock_clients): scenario = utils.NeutronScenario() router = scenario._create_router({}) scenario._delete_router(router) mock_clients("neutron").delete_router.assert_called_once_with( router["router"]["id"]) self._test_atomic_action_timer(scenario.atomic_actions(), "neutron.delete_router")
def test_list_networks(self, mock_clients): scenario = utils.NeutronScenario() networks_list = [] networks_dict = {"networks": networks_list} mock_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_delete_port(self, mock_clients): scenario = utils.NeutronScenario() 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_list_subnets(self, mock_clients): subnets = [{"name": "fake1"}, {"name": "fake2"}] mock_clients("neutron")\ .list_subnets.return_value = {"subnets": subnets} scenario = utils.NeutronScenario() result = scenario._list_subnets() self.assertEqual(subnets, result) self._test_atomic_action_timer(scenario.atomic_actions(), "neutron.list_subnets")
def test_delete_subnet(self, mock_clients, mock_generate_subnet_cidr): scenario = utils.NeutronScenario() network = scenario._create_network({}) subnet = scenario._create_subnet(network, 1, {}) scenario._delete_subnet(subnet) self._test_atomic_action_timer(scenario.atomic_actions(), 'neutron.delete_subnet')
def test_remove_interface_router(self, mock_clients): subnet = {"name": "subnet-name", "id": "subnet-id"} router_data = {"id": 1} scenario = utils.NeutronScenario() router = scenario._create_router(router_data) scenario._add_interface_router(subnet, router) scenario._remove_interface_router(subnet, router) mock_remove_router = mock_clients("neutron").remove_interface_router mock_remove_router.assert_called_once_with(router["id"], {"subnet_id": subnet["id"]}) self._test_atomic_action_timer(scenario.atomic_actions(), "neutron.remove_interface_router")
def test_generate_subnet_cidr(self): scenario = utils.NeutronScenario() scenario.context = mock.Mock(return_value={"iteration": 1}) subnets_num = 30 cidrs1 = map(scenario._generate_subnet_cidr, [subnets_num] * subnets_num) cidrs2 = map(scenario._generate_subnet_cidr, [subnets_num] * subnets_num) # All CIDRs must differ self.assertEqual(len(cidrs1), len(set(cidrs1))) self.assertEqual(len(cidrs2), len(set(cidrs2))) # All CIDRs must be valid map(netaddr.IPNetwork, cidrs1 + cidrs2)
def test_generate_subnet_cidr(self): scenario = utils.NeutronScenario() network1_id = "fake1" network2_id = "fake2" subnets_num = 300 cidrs1 = map(scenario._generate_subnet_cidr, [network1_id] * subnets_num) cidrs2 = map(scenario._generate_subnet_cidr, [network2_id] * subnets_num) # All CIDRs must differ self.assertEqual(len(cidrs1), len(set(cidrs1))) self.assertEqual(len(cidrs2), len(set(cidrs2))) # All CIDRs must be valid map(netaddr.IPNetwork, cidrs1 + cidrs2)
def test_create_network_and_subnets(self, mock_cidr_start, mock_create_network, mock_create_subnet): scenario = utils.NeutronScenario() network_create_args = {} subnet_create_args = {} subnets_per_network = 4 mock_create_network.reset_mock() mock_create_subnet.reset_mock() # Default options scenario._create_network_and_subnets( network_create_args=network_create_args, subnet_create_args=subnet_create_args, subnet_cidr_start=scenario.SUBNET_CIDR_START, 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" }}, subnets_per_network, {}) ] * subnets_per_network) self.assertEqual(scenario.SUBNET_CIDR_START, "default_cidr") 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="custom_cidr", subnets_per_network=subnets_per_network) self.assertEqual(scenario.SUBNET_CIDR_START, "custom_cidr") mock_create_network.assert_called_once_with({}) mock_create_subnet.assert_has_calls([ mock.call({"network": { "id": "fake-id" }}, subnets_per_network, {"allocation_pools": []}) ] * subnets_per_network)
def test_update_subnet(self, mock_clients): scenario = utils.NeutronScenario() expected_subnet = { "subnet": { "name": "subnet-name_updated", "enable_dhcp": False } } mock_clients("neutron").update_subnet.return_value = expected_subnet subnet = {"subnet": {"name": "subnet-name", "id": "subnet-id"}} subnet_update_args = {"name": "_updated", "enable_dhcp": False} result_subnet = scenario._update_subnet(subnet, subnet_update_args) mock_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_functional_create_network_and_subnets(self, mock_generate_cidr): scenario = utils.NeutronScenario(clients=fakes.FakeClients()) network_create_args = {"name": "foo_network"} subnet_create_args = {} subnets_per_network = 5 subnet_cidr_start = "1.1.1.0/24" cidrs = ["1.1.%d.0/24" % i for i in range(subnets_per_network)] cidrs_ = iter(cidrs) mock_generate_cidr.side_effect = lambda **kw: next(cidrs_) network, subnets = scenario._create_network_and_subnets( network_create_args, subnet_create_args, subnets_per_network, subnet_cidr_start) self.assertEqual(network["network"]["name"], "foo_network") # This checks both data (cidrs seem to be enough) and subnets number result_cidrs = sorted([s["subnet"]["cidr"] for s in subnets]) self.assertEqual(cidrs, result_cidrs)
def test_functional_create_network_and_subnets(self): scenario = utils.NeutronScenario(clients=fakes.FakeClients()) network_create_args = {"name": "foo_network"} subnet_create_args = {} subnets_per_network = 5 subnet_cidr_start = None cidrs = sorted(["1.1.1.%d/30" % i for i in range(subnets_per_network)]) _cidrs = cidrs[:] scenario._generate_subnet_cidr = lambda i: _cidrs.pop() network, subnets = scenario._create_network_and_subnets( network_create_args, subnet_create_args, subnets_per_network, subnet_cidr_start) self.assertEqual(network["network"]["name"], "foo_network") # This checks both data (cidrs seem to be enough) and subnets number result_cidrs = sorted([s["subnet"]["cidr"] for s in subnets]) self.assertEqual(cidrs, result_cidrs)
def test_generate_subnet_cidr(self): scenario = utils.NeutronScenario() network1_id = "fake1" network2_id = "fake2" cidrs1 = map(scenario._generate_subnet_cidr, [network1_id] * 256) self.assertRaises(ValueError, scenario._generate_subnet_cidr, network1_id) cidrs2 = map(scenario._generate_subnet_cidr, [network2_id] * 256) self.assertRaises(ValueError, scenario._generate_subnet_cidr, network2_id) # All CIDRs must differ self.assertEqual(len(cidrs1), len(set(cidrs1))) self.assertEqual(len(cidrs2), len(set(cidrs2))) # All CIDRs must be valid map(netaddr.IPNetwork, cidrs1 + cidrs2)
def test_create_network_and_subnets(self, mock_create_network, mock_create_subnet): scenario = utils.NeutronScenario() network_create_args = {} subnet_create_args = {} subnets_per_network = 4 mock_create_network.reset_mock() mock_create_subnet.reset_mock() # 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)