def test_process_create_exception_process_create_faild(self):
self.mox.StubOutWithMock(self.manager.process_client, "process_create")
fake_name = "fake_name"
fake_key_name = "fake_key_name"
face_security_groups = ["security_group_id1"]
fake_image = "fake_image"
fake_flavor = "fake_flavor"
fake_userdata = "fake_userdata"
fake_meta = "fake_meta"
fake_nics = "fake_nics"
self.manager.process_client.process_create(fake_name,
fake_key_name,
face_security_groups,
fake_image,
fake_flavor,
fake_userdata,
fake_meta,
fake_nics)\
.AndRaise(exception.OpenStackException(400, "fake_msg"))
self.mox.ReplayAll()
try:
self.manager.process_create(self.context, fake_name, fake_key_name,
face_security_groups, fake_image,
fake_flavor, fake_userdata, fake_meta,
fake_nics)
except Exception as e:
self.assertEqual(e.code, 400)
self.assertEqual(e.message, "fake_msg")
def test_keypair_delete_exception_404(self):
self.mox.StubOutWithMock(self.manager.keypair_client, "keypair_delete")
self.manager.keypair_client.keypair_delete("fake_keypair")\
.AndRaise(exception.OpenStackException(404, "fake_msg"))
self.mox.ReplayAll()
self.manager.keypair_delete(self.context, "fake_keypair")
def test_network_create_exception_add_interface_router_faild(self):
fake_neutron_network_id = "fake_neutron_network_id"
fake_name = "fake_name"
fake_cidr = "fake_cidr"
fake_gateway = "fake_gateway"
fake_ext_router = "fake_ext_router"
fake_dns_nameservers = "fake_dns_nameservers"
fake_network = {"network": {"id": fake_neutron_network_id}}
self.neutron_mock.create_network({"network": {"name": fake_name}})\
.AndReturn(fake_network)
fake_subnet_body = {
"subnet": {
"network_id": fake_neutron_network_id,
"ip_version": 4,
"cidr": fake_cidr,
"gateway_ip": fake_gateway,
"dns_nameservers": fake_dns_nameservers
}
}
self.neutron_mock.create_subnet(fake_subnet_body)\
.AndRaise(exception.OpenStackException(400, "fake_msg"))
self.neutron_mock.delete_network(fake_neutron_network_id)
self.mox.ReplayAll()
try:
self.network_client.network_create(fake_name, fake_cidr,
fake_gateway, fake_ext_router,
fake_dns_nameservers)
except Exception as e:
self.assertEqual(e.code, 400)
self.assertEqual(e.message, "fake_msg")
def network_create(self, context, name, cidr, gateway, ext_router,
dns_nameservers):
try:
return self.network_client.network_create(
name, cidr, gateway, ext_router, dns_nameservers)
except Exception as e:
LOG.exception(e)
raise exception.OpenStackException(e.status_code, e.message)
def network_delete(self, context, neutron_network_id, ext_router):
try:
self.network_client.network_delete(neutron_network_id, ext_router)
except Exception as e:
LOG.exception(e)
if e.status_code == 404:
return
raise exception.OpenStackException(e.status_code, e.message)
def process_delete(self, context, nova_instance_id):
try:
self.process_client.process_delete(nova_instance_id)
except Exception as e:
LOG.exception(e)
if e.code == 404:
return
raise exception.OpenStackException(e.code, e.message)
def test_process_delete_exception_404(self):
self.mox.StubOutWithMock(self.manager.process_client, "process_delete")
fake_nova_instance_id = "nova_instance_id1"
self.manager.process_client.process_delete(fake_nova_instance_id)\
.AndRaise(exception.OpenStackException(404, "fake_msg"))
self.mox.ReplayAll()
self.manager.process_delete(self.context, fake_nova_instance_id)
def keypair_delete(self, context, nova_keypair_id):
try:
self.keypair_client.keypair_delete(nova_keypair_id)
except Exception as e:
LOG.exception(e)
if e.code == 404:
return
raise exception.OpenStackException(e.code, e.message)
def test_keypair_show_status_not_exist(self):
self.mox.StubOutWithMock(self.manager.keypair_client, "keypair_show")
self.manager.keypair_client.keypair_show("fake")\
.AndRaise(exception.OpenStackException(404, ""))
self.mox.ReplayAll()
test_keypair = {"nova_keypair_id": "fake"}
self.manager.keypair_show(self.context, test_keypair)
self.assertEqual(test_keypair["status"], "NotExist")
def securitygroup_delete(self, context, neutron_securitygroup_id):
try:
self.securitygroup_client.securitygroup_delete(
neutron_securitygroup_id)
except Exception as e:
if e.status_code == 404:
pass
else:
LOG.exception(e)
raise exception.OpenStackException(e.status_code, e.message)
def process_create(self, context, name, key_name,
security_groups, image, flavor,
userdata, meta, nics):
try:
return self.process_client.process_create(
name, key_name, security_groups, image, flavor,
userdata, meta, nics)
except Exception as e:
LOG.exception(e)
raise exception.OpenStackException(e.code, e.message)
def test_process_show_exception_404(self):
self.mox.StubOutWithMock(self.manager.process_client, "process_show")
fake_nova_instance_id = "nova_instance_id1"
self.manager.process_client.process_show(fake_nova_instance_id)\
.AndRaise(exception.OpenStackException(404, "fake_msg"))
self.mox.ReplayAll()
process = {"nova_instance_id": fake_nova_instance_id}
self.manager.process_show(self.context, process)
self.assertEqual(process["status"], "NotExist")
def keypair_show(self, context, keypair):
try:
self.keypair_client.keypair_show(keypair["nova_keypair_id"])
keypair["status"] = "Exist"
except Exception as e:
LOG.exception(e)
if e.code == 404:
keypair["status"] = "NotExist"
return
raise exception.OpenStackException(e.code, e.message)
def network_show(self, context, network):
try:
self.network_client.network_show(network["neutron_network_id"])
network["status"] = "Exist"
except Exception as e:
LOG.exception(e)
if e.status_code == 404:
network["status"] = "NotExist"
return
raise exception.OpenStackException(e.status_code, e.message)
def test_keypair_delete_exception_not_404(self):
self.mox.StubOutWithMock(self.manager.keypair_client, "keypair_delete")
self.manager.keypair_client.keypair_delete("fake_keypair")\
.AndRaise(exception.OpenStackException(405, "fake_msg"))
self.mox.ReplayAll()
try:
self.manager.keypair_delete(self.context, "fake_keypair")
except Exception as e:
self.assertEqual(e.code, 405)
self.assertEqual(e.message, "fake_msg")
def securitygroup_show(self, context, securitygroup):
try:
self.securitygroup_client.securitygroup_get(
securitygroup['neutron_securitygroup_id'])
securitygroup["status"] = "Exist"
except Exception as e:
if e.status_code == 404:
securitygroup["status"] = "NotExist"
else:
raise exception.OpenStackException(e.status_code, e.message)
return securitygroup
def test_process_delete_exception_not_404(self):
self.mox.StubOutWithMock(self.manager.process_client, "process_delete")
fake_nova_instance_id = "nova_instance_id1"
self.manager.process_client.process_delete(fake_nova_instance_id)\
.AndRaise(exception.OpenStackException(400, "fake_msg"))
self.mox.ReplayAll()
try:
self.manager.process_delete(self.context, fake_nova_instance_id)
except Exception as e:
self.assertEqual(e.code, 400)
self.assertEqual(e.message, "fake_msg")
def test_keypair_show_exception(self):
self.mox.StubOutWithMock(self.manager.keypair_client, "keypair_show")
self.manager.keypair_client.keypair_show("fake")\
.AndRaise(exception.OpenStackException(405, "fake_msg"))
self.mox.ReplayAll()
test_keypair = {"nova_keypair_id": "fake"}
try:
self.manager.keypair_show(self.context, test_keypair)
except Exception as e:
self.assertEqual(e.code, 405)
self.assertEqual(e.message, "fake_msg")
def network_list(self, context, networks):
try:
ids = self.network_client.network_list()
except Exception as e:
LOG.exception(e)
raise exception.OpenStackException(e.status_code, e.message)
for network in networks:
if network["neutron_network_id"] in ids:
network["status"] = "Exist"
else:
network["status"] = "NotExist"
return networks
def securitygroup_list(self, context, securitygroups):
try:
neutron_securitygroup_ids = self.securitygroup_client.\
securitygroup_list()
except Exception as e:
raise exception.OpenStackException(e.status_code, e.message)
for securitygroup in securitygroups:
if securitygroup["neutron_securitygroup_id"] in\
neutron_securitygroup_ids:
securitygroup["status"] = "Exist"
else:
securitygroup["status"] = "NotExist"
return securitygroups
def keypair_list(self, context, keypairs):
try:
ids = self.keypair_client.keypair_list()
except Exception as e:
LOG.exception(e)
raise exception.OpenStackException(e.code, e.message)
for keypair in keypairs:
if keypair["nova_keypair_id"] in ids:
keypair["status"] = "Exist"
else:
keypair["status"] = "NotExist"
return keypairs
def test_get_process_address_exception_get_process_address_faild(self):
self.mox.StubOutWithMock(self.manager.process_client,
"get_process_address")
fake_nova_instance_id = "nova_instance_id1"
self.manager.process_client.get_process_address(fake_nova_instance_id)\
.AndRaise(exception.OpenStackException(400, "fake_msg"))
self.mox.ReplayAll()
try:
self.manager.get_process_address(self.context,
fake_nova_instance_id)
except Exception as e:
self.assertEqual(e.code, 400)
self.assertEqual(e.message, "fake_msg")
def test_keypair_list_exception_OpenStackException(self):
self.mox.StubOutWithMock(self.manager.keypair_client, "keypair_list")
self.manager.keypair_client.keypair_list()\
.AndRaise(exception.OpenStackException(400, "fake"))
self.mox.ReplayAll()
test_keypairs = [{
"nova_keypair_id": "nova_keypair_ids1"
}, {
"nova_keypair_id": "nova_keypair_ids2"
}]
try:
self.manager.keypair_list(self.context, test_keypairs)
except Exception as e:
self.assertEqual(e.code, 400)
self.assertEqual(e.message, "fake")
def process_show(self, context, process):
try:
nova_process = self.process_client.process_show(
process["nova_instance_id"])
process["status"] = nova_process["status"]
for nova_network in nova_process["networks"]:
for network in process["networks"]:
if(nova_network["display_name"] ==
network["display_name"]):
network.update(nova_network)
except Exception as e:
LOG.exception(e)
if e.code == 404:
process["status"] = "NotExist"
return
raise exception.OpenStackException(e.code, e.message)
def test_processes_list_exception(self):
self.mox.StubOutWithMock(self.manager.process_client, "process_list")
fake_processes = [{
"nova_instance_id": "nova_instance_id1",
"status": "Active"
}, {
"nova_instance_id": "nova_instance_id2",
"status": "Active"
}]
self.manager.process_client.process_list()\
.AndRaise(exception.OpenStackException(400, "fake_msg"))
self.mox.ReplayAll()
try:
self.manager.process_list(self.context, fake_processes)
except Exception as e:
self.assertEqual(e.code, 400)
self.assertEqual(e.message, "fake_msg")
def process_list(self, context, processes):
try:
nova_process_list = self.process_client.process_list()
except Exception as e:
LOG.exception(e)
raise exception.OpenStackException(e.code, e.message)
for process in processes:
is_exist = False
for nova_process in nova_process_list:
if process["nova_instance_id"] ==\
nova_process["nova_instance_id"]:
is_exist = True
process["status"] = nova_process["status"]
for nova_network in nova_process["networks"]:
for network in process["networks"]:
if(nova_network["display_name"] ==
network["display_name"]):
network.update(nova_network)
break
if not is_exist:
process["status"] = "NotExist"
return processes
def keypair_create(self, context, name):
try:
return self.keypair_client.keypair_create(name)
except Exception as e:
LOG.exception(e)
raise exception.OpenStackException(e.code, e.message)
def get_process_address(self, context, nova_instance_id):
try:
return self.process_client.get_process_address(nova_instance_id)
except Exception as e:
LOG.exception(e)
raise exception.OpenStackException(e.code, e.message)
def securitygroup_create(self, context, name, securitygrouprules):
try:
return self.securitygroup_client.securitygroup_create(
name, securitygrouprules)
except Exception as e:
raise exception.OpenStackException(e.status_code, e.message)
