Revision 92d2d1ce snf-cyclades-app/synnefo/api/tests/servers.py
| b/snf-cyclades-app/synnefo/api/tests/servers.py | ||
|---|---|---|
| 122 | 122 |
"""Test if a server details are returned.""" |
| 123 | 123 |
db_vm = self.vm2 |
| 124 | 124 |
user = self.vm2.userid |
| 125 |
net = mfactory.NetworkFactory() |
|
| 126 |
nic = mfactory.NetworkInterfaceFactory(machine=self.vm2, network=net, |
|
| 127 |
ipv6="::babe") |
|
| 125 |
ip4 = mfactory.IPv4AddressFactory(nic__machine=self.vm2) |
|
| 126 |
nic = ip4.nic |
|
| 127 |
net = ip4.network |
|
| 128 |
ip6 = mfactory.IPv6AddressFactory(nic=nic, network=net) |
|
| 129 |
nic.mac = "aa:00:11:22:33:44" |
|
| 130 |
nic.save() |
|
| 128 | 131 |
|
| 129 | 132 |
db_vm_meta = mfactory.VirtualMachineMetadataFactory(vm=db_vm) |
| 130 | 133 |
|
| ... | ... | |
| 141 | 144 |
self.assertEqual(api_nic['network_id'], str(net.id)) |
| 142 | 145 |
self.assertEqual(api_nic['mac_address'], nic.mac) |
| 143 | 146 |
self.assertEqual(api_nic['firewallProfile'], nic.firewall_profile) |
| 144 |
self.assertEqual(api_nic['ipv4'], nic.ipv4)
|
|
| 145 |
self.assertEqual(api_nic['ipv6'], nic.ipv6)
|
|
| 147 |
self.assertEqual(api_nic['ipv4'], ip4.address)
|
|
| 148 |
self.assertEqual(api_nic['ipv6'], ip6.address)
|
|
| 146 | 149 |
self.assertEqual(api_nic['OS-EXT-IPS:type'], "fixed") |
| 147 | 150 |
self.assertEqual(api_nic['id'], nic.id) |
| 148 | 151 |
api_address = server["addresses"] |
| 149 | 152 |
self.assertEqual(api_address[str(net.id)], [ |
| 150 |
{"version": 4, "addr": nic.ipv4, "OS-EXT-IPS:type": "fixed"},
|
|
| 151 |
{"version": 6, "addr": nic.ipv6, "OS-EXT-IPS:type": "fixed"}
|
|
| 153 |
{"version": 4, "addr": ip4.address, "OS-EXT-IPS:type": "fixed"},
|
|
| 154 |
{"version": 6, "addr": ip6.address, "OS-EXT-IPS:type": "fixed"}
|
|
| 152 | 155 |
]) |
| 153 | 156 |
|
| 154 | 157 |
metadata = server['metadata'] |
| ... | ... | |
| 184 | 187 |
self.assertEqual(server["SNF:fqdn"], "") |
| 185 | 188 |
|
| 186 | 189 |
# IPv6 NIC |
| 187 |
nic = mfactory.NetworkInterfaceFactory(machine=vm, ipv4=None, |
|
| 188 |
ipv6="babe::", state="ACTIVE", |
|
| 189 |
network__public=True) |
|
| 190 |
ipv6_address = mfactory.IPv6AddressFactory(nic__machine=vm, |
|
| 191 |
network__public=True) |
|
| 190 | 192 |
with override_settings(settings, |
| 191 | 193 |
CYCLADES_SERVERS_FQDN=None): |
| 192 | 194 |
response = self.myget("servers/%d" % vm.id, vm.userid)
|
| 193 | 195 |
server = json.loads(response.content)['server'] |
| 194 |
self.assertEqual(server["SNF:fqdn"], nic.ipv6)
|
|
| 196 |
self.assertEqual(server["SNF:fqdn"], ipv6_address.address)
|
|
| 195 | 197 |
|
| 196 | 198 |
# IPv4 NIC |
| 197 |
nic = mfactory.NetworkInterfaceFactory(machine=vm, |
|
| 198 |
network__public=True, |
|
| 199 |
state="ACTIVE") |
|
| 199 |
ipv4_address = mfactory.IPv4AddressFactory(nic__machine=vm, |
|
| 200 |
network__public=True) |
|
| 200 | 201 |
with override_settings(settings, |
| 201 | 202 |
CYCLADES_SERVERS_FQDN=None): |
| 202 | 203 |
response = self.myget("servers/%d" % vm.id, vm.userid)
|
| 203 | 204 |
server = json.loads(response.content)['server'] |
| 204 |
self.assertEqual(server["SNF:fqdn"], nic.ipv4)
|
|
| 205 |
self.assertEqual(server["SNF:fqdn"], ipv4_address.address)
|
|
| 205 | 206 |
|
| 206 | 207 |
def test_server_port_forwarding(self): |
| 207 | 208 |
vm = mfactory.VirtualMachineFactory() |
| ... | ... | |
| 229 | 230 |
server = json.loads(response.content)['server'] |
| 230 | 231 |
self.assertEqual(server["SNF:port_forwarding"], {})
|
| 231 | 232 |
|
| 232 |
mfactory.NetworkInterfaceFactory(machine=vm, ipv4="192.168.2.2", |
|
| 233 |
network__public=True) |
|
| 233 |
mfactory.IPv4AddressFactory(nic__machine=vm, |
|
| 234 |
network__public=True, |
|
| 235 |
address="192.168.2.2") |
|
| 234 | 236 |
with override_settings(settings, |
| 235 | 237 |
CYCLADES_PORT_FORWARDING=ports): |
| 236 | 238 |
response = self.myget("servers/%d" % vm.id, vm.userid)
|
| ... | ... | |
| 335 | 337 |
def setUp(self): |
| 336 | 338 |
self.flavor = mfactory.FlavorFactory() |
| 337 | 339 |
# Create public network and backend |
| 338 |
self.network = mfactory.NetworkFactory(public=True) |
|
| 340 |
subnet = mfactory.IPv4SubnetFactory(network__public=True) |
|
| 341 |
self.network = subnet.network |
|
| 339 | 342 |
self.backend = mfactory.BackendFactory() |
| 340 | 343 |
mfactory.BackendNetworkFactory(network=self.network, |
| 341 | 344 |
backend=self.backend, |
| ... | ... | |
| 386 | 389 |
|
| 387 | 390 |
def test_create_network_settings(self, mrapi): |
| 388 | 391 |
mrapi().CreateInstance.return_value = 12 |
| 389 |
bnet1 = mfactory.BackendNetworkFactory(operstate="ACTIVE", |
|
| 390 |
backend=self.backend) |
|
| 391 |
bnet2 = mfactory.BackendNetworkFactory(operstate="ACTIVE", |
|
| 392 |
backend=self.backend) |
|
| 393 |
bnet3 = mfactory.BackendNetworkFactory(network__userid="test_user", |
|
| 394 |
operstate="ACTIVE", |
|
| 395 |
backend=self.backend) |
|
| 396 |
bnet4 = mfactory.BackendNetworkFactory(network__userid="test_user", |
|
| 397 |
operstate="ACTIVE", |
|
| 398 |
backend=self.backend) |
|
| 392 |
# Create public network and backend |
|
| 393 |
subnet1 = mfactory.IPv4SubnetFactory() |
|
| 394 |
bnet1 = mfactory.BackendNetworkFactory(network=subnet1.network, |
|
| 395 |
backend=self.backend, |
|
| 396 |
operstate="ACTIVE") |
|
| 397 |
subnet2 = mfactory.IPv4SubnetFactory() |
|
| 398 |
bnet2 = mfactory.BackendNetworkFactory(network=subnet2.network, |
|
| 399 |
backend=self.backend, |
|
| 400 |
operstate="ACTIVE") |
|
| 401 |
subnet3 = mfactory.IPv4SubnetFactory(network__userid="test_user") |
|
| 402 |
bnet3 = mfactory.BackendNetworkFactory(network=subnet3.network, |
|
| 403 |
backend=self.backend, |
|
| 404 |
operstate="ACTIVE") |
|
| 405 |
subnet4 = mfactory.IPv4SubnetFactory(network__userid="test_user") |
|
| 406 |
bnet4 = mfactory.BackendNetworkFactory(network=subnet4.network, |
|
| 407 |
backend=self.backend, |
|
| 408 |
operstate="ACTIVE") |
|
| 399 | 409 |
# User requested private networks |
| 400 | 410 |
request = deepcopy(self.request) |
| 401 | 411 |
request["server"]["networks"] = [bnet3.network.id, bnet4.network.id] |
| ... | ... | |
| 464 | 474 |
# Test floating IPs |
| 465 | 475 |
request = deepcopy(self.request) |
| 466 | 476 |
request["server"]["networks"] = [bnet4.network.id] |
| 467 |
network = mfactory.NetworkFactory(subnet="10.0.0.0/24") |
|
| 468 |
mfactory.BackendNetworkFactory(network=network, |
|
| 469 |
backend=self.backend, |
|
| 470 |
operstate="ACTIVE") |
|
| 471 |
fp1 = mfactory.IPAddressFactory(ipv4="10.0.0.2", |
|
| 477 |
fp1 = mfactory.FloatingIPFactory(address="10.0.0.2", |
|
| 472 | 478 |
userid="test_user", |
| 473 |
network=network, machine=None)
|
|
| 474 |
fp2 = mfactory.IPAddressFactory(ipv4="10.0.0.3", network=network,
|
|
| 479 |
nic=None)
|
|
| 480 |
fp2 = mfactory.FloatingIPFactory(address="10.0.0.3",
|
|
| 475 | 481 |
userid="test_user", |
| 476 |
machine=None)
|
|
| 477 |
request["server"]["floating_ips"] = [fp1.ipv4, fp2.ipv4]
|
|
| 482 |
nic=None)
|
|
| 483 |
request["server"]["floating_ips"] = [fp1.address, fp2.address]
|
|
| 478 | 484 |
with override_settings(settings, |
| 479 | 485 |
DEFAULT_INSTANCE_NETWORKS=[bnet3.network.id]): |
| 480 | 486 |
with mocked_quotaholder(): |
| ... | ... | |
| 483 | 489 |
self.assertEqual(response.status_code, 202) |
| 484 | 490 |
api_server = json.loads(response.content)['server'] |
| 485 | 491 |
vm = VirtualMachine.objects.get(id=api_server["id"]) |
| 486 |
fp1 = IPAddress.objects.get(id=fp1.id) |
|
| 487 |
fp2 = IPAddress.objects.get(id=fp2.id) |
|
| 488 |
self.assertEqual(fp1.machine, vm) |
|
| 489 |
self.assertEqual(fp2.machine, vm) |
|
| 492 |
fp1 = IPAddress.objects.get(floating_ip=True, id=fp1.id)
|
|
| 493 |
fp2 = IPAddress.objects.get(floating_ip=True, id=fp2.id)
|
|
| 494 |
self.assertEqual(fp1.nic.machine, vm)
|
|
| 495 |
self.assertEqual(fp2.nic.machine, vm)
|
|
| 490 | 496 |
name, args, kwargs = mrapi().CreateInstance.mock_calls[2] |
| 491 | 497 |
self.assertEqual(len(kwargs["nics"]), 4) |
| 492 | 498 |
self.assertEqual(kwargs["nics"][0]["network"], |
| 493 | 499 |
bnet3.network.backend_id) |
| 494 |
self.assertEqual(kwargs["nics"][1]["network"], network.backend_id) |
|
| 495 |
self.assertEqual(kwargs["nics"][1]["ip"], fp1.ipv4)
|
|
| 496 |
self.assertEqual(kwargs["nics"][2]["network"], network.backend_id) |
|
| 497 |
self.assertEqual(kwargs["nics"][2]["ip"], fp2.ipv4)
|
|
| 500 |
self.assertEqual(kwargs["nics"][1]["network"], fp1.network.backend_id)
|
|
| 501 |
self.assertEqual(kwargs["nics"][1]["ip"], fp1.address)
|
|
| 502 |
self.assertEqual(kwargs["nics"][2]["network"], fp2.network.backend_id)
|
|
| 503 |
self.assertEqual(kwargs["nics"][2]["ip"], fp2.address)
|
|
| 498 | 504 |
self.assertEqual(kwargs["nics"][3]["network"], |
| 499 | 505 |
bnet4.network.backend_id) |
| 500 | 506 |
|
| ... | ... | |
| 510 | 516 |
"""Test if the create server call returns the expected response |
| 511 | 517 |
if a valid request has been speficied.""" |
| 512 | 518 |
mrapi().CreateInstance.side_effect = GanetiApiError("..ganeti is down")
|
| 513 |
# Create public network and backend |
|
| 514 |
network = mfactory.NetworkFactory(public=True) |
|
| 515 |
backend = mfactory.BackendFactory() |
|
| 516 |
mfactory.BackendNetworkFactory(network=network, backend=backend) |
|
| 517 | 519 |
|
| 518 | 520 |
request = self.request |
| 519 | 521 |
with mocked_quotaholder(): |
Also available in: Unified diff