def test_snf_create_server_with_user_data(gr, gfr, _oa, snfci):
"""Test snf_create_server with user data"""
cls, req = fakes.DummyClass(), fakes.FakeReq()
req.environ['HTTP_X_PROJECT_ID'] = 'a project id'
args = ('a name', 'an image', 'a flavor')
r = compute.snf_create_server(cls, req, *args, user_data='user data')
assert r == _response
exp_personlity = {
"path": "/var/lib/cloud/seed/nocloud-net/user-data",
"contents": b64encode('user data')
}
assert req.environ == {
'HTTP_X_PROJECT_ID':
'a project id',
'service_type':
'compute',
'method_name':
'servers_post',
'kwargs':
dict(json_data=dict(server=dict(name='a name',
imageRef='an image',
flavorRef='a flavor',
project='a project id',
personality=[
exp_personlity,
])))
}
gr.assert_called_once_with(cls.app)
gfr.assert_called_once_with('my response', 'server', {})
_oa.assert_called_once_with(_response['addresses'],
_response['attachments'])
def test__snf_create_floating_ip(gr, gfr):
"""Test _snf_create_floating_ip method"""
cls, req = fakes.DummyClass(), fakes.FakeReq()
project_id = 'a project id'
req.environ['HTTP_X_PROJECT_ID'] = project_id
network_links._snf_create_floating_ip(cls, req)
data = {
'floatingip': {
'floating_network_id': None,
'floating_ip_address': '',
'project': project_id
}
}
assert req.environ == dict(HTTP_X_PROJECT_ID=project_id,
service_type='network',
method_name='floatingips_post',
kwargs={
'success': 200,
'json_data': data
})
gr.assert_called_once_with(cls.app)
gfr.assert_called_once_with('my response', 'floatingip', {})
def test_empty_list_200(gr, gfr):
"""Test the empty list method"""
cls, req = fakes.DummyClass(), fakes.FakeReq()
r = utils.empty_list_200(cls, req)
assert r == 'g f r'
gfr.assert_called_once_with('my response', 'empty list', [])
gr.assert_called_once_with(cls.app)
def test_snf_create_server_with_pk(gr, gfr, _oa, gp, snfci):
"""Test snf_create_server with pk"""
cls, req = fakes.DummyClass(), fakes.FakeReq()
req.environ['soi:public_keys'] = {'key_name': 'some key'}
req.environ['HTTP_X_PROJECT_ID'] = 'a project id'
args = ('a name', 'an image', 'a flavor')
r = compute.snf_create_server(cls, req, *args, key_name='key_name')
assert r == _response
assert req.environ == {
'HTTP_X_PROJECT_ID':
'a project id',
'service_type':
'compute',
'method_name':
'servers_post',
'soi:public_keys': {
'key_name': 'some key'
},
'kwargs':
dict(json_data=dict(server=dict(name='a name',
imageRef='an image',
flavorRef='a flavor',
project='a project id',
personality=[
'some key',
])))
}
gr.assert_called_once_with(cls.app)
gfr.assert_called_once_with('my response', 'server', {})
_oa.assert_called_once_with(_response['addresses'],
_response['attachments'])
def test_snf_delete_network_link(gp, dp):
"""Test snf_delete_network_link method"""
cls, req = fakes.DummyClass(), fakes.FakeReq()
compute_id = port_id = 'test_id'
network_links.snf_delete_network_link(cls, req, compute_id, port_id)
gp.assert_called_once_with(cls, req, compute_id)
dp.assert_called_once_with(cls, req, compute_id, port_id)
def _test_snf_run_action(action, json_data, gr):
"""used by "test_snf_run_action_* methods"""
cls, req = fakes.DummyClass(), fakes.FakeReq()
compute.snf_run_action(cls, req, action, 'my server id')
assert req.environ == dict(service_type='compute',
method_name='servers_action_post',
kwargs=dict(server_id='my server id',
json_data=json_data))
gr.assert_called_once_with(cls.app)
def test_snf_index(gr, gfr):
"""Test snf_index"""
cls, req = fakes.DummyClass(), fakes.FakeReq()
r = compute.snf_index(cls, req)
assert r == 'g f r'
assert req.environ == dict(service_type='compute',
method_name='servers_get')
gr.assert_called_once_with(cls.app)
gfr.assert_called_once_with('my response', 'servers', [])
def test_snf_delete_server(gr):
"""Test snf_delete_server"""
cls, req = fakes.DummyClass(), fakes.FakeReq()
compute.snf_delete_server(cls, req, 'my server id')
assert req.environ == dict(service_type='compute',
method_name='servers_delete',
kwargs=dict(server_id='my server id'))
gr.assert_called_once_with(cls.app)
def test_snf_get_images(gr, gfr):
"""Test snf_get_images"""
cls, req = fakes.DummyClass(), fakes.FakeReq()
r = compute.snf_get_images(cls, req)
assert r == 'g f r'
assert req.environ == dict(service_type='compute',
method_name='images_get',
kwargs=dict(detail=True))
gr.assert_called_once_with(cls.app)
gfr.assert_called_once_with('my response', 'images', [])
def test_snf_create_network_link2(sn, cppnet):
"""Test snf_create_network_link
Case of private network
"""
cls, req = fakes.DummyClass(), fakes.FakeReq()
network_id = device_id = 'test_id'
network_links.snf_create_network_link(cls, req, network_id, device_id)
sn.assert_called_once_with(cls, req, network_id)
cppnet.assert_called_once_with(cls, req, network_id, device_id)
def test_snf_get_server_volume_links(gr, gfr):
"""Test snf_get_server_volume_links"""
cls, req = fakes.DummyClass(), fakes.FakeReq()
r = compute.snf_get_server_volumes_link(cls, req, 'my server id')
assert r == 'g f r'
assert req.environ == dict(service_type='compute',
method_name='volume_attachment_get',
kwargs=dict(server_id='my server id'))
gr.assert_called_once_with(cls.app)
gfr.assert_called_once_with('my response', 'volumeAttachments', [])
def test_snf_get_image(gr, gfr):
"""Test snf_get_image"""
cls, req = fakes.DummyClass(), fakes.FakeReq()
r = compute.snf_get_image(cls, req, 'my image id')
assert r == 'g f r'
assert req.environ == dict(service_type='compute',
method_name='images_get',
kwargs=dict(image_id='my image id'))
gr.assert_called_once_with(cls.app)
gfr.assert_called_once_with('my response', 'image', {})
def test_snf_delete_volume(gr):
"""Test snf_delete_volume """
cls, req = fakes.DummyClass(), fakes.FakeReq()
volume_id = 'a volume id'
storage.snf_delete_volume(cls, req, volume_id)
assert req.environ == dict(service_type='volume',
method_name='volumes_delete',
kwargs={'volume_id': volume_id})
gr.assert_called_once_with(cls.app)
def test_keypair_register():
"""Test keypair_register"""
cls, req = fakes.DummyClass(), fakes.FakeReq()
name, pk = 'key_name', 'rsa-ssa keystuffhere ==user@host'
compute.keypair_register(cls, req, name, pk)
assert 'soi:public_keys' in req.environ
assert req.environ['soi:public_keys'] == {name: pk}
name0, pk0 = 'key_name0', 'rsa-ssa otherstuffhere ==user@host'
compute.keypair_register(cls, req, name0, pk0)
assert req.environ['soi:public_keys'] == {name: pk, name0: pk0}
def test_snf_get_server_net_attachments(gr, gfr, _ona):
"""Test snf_get_server_net_attachments"""
cls, req = fakes.DummyClass(), fakes.FakeReq()
r = compute.snf_get_server_net_attachments(cls, req, 'my server id')
assert r == 'g f r'
assert req.environ == dict(service_type='compute',
method_name='servers_ips_get',
kwargs=dict(server_id='my server id'))
gr.assert_called_once_with(cls.app)
gfr.assert_called_once_with('my response', 'attachments', [])
_ona.assert_called_once_with('g f r')
def test_snf_list_networks(gr, gfr, _osnr, bn):
"""Test snf_list_networks method"""
cls, req = fakes.DummyClass(), fakes.FakeReq()
network.snf_list_networks(cls, req)
assert req.environ == dict(service_type='network',
method_name='networks_get')
gr.assert_called_once_with(cls.app)
gfr.assert_called_once_with('my response', 'networks', [])
_osnr.assert_called_once_with('g f r')
bn.assert_called_once_with('g f r')
def test_snf_get_volumes(gr, gfr, _ovdns):
"""Test snf_get_volumes method"""
cls, req = fakes.DummyClass(), fakes.FakeReq()
storage.snf_get_volumes(cls, req)
assert req.environ == dict(service_type='volume',
method_name='volumes_get',
kwargs={'detail': True})
gr.assert_called_once_with(cls.app)
gfr.assert_called_once_with('my response', 'volumes', [])
_ovdns.assert_called_once_with('g f r')
def test_snf_list_floating_ips(gr, gfr, _osnr):
"""Test snf_list_networks method"""
cls, req = fakes.DummyClass(), fakes.FakeReq()
network_links.snf_list_floating_ips(cls, req)
assert req.environ == dict(service_type='network',
method_name='floatingips_get',
kwargs={'success': 200})
gr.assert_called_once_with(cls.app)
gfr.assert_called_once_with('my response', 'floatingips', [])
_osnr.assert_called_once_with('g f r')
def test_snf_get_subnet(gr, gfr):
"""Test snf_get_subnet method"""
cls, req = fakes.DummyClass(), fakes.FakeReq()
subnet_id = 'sbnt_id'
network._snf_get_subnet(cls, req, subnet_id)
assert req.environ == dict(service_type='network',
method_name='subnets_get',
kwargs={'subnet_id': subnet_id})
gr.assert_called_once_with(cls.app)
gfr.assert_called_once_with('my response', 'subnet', {})
def test_snf_get_server(gr, gfr, _oa):
"""Test snf_get_server"""
cls, req = fakes.DummyClass(), fakes.FakeReq()
r = compute.snf_get_server(cls, req, 'my server id')
assert r == _response
assert req.environ == dict(service_type='compute',
method_name='servers_get',
kwargs=dict(server_id='my server id'))
gr.assert_called_once_with(cls.app)
gfr.assert_called_once_with('my response', 'server', {})
_oa.assert_called_once_with(_response['addresses'],
_response['attachments'])
def test_snf_show_network(gr, gfr, _osnr, bn):
"""Test snf_show_network method"""
cls, req = fakes.DummyClass(), fakes.FakeReq()
net_id = 'network_id'
network.snf_show_network(cls, req, net_id)
assert req.environ == dict(service_type='network',
method_name='networks_get',
kwargs={'network_id': net_id})
gr.assert_called_once_with(cls.app)
gfr.assert_called_once_with('my response', 'network', {})
_osnr.assert_called_once_with([{'subnets': []}], False)
bn.assert_called_once_with([{'subnets': []}])
def test_snf_get_volume(gr, gfr, _ovdn):
"""Test snd_get_volume method"""
cls, req = fakes.DummyClass(), fakes.FakeReq()
volume_id = 'volume_id'
storage.snf_get_volume_info(cls, req, volume_id)
assert req.environ == dict(service_type='volume',
method_name='volumes_get',
kwargs={'volume_id': volume_id})
gr.assert_called_once_with(cls.app)
gfr.assert_called_once_with('my response', 'volume', [])
_ovdn.assert_called_once_with('g f r')
def test_snf_delete_network(gr):
"""Test snf_delete_network method"""
cls, req = fakes.DummyClass(), fakes.FakeReq()
net_id = 'network_id'
network.snf_delete_network(cls, req, net_id)
assert req.environ == dict(service_type='network',
method_name='networks_delete',
kwargs={
'network_id': net_id,
'success': (204, )
})
gr.assert_called_once_with(cls.app)
def test_snf_get_server_volume_links(gr, gfr):
"""Test snf_get_server_volume_links method"""
cls, req = fakes.DummyClass(), fakes.FakeReq()
server_id = '1234'
storage_link.snf_get_server_volume_links(cls, req, server_id)
assert req.environ == dict(
service_type='compute',
method_name='volume_attachment_get',
kwargs={'server_id': server_id}
)
gr.assert_called_once_with(cls.app)
gfr.assert_called_once_with('my response', 'volumeAttachments', [])
def test__snf_delete_port(gr):
"""Test _snf_delete_port method"""
cls, req = fakes.DummyClass(), fakes.FakeReq()
compute_id = ip_id = 'test'
network_links._snf_delete_port(cls, req, compute_id, ip_id)
assert req.environ == dict(service_type='network',
method_name='ports_delete',
kwargs={
'port_id': ip_id,
'server_id': compute_id,
'success': 204
})
gr.assert_called_once_with(cls.app)
def test_snf_create_network_link(sn, allocfip):
"""Test snf_create_network_link
Case of public network
"""
cls, req = fakes.DummyClass(), fakes.FakeReq()
network_id = device_id = 'test_id'
network_links.snf_create_network_link(cls, req, network_id, device_id)
sn.assert_called_once_with(cls, req, network_id)
allocfip.assert_called_once_with(cls,
req,
network_id,
device_id,
pool=None)
def test_snf_delete_server_volumes_link(gr):
"""Test snf_delete_server_volumes_link method"""
cls, req = fakes.DummyClass(), fakes.FakeReq()
server_id = '1234'
volume_id = '666'
storage_link. snf_delete_server_volumes_link(cls, req, server_id,
volume_id)
assert req.environ == dict(
service_type='compute',
method_name='volume_attachment_delete',
kwargs={'server_id': server_id,
'attachment_id': volume_id}
)
gr.assert_called_once_with(cls.app)
def test_snf_get_ports(gr, gfr, _fp, _osnr):
"""Test snf_get_ports method"""
cls, req = fakes.DummyClass(), fakes.FakeReq()
server_id = 'srv_id'
network_links.snf_get_ports(cls, req, server_id)
assert req.environ == dict(service_type='network',
method_name='ports_get',
kwargs={
'success': 200,
'device_id': server_id
})
gr.assert_called_once_with(cls.app)
gfr.assert_called_once_with('my response', 'ports', [])
_fp.assert_called_once_with([], server_id)
_osnr.assert_called_once_with('f p')
def test__snf_allocate_floating_ip2(lsfips, cfips, cppn, bl):
"""Test _snf_allocate_floating_ip method
Case of none existing floating ips
"""
cls, req = fakes.DummyClass(), fakes.FakeReq()
network_id = device_id = 'test_id'
pool = None
network_links.snf_allocate_floating_ip(cls, req, network_id, device_id,
pool)
lsfips.assert_called_once_with(cls, req)
cfips.assert_called_once_with(cls, req)
floating_network_id = create_floating_ip_results['floating_network_id']
floating_ip_address = create_floating_ip_results['floating_ip_address']
cppn.assert_called_once_with(cls, req, floating_network_id, device_id,
floating_ip_address)
bl.assert_called_once_with(floating_network_id, device_id,
floating_ip_address, floating_network_id)
def test__snf_allocate_floating_ip1(lsfips, cppn, bl):
"""Test _snf_allocate_floating_ip method
Case of existing floating ips
"""
cls, req = fakes.DummyClass(), fakes.FakeReq()
network_id = device_id = 'test_id'
pool = None
network_links.snf_allocate_floating_ip(cls, req, network_id, device_id,
pool)
lsfips.assert_called_once_with(cls, req)
floating_network_id = floating_ips_listing_results[0]["floating_"
"network_id"]
floating_ip_address = floating_ips_listing_results[0]["floating_ip_"
"address"]
cppn.assert_called_once_with(cls, req, floating_network_id, device_id,
floating_ip_address)
bl.assert_called_once_with(floating_network_id, device_id,
floating_ip_address, floating_network_id)
