def test_create_server_with_admin_pass_wait(self, mock_nova, mock_wait):
"""
Test that a server with an admin_pass passed returns the password
"""
fake_server = fakes.FakeServer('1234', '', 'BUILD')
fake_server_with_pass = fakes.FakeServer('1234', '', 'BUILD',
adminPass='******')
mock_nova.servers.create.return_value = fake_server
mock_nova.servers.get.return_value = fake_server
# The wait returns non-password server
mock_wait.return_value = _utils.normalize_server(
meta.obj_to_dict(fake_server), None, None)
server = self.client.create_server(
name='server-name', image='image-id',
flavor='flavor-id', admin_pass='******', wait=True)
# Assert that we did wait
self.assertTrue(mock_wait.called)
# Even with the wait, we should still get back a passworded server
self.assertEqual(
server,
_utils.normalize_server(meta.obj_to_dict(fake_server_with_pass),
None, None)
)
def test_create_volume_snapshot_wait(self, mock_cinder):
"""
Test that create_volume_snapshot with a wait returns the volume
snapshot when its status changes to "available".
"""
build_snapshot = fakes.FakeVolumeSnapshot('1234', 'creating',
'foo', 'derpysnapshot')
fake_snapshot = fakes.FakeVolumeSnapshot('1234', 'available',
'foo', 'derpysnapshot')
mock_cinder.volume_snapshots.create.return_value = build_snapshot
mock_cinder.volume_snapshots.get.return_value = fake_snapshot
mock_cinder.volume_snapshots.list.return_value = [
build_snapshot, fake_snapshot]
self.assertEqual(
meta.obj_to_dict(fake_snapshot),
self.client.create_volume_snapshot(volume_id='1234',
wait=True)
)
mock_cinder.volume_snapshots.create.assert_called_with(
display_description=None, display_name=None, force=False,
volume_id='1234'
)
mock_cinder.volume_snapshots.get.assert_called_with(
snapshot_id=meta.obj_to_dict(build_snapshot)['id']
)
def test_has_volume(self):
mock_cloud = mock.MagicMock()
mock_volume = mock.MagicMock()
mock_volume.id = "volume1"
mock_volume.status = "available"
mock_volume.display_name = "Volume 1 Display Name"
mock_volume.attachments = [{"device": "/dev/sda0"}]
mock_volume_dict = meta.obj_to_dict(mock_volume)
mock_cloud.get_volumes.return_value = [mock_volume_dict]
hostvars = meta.get_hostvars_from_server(mock_cloud, meta.obj_to_dict(FakeServer()))
self.assertEquals("volume1", hostvars["volumes"][0]["id"])
self.assertEquals("/dev/sda0", hostvars["volumes"][0]["device"])
def test_list_volumes_creating_invalidates(self, cinder_mock):
fake_volume = fakes.FakeVolume('volume1', 'creating',
'Volume 1 Display Name')
fake_volume_dict = meta.obj_to_dict(fake_volume)
cinder_mock.volumes.list.return_value = [fake_volume]
self.assertEqual([fake_volume_dict], self.cloud.list_volumes())
fake_volume2 = fakes.FakeVolume('volume2', 'available',
'Volume 2 Display Name')
fake_volume2_dict = meta.obj_to_dict(fake_volume2)
cinder_mock.volumes.list.return_value = [fake_volume, fake_volume2]
self.assertEqual([fake_volume_dict, fake_volume2_dict],
self.cloud.list_volumes())
def test_has_volume(self):
mock_cloud = mock.MagicMock()
mock_volume = mock.MagicMock()
mock_volume.id = 'volume1'
mock_volume.status = 'available'
mock_volume.display_name = 'Volume 1 Display Name'
mock_volume.attachments = [{'device': '/dev/sda0'}]
mock_volume_dict = meta.obj_to_dict(mock_volume)
mock_cloud.get_volumes.return_value = [mock_volume_dict]
hostvars = meta.get_hostvars_from_server(
mock_cloud, meta.obj_to_dict(FakeServer()))
self.assertEquals('volume1', hostvars['volumes'][0]['id'])
self.assertEquals('/dev/sda0', hostvars['volumes'][0]['device'])
def test_create_volume_invalidates(self, cinder_mock):
mock_volb4 = mock.MagicMock()
mock_volb4.id = 'volume1'
mock_volb4.status = 'available'
mock_volb4.display_name = 'Volume 1 Display Name'
mock_volb4_dict = meta.obj_to_dict(mock_volb4)
cinder_mock.volumes.list.return_value = [mock_volb4]
self.assertEqual([mock_volb4_dict], self.cloud.list_volumes())
volume = dict(display_name='junk_vol',
size=1,
display_description='test junk volume')
mock_vol = mock.Mock()
mock_vol.status = 'creating'
mock_vol.id = '12345'
mock_vol_dict = meta.obj_to_dict(mock_vol)
cinder_mock.volumes.create.return_value = mock_vol
cinder_mock.volumes.list.return_value = [mock_volb4, mock_vol]
def creating_available():
def now_available():
mock_vol.status = 'available'
mock_vol_dict['status'] = 'available'
return mock.DEFAULT
cinder_mock.volumes.list.side_effect = now_available
return mock.DEFAULT
cinder_mock.volumes.list.side_effect = creating_available
self.cloud.create_volume(wait=True, timeout=None, **volume)
self.assertTrue(cinder_mock.volumes.create.called)
self.assertEqual(3, cinder_mock.volumes.list.call_count)
# If cache was not invalidated, we would not see our own volume here
# because the first volume was available and thus would already be
# cached.
self.assertEqual([mock_volb4_dict, mock_vol_dict],
self.cloud.list_volumes())
# And now delete and check same thing since list is cached as all
# available
mock_vol.status = 'deleting'
mock_vol_dict = meta.obj_to_dict(mock_vol)
def deleting_gone():
def now_gone():
cinder_mock.volumes.list.return_value = [mock_volb4]
return mock.DEFAULT
cinder_mock.volumes.list.side_effect = now_gone
return mock.DEFAULT
cinder_mock.volumes.list.return_value = [mock_volb4, mock_vol]
cinder_mock.volumes.list.side_effect = deleting_gone
cinder_mock.volumes.delete.return_value = mock_vol_dict
self.cloud.delete_volume('12345')
self.assertEqual([mock_volb4_dict], self.cloud.list_volumes())
def test_has_volume(self):
mock_cloud = mock.MagicMock()
fake_volume = fakes.FakeVolume(
id='volume1',
status='available',
name='Volume 1 Display Name',
attachments=[{'device': '/dev/sda0'}])
fake_volume_dict = meta.obj_to_dict(fake_volume)
mock_cloud.get_volumes.return_value = [fake_volume_dict]
hostvars = meta.get_hostvars_from_server(
mock_cloud, meta.obj_to_dict(standard_fake_server))
self.assertEquals('volume1', hostvars['volumes'][0]['id'])
self.assertEquals('/dev/sda0', hostvars['volumes'][0]['device'])
def test_list_images_ignores_unsteady_status(self, glance_mock):
steady_image = fakes.FakeImage('68', 'Jagr', 'active')
steady_image_dict = meta.obj_to_dict(steady_image)
for status in ('queued', 'saving', 'pending_delete'):
active_image = fakes.FakeImage(self.getUniqueString(),
self.getUniqueString(), status)
glance_mock.images.list.return_value = [active_image]
active_image_dict = meta.obj_to_dict(active_image)
self.assertEqual([active_image_dict],
self.cloud.list_images())
glance_mock.images.list.return_value = [active_image, steady_image]
# Should expect steady_image to appear if active wasn't cached
self.assertEqual([active_image_dict, steady_image_dict],
self.cloud.list_images())
def test_image_string(self, mock_get_server_external_ipv4):
mock_get_server_external_ipv4.return_value = PUBLIC_V4
server = FakeServer()
server.image = "fake-image-id"
hostvars = meta.get_hostvars_from_server(FakeCloud(), meta.obj_to_dict(server))
self.assertEquals("fake-image-id", hostvars["image"]["id"])
def test_private_interface_ip(self, mock_get_server_external_ipv4):
mock_get_server_external_ipv4.return_value = PUBLIC_V4
cloud = FakeCloud()
cloud.private = True
hostvars = meta.get_hostvars_from_server(cloud, meta.obj_to_dict(FakeServer()))
self.assertEqual(PRIVATE_V4, hostvars["interface_ip"])
def test_get_server_internal_provider_ipv4_neutron(
self, mock_list_networks, mock_list_subnets,
mock_has_service):
# Testing Clouds with Neutron
mock_has_service.return_value = True
mock_list_subnets.return_value = SUBNETS_WITH_NAT
mock_list_networks.return_value = [{
'id': 'test-net-id',
'name': 'test-net',
'router:external': False,
'provider:network_type': 'vxlan',
'provider:physical_network': None,
}]
srv = meta.obj_to_dict(fakes.FakeServer(
id='test-id', name='test-name', status='ACTIVE',
addresses={'test-net': [{
'addr': PRIVATE_V4,
'version': 4}]},
))
self.assertIsNone(
meta.get_server_external_ipv4(cloud=self.cloud, server=srv))
int_ip = meta.get_server_private_ip(cloud=self.cloud, server=srv)
self.assertEqual(PRIVATE_V4, int_ip)
def test_create_server_with_admin_pass_no_wait(self):
"""
Test that a server with an admin_pass passed returns the password
"""
with patch("shade.OpenStackCloud"):
fake_server = fakes.FakeServer('1234', '', 'BUILD')
fake_create_server = fakes.FakeServer('1234', '', 'BUILD',
adminPass='******')
fake_floating_ip = fakes.FakeFloatingIP('1234', 'ippool',
'1.1.1.1', '2.2.2.2',
'5678')
config = {
"servers.create.return_value": fake_create_server,
"servers.get.return_value": fake_server,
"floating_ips.list.return_value": [fake_floating_ip]
}
OpenStackCloud.nova_client = Mock(**config)
self.assertEqual(
_utils.normalize_server(
meta.obj_to_dict(fake_create_server),
cloud_name=self.client.name,
region_name=self.client.region_name),
self.client.create_server(
name='server-name', image='image=id',
flavor='flavor-id', admin_pass='******'))
def test_create_volume_snapshot_with_error(self, mock_cinder):
"""
Test that a error status while waiting for the volume snapshot to
create raises an exception in create_volume_snapshot.
"""
build_snapshot = fakes.FakeVolumeSnapshot('1234', 'creating',
'bar', 'derpysnapshot')
error_snapshot = fakes.FakeVolumeSnapshot('1234', 'error',
'blah', 'derpysnapshot')
mock_cinder.volume_snapshots.create.return_value = build_snapshot
mock_cinder.volume_snapshots.get.return_value = error_snapshot
mock_cinder.volume_snapshots.list.return_value = [error_snapshot]
self.assertRaises(
OpenStackCloudException,
self.client.create_volume_snapshot, volume_id='1234',
wait=True, timeout=5)
mock_cinder.volume_snapshots.create.assert_called_with(
display_description=None, display_name=None, force=False,
volume_id='1234'
)
mock_cinder.volume_snapshots.get.assert_called_with(
snapshot_id=meta.obj_to_dict(build_snapshot)['id']
)
def test_update_domain(self, mock_keystone, mock_normalize):
mock_keystone.domains.update.return_value = domain_obj
self.cloud.update_domain("domain_id", name="new name", description="new description", enabled=False)
mock_keystone.domains.update.assert_called_once_with(
domain="domain_id", name="new name", description="new description", enabled=False
)
mock_normalize.assert_called_once_with([meta.obj_to_dict(domain_obj)])
def test_create_domain(self, mock_keystone, mock_normalize):
mock_keystone.domains.create.return_value = domain_obj
self.cloud.create_domain(domain_obj.name, domain_obj.description)
mock_keystone.domains.create.assert_called_once_with(
name=domain_obj.name, description=domain_obj.description, enabled=True
)
mock_normalize.assert_called_once_with([meta.obj_to_dict(domain_obj)])
def test_az(self, mock_get_server_external_ipv4):
mock_get_server_external_ipv4.return_value = PUBLIC_V4
server = FakeServer()
server.__dict__["OS-EXT-AZ:availability_zone"] = "az1"
hostvars = meta.get_hostvars_from_server(FakeCloud(), meta.obj_to_dict(server))
self.assertEquals("az1", hostvars["az"])
def test_rebuild_server_with_admin_pass_wait(self):
"""
Test that a server with an admin_pass passed returns the password
"""
with patch("shade.OpenStackCloud"):
rebuild_server = fakes.FakeServer('1234', '', 'REBUILD',
adminPass='******')
active_server = fakes.FakeServer('1234', '', 'ACTIVE')
ret_active_server = fakes.FakeServer('1234', '', 'ACTIVE',
adminPass='******')
fake_floating_ip = fakes.FakeFloatingIP('1234', 'ippool',
'1.1.1.1', '2.2.2.2',
'5678')
config = {
"servers.rebuild.return_value": rebuild_server,
"servers.get.return_value": active_server,
"floating_ips.list.return_value": [fake_floating_ip]
}
OpenStackCloud.nova_client = Mock(**config)
self.client.name = 'cloud-name'
self.assertEqual(
_utils.normalize_server(
meta.obj_to_dict(ret_active_server),
cloud_name='cloud-name', region_name=''),
self.client.rebuild_server("a", "b", wait=True,
admin_pass='******'))
def test_get_server_external_ipv4_neutron_accessIPv6(self):
srv = meta.obj_to_dict(fakes.FakeServer(
id='test-id', name='test-name', status='ACTIVE',
accessIPv6=PUBLIC_V6))
ip = meta.get_server_external_ipv6(server=srv)
self.assertEqual(PUBLIC_V6, ip)
def test_basic_hostvars(
self, mock_get_server_external_ipv4,
mock_get_server_external_ipv6):
mock_get_server_external_ipv4.return_value = PUBLIC_V4
mock_get_server_external_ipv6.return_value = PUBLIC_V6
hostvars = meta.get_hostvars_from_server(
FakeCloud(), _utils.normalize_server(
meta.obj_to_dict(FakeServer()),
cloud_name='CLOUD_NAME',
region_name='REGION_NAME'))
self.assertNotIn('links', hostvars)
self.assertEqual(PRIVATE_V4, hostvars['private_v4'])
self.assertEqual(PUBLIC_V4, hostvars['public_v4'])
self.assertEqual(PUBLIC_V6, hostvars['public_v6'])
self.assertEqual(PUBLIC_V6, hostvars['interface_ip'])
self.assertEquals('REGION_NAME', hostvars['region'])
self.assertEquals('CLOUD_NAME', hostvars['cloud'])
self.assertEquals("test-image-name", hostvars['image']['name'])
self.assertEquals(FakeServer.image['id'], hostvars['image']['id'])
self.assertNotIn('links', hostvars['image'])
self.assertEquals(FakeServer.flavor['id'], hostvars['flavor']['id'])
self.assertEquals("test-flavor-name", hostvars['flavor']['name'])
self.assertNotIn('links', hostvars['flavor'])
# test having volumes
# test volume exception
self.assertEquals([], hostvars['volumes'])
def test_list_volumes(self, cinder_mock):
fake_volume = fakes.FakeVolume('volume1', 'available',
'Volume 1 Display Name')
fake_volume_dict = _utils.normalize_volumes(
[meta.obj_to_dict(fake_volume)])[0]
cinder_mock.volumes.list.return_value = [fake_volume]
self.assertEqual([fake_volume_dict], self.cloud.list_volumes())
fake_volume2 = fakes.FakeVolume('volume2', 'available',
'Volume 2 Display Name')
fake_volume2_dict = _utils.normalize_volumes(
[meta.obj_to_dict(fake_volume2)])[0]
cinder_mock.volumes.list.return_value = [fake_volume, fake_volume2]
self.assertEqual([fake_volume_dict], self.cloud.list_volumes())
self.cloud.list_volumes.invalidate(self.cloud)
self.assertEqual([fake_volume_dict, fake_volume2_dict],
self.cloud.list_volumes())
def test_get_machine(self, mock_client):
node = fakes.FakeMachine(id='00000000-0000-0000-0000-000000000000',
name='bigOlFaker')
mock_client.node.get.return_value = node
machine = self.cloud.get_machine('bigOlFaker')
mock_client.node.get.assert_called_with(node_id='bigOlFaker')
self.assertEqual(meta.obj_to_dict(node), machine)
def test_get_flavor_by_ram(self, mock_list):
class Flavor1(object):
id = '1'
name = 'vanilla ice cream'
ram = 100
class Flavor2(object):
id = '2'
name = 'chocolate ice cream'
ram = 200
vanilla = meta.obj_to_dict(Flavor1())
chocolate = meta.obj_to_dict(Flavor2())
mock_list.return_value = [vanilla, chocolate]
flavor = self.cloud.get_flavor_by_ram(ram=150)
self.assertEquals(chocolate, flavor)
def wait(self, raw):
self._finished.wait()
if self._exception:
six.reraise(type(self._exception), self._exception,
self._traceback)
if raw:
# Do NOT convert the result.
return self._result
# NOTE(Shrews): Since the client API might decide to subclass one
# of these result types, we use isinstance() here instead of type().
if (isinstance(self._result, list) or
isinstance(self._result, types.GeneratorType)):
return meta.obj_list_to_dict(
self._result, request_id=self._request_id)
elif (not isinstance(self._result, bool) and
not isinstance(self._result, int) and
not isinstance(self._result, float) and
not isinstance(self._result, str) and
not isinstance(self._result, set) and
not isinstance(self._result, tuple) and
not isinstance(self._result, types.GeneratorType)):
return meta.obj_to_dict(self._result, request_id=self._request_id)
else:
return self._result
def test_list_volumes_creating_invalidates(self, cinder_mock):
mock_volume = mock.MagicMock()
mock_volume.id = 'volume1'
mock_volume.status = 'creating'
mock_volume.display_name = 'Volume 1 Display Name'
mock_volume_dict = meta.obj_to_dict(mock_volume)
cinder_mock.volumes.list.return_value = [mock_volume]
self.assertEqual([mock_volume_dict], self.cloud.list_volumes())
mock_volume2 = mock.MagicMock()
mock_volume2.id = 'volume2'
mock_volume2.status = 'available'
mock_volume2.display_name = 'Volume 2 Display Name'
mock_volume2_dict = meta.obj_to_dict(mock_volume2)
cinder_mock.volumes.list.return_value = [mock_volume, mock_volume2]
self.assertEqual([mock_volume_dict, mock_volume2_dict],
self.cloud.list_volumes())
def test_get_server_external_ipv4_neutron_accessIPv4(self):
srv = meta.obj_to_dict(fakes.FakeServer(
id='test-id', name='test-name', status='ACTIVE',
accessIPv4=PUBLIC_V4))
ip = meta.get_server_external_ipv4(
cloud=shade.openstack_cloud(validate=False), server=srv)
self.assertEqual(PUBLIC_V4, ip)
def test_az(self):
server = FakeServer()
server.__dict__['OS-EXT-AZ:availability_zone'] = 'az1'
hostvars = _utils.normalize_server(
meta.obj_to_dict(server),
cloud_name='', region_name='')
self.assertEquals('az1', hostvars['az'])
def test_image_string(self, mock_get_server_external_ipv4):
mock_get_server_external_ipv4.return_value = PUBLIC_V4
server = standard_fake_server
server.image = 'fake-image-id'
hostvars = meta.get_hostvars_from_server(
FakeCloud(), meta.obj_to_dict(server))
self.assertEquals('fake-image-id', hostvars['image']['id'])
def test_list_flavors(self, nova_mock):
nova_mock.flavors.list.return_value = []
self.assertEqual([], self.cloud.list_flavors())
fake_flavor = fakes.FakeFlavor('555', 'vanilla')
fake_flavor_dict = meta.obj_to_dict(fake_flavor)
nova_mock.flavors.list.return_value = [fake_flavor]
self.cloud.list_flavors.invalidate(self.cloud)
self.assertEqual([fake_flavor_dict], self.cloud.list_flavors())
def test_list_images(self, glance_mock):
glance_mock.images.list.return_value = []
self.assertEqual([], self.cloud.list_images())
fake_image = fakes.FakeImage('22', '22 name', 'success')
fake_image_dict = meta.obj_to_dict(fake_image)
glance_mock.images.list.return_value = [fake_image]
self.cloud.list_images.invalidate(self.cloud)
self.assertEqual([fake_image_dict], self.cloud.list_images())
def test_add_ips_to_server_auto_ip(self, mock_add_auto_ip, mock_nova_client):
server = FakeServer(id="server-id", name="test-server", status="ACTIVE", addresses={})
server_dict = meta.obj_to_dict(server)
mock_nova_client.servers.get.return_value = server
self.client.add_ips_to_server(server_dict)
mock_add_auto_ip.assert_called_with(server_dict, wait=False, timeout=60, reuse=True)
def test_delete_role(self, mock_keystone, mock_get):
role_obj = fakes.FakeRole(id='1234', name='aaa')
mock_get.return_value = meta.obj_to_dict(role_obj)
self.assertTrue(self.cloud.delete_role('1234'))
self.assertTrue(mock_keystone.roles.delete.called)
def test_get_server_cloud_missing_fips(self, mock_get_flavor_name,
mock_get_image_name,
mock_get_volumes, mock_has_service):
mock_get_image_name.return_value = 'cirros-0.3.4-x86_64-uec'
mock_get_flavor_name.return_value = 'm1.tiny'
mock_get_volumes.return_value = []
mock_has_service.return_value = True
self.register_uris([
dict(method='GET',
uri=('https://network.example.com/v2.0/ports.json?'
'device_id=test-id'),
json={
'ports': [{
'id': 'test_port_id',
'mac_address': 'fa:16:3e:ae:7d:42',
'device_id': 'test-id'
}]
}),
dict(method='GET',
uri=('https://network.example.com/v2.0/floatingips.json'
'?port_id=test_port_id'),
json={
'floatingips': [{
'id': 'floating-ip-id',
'port_id': 'test_port_id',
'fixed_ip_address': PRIVATE_V4,
'floating_ip_address': PUBLIC_V4,
}]
}),
dict(method='GET',
uri='https://network.example.com/v2.0/networks.json',
json={
'networks': [{
'id': 'test_pnztt_net',
'name': 'test_pnztt_net',
'router:external': False,
}, {
'id': 'private',
'name': 'private',
}]
}),
dict(method='GET',
uri='https://network.example.com/v2.0/subnets.json',
json={'subnets': SUBNETS_WITH_NAT}),
dict(method='GET',
uri='{endpoint}/servers/test-id/os-security-groups'.format(
endpoint=fakes.COMPUTE_ENDPOINT),
json={'security_groups': []})
])
srv = self.cloud.get_openstack_vars(
meta.obj_to_dict(
fakes.FakeServer(id='test-id',
name='test-name',
status='ACTIVE',
flavor={u'id': u'1'},
image={
'name': u'cirros-0.3.4-x86_64-uec',
u'id':
u'f93d000b-7c29-4489-b375-3641a1758fe1'
},
addresses={
u'test_pnztt_net': [{
u'addr':
PRIVATE_V4,
u'version':
4,
'OS-EXT-IPS-MAC:mac_addr':
'fa:16:3e:ae:7d:42',
}]
})))
self.assertEqual(PUBLIC_V4, srv['public_v4'])
self.assert_calls()
def test_list_machines(self, mock_client):
m1 = fakes.FakeMachine(1, 'fake_machine1')
mock_client.node.list.return_value = [m1]
machines = self.cloud.list_machines()
self.assertTrue(mock_client.node.list.called)
self.assertEqual(meta.obj_to_dict(m1), machines[0])
def test_has_no_volume_service(self):
fake_cloud = FakeCloud()
fake_cloud.service_val = False
hostvars = meta.get_hostvars_from_server(
fake_cloud, meta.obj_to_dict(standard_fake_server))
self.assertEquals([], hostvars['volumes'])
def test_get_server_ip(self):
srv = meta.obj_to_dict(standard_fake_server)
self.assertEqual(PRIVATE_V4, meta.get_server_ip(srv, ext_tag='fixed'))
self.assertEqual(PUBLIC_V4, meta.get_server_ip(srv,
ext_tag='floating'))
def test_create_image_task(self, swift_service_mock, swift_mock,
glance_mock, get_file_hashes, mock_api_version):
mock_api_version.return_value = '2'
self.cloud.image_api_use_tasks = True
class Container(object):
name = 'image_upload_v2_test_container'
fake_container = Container()
swift_mock.get_capabilities.return_value = {
'swift': {
'max_file_size': 1000
}
}
swift_mock.put_container.return_value = fake_container
swift_mock.head_object.return_value = {}
glance_mock.images.list.return_value = []
self.assertEqual([], self.cloud.list_images())
fake_md5 = "fake-md5"
fake_sha256 = "fake-sha256"
get_file_hashes.return_value = (fake_md5, fake_sha256)
# V2's warlock objects just work like dicts
class FakeImage(dict):
status = 'CREATED'
id = '99'
name = '99 name'
fake_image = FakeImage()
fake_image.update({
'id': '99',
'name': '99 name',
shade.IMAGE_MD5_KEY: fake_md5,
shade.IMAGE_SHA256_KEY: fake_sha256,
})
glance_mock.images.list.return_value = [fake_image]
class FakeTask(dict):
status = 'success'
result = {'image_id': '99'}
fake_task = FakeTask()
fake_task.update({
'id': '100',
'status': 'success',
})
glance_mock.tasks.get.return_value = fake_task
self._call_create_image(name='99 name',
container='image_upload_v2_test_container')
args = {
'header': [
'x-object-meta-x-shade-md5:fake-md5',
'x-object-meta-x-shade-sha256:fake-sha256'
],
'segment_size':
1000
}
swift_service_mock.upload.assert_called_with(
container='image_upload_v2_test_container',
objects=mock.ANY,
options=args)
glance_mock.tasks.create.assert_called_with(
type='import',
input={
'import_from': 'image_upload_v2_test_container/99 name',
'image_properties': {
'name': '99 name'
}
})
args = {
'owner_specified.shade.md5': fake_md5,
'owner_specified.shade.sha256': fake_sha256,
'image_id': '99'
}
glance_mock.images.update.assert_called_with(**args)
fake_image_dict = meta.obj_to_dict(fake_image)
self.assertEqual([fake_image_dict], self.cloud.list_images())
def test_get_server_ip(self):
srv = meta.obj_to_dict(FakeServer())
self.assertEqual(PRIVATE_V4,
meta.get_server_private_ip(srv, self.cloud))
self.assertEqual(PUBLIC_V4,
meta.get_server_external_ipv4(self.cloud, srv))
nova_grp_obj = fakes.FakeSecgroup(id='2',
name='nova-sec-group',
description='Test Nova security group #1',
rules=[
dict(id='2',
from_port=8000,
to_port=8001,
ip_protocol='tcp',
ip_range=dict(cidr='0.0.0.0/0'),
parent_group_id=None)
])
# Neutron returns dicts instead of objects, so the dict versions should
# be used as expected return values from neutron API methods.
neutron_grp_dict = meta.obj_to_dict(neutron_grp_obj)
nova_grp_dict = meta.obj_to_dict(nova_grp_obj)
class TestSecurityGroups(base.TestCase):
def setUp(self):
super(TestSecurityGroups, self).setUp()
self.has_neutron = True
def fake_has_service(*args, **kwargs):
return self.has_neutron
self.cloud.has_service = fake_has_service
@mock.patch.object(shade.OpenStackCloud, 'neutron_client')
@mock.patch.object(shade.OpenStackCloud, 'nova_client')
def setUp(self):
super(TestRoleAssignment, self).setUp()
self.fake_role = obj_to_dict(fakes.FakeRole('12345', 'test'))
self.fake_user = obj_to_dict(
fakes.FakeUser('12345',
'*****@*****.**',
'test',
domain_id='test-domain'))
self.fake_group = obj_to_dict(
fakes.FakeGroup('12345',
'test',
'test group',
domain_id='test-domain'))
self.fake_project = obj_to_dict(
fakes.FakeProject('12345', domain_id='test-domain'))
self.fake_domain = obj_to_dict(
fakes.FakeDomain('test-domain',
'test',
'test domain',
enabled=True))
self.user_project_assignment = obj_to_dict({
'role': {
'id': self.fake_role['id']
},
'scope': {
'project': {
'id': self.fake_project['id']
}
},
'user': {
'id': self.fake_user['id']
}
})
self.group_project_assignment = obj_to_dict({
'role': {
'id': self.fake_role['id']
},
'scope': {
'project': {
'id': self.fake_project['id']
}
},
'group': {
'id': self.fake_group['id']
}
})
self.user_domain_assignment = obj_to_dict({
'role': {
'id': self.fake_role['id']
},
'scope': {
'domain': {
'id': self.fake_domain['id']
}
},
'user': {
'id': self.fake_user['id']
}
})
self.group_domain_assignment = obj_to_dict({
'role': {
'id': self.fake_role['id']
},
'scope': {
'domain': {
'id': self.fake_domain['id']
}
},
'group': {
'id': self.fake_group['id']
}
})
def test_az(self):
server = standard_fake_server
server.__dict__['OS-EXT-AZ:availability_zone'] = 'az1'
hostvars = self.cloud._normalize_server(meta.obj_to_dict(server))
self.assertEqual('az1', hostvars['az'])
def test_create_image_task(self, swift_service_mock, swift_mock,
glance_mock, get_file_hashes, mock_api_version):
mock_api_version.return_value = '2'
self.cloud.image_api_use_tasks = True
class Container(object):
name = 'image_upload_v2_test_container'
fake_container = Container()
swift_mock.get_capabilities.return_value = {
'swift': {
'max_file_size': 1000
}
}
swift_mock.put_container.return_value = fake_container
swift_mock.head_object.return_value = {}
glance_mock.images.list.return_value = []
self.assertEqual([], self.cloud.list_images())
fake_md5 = "fake-md5"
fake_sha256 = "fake-sha256"
get_file_hashes.return_value = (fake_md5, fake_sha256)
FakeImage = warlock.model_factory(shell.get_image_schema())
fake_image = FakeImage(id='a35e8afc-cae9-4e38-8441-2cd465f79f7b',
name='name-99',
status='active',
visibility='private')
glance_mock.images.list.return_value = [fake_image]
FakeTask = warlock.model_factory(_TASK_SCHEMA)
args = {
'id': '21FBD9A7-85EC-4E07-9D58-72F1ACF7CB1F',
'status': 'success',
'type': 'import',
'result': {
'image_id': 'a35e8afc-cae9-4e38-8441-2cd465f79f7b',
},
}
fake_task = FakeTask(**args)
glance_mock.tasks.get.return_value = fake_task
self._call_create_image(name='name-99',
container='image_upload_v2_test_container')
args = {
'header': [
'x-object-meta-x-shade-md5:fake-md5',
'x-object-meta-x-shade-sha256:fake-sha256'
],
'segment_size':
1000,
'use_slo':
True
}
swift_service_mock.upload.assert_called_with(
container='image_upload_v2_test_container',
objects=mock.ANY,
options=args)
glance_mock.tasks.create.assert_called_with(
type='import',
input={
'import_from': 'image_upload_v2_test_container/name-99',
'image_properties': {
'name': 'name-99'
}
})
object_path = 'image_upload_v2_test_container/name-99'
args = {
'owner_specified.shade.md5': fake_md5,
'owner_specified.shade.sha256': fake_sha256,
'owner_specified.shade.object': object_path,
'image_id': 'a35e8afc-cae9-4e38-8441-2cd465f79f7b'
}
glance_mock.images.update.assert_called_with(**args)
fake_image_dict = meta.obj_to_dict(fake_image)
self.assertEqual([fake_image_dict], self.cloud.list_images())
def _image_dict(self, fake_image):
return self.cloud._normalize_image(meta.obj_to_dict(fake_image))
def test_get_server_ip(self):
srv = meta.obj_to_dict(FakeServer())
cloud = shade.openstack_cloud(validate=False)
self.assertEqual(PRIVATE_V4, meta.get_server_private_ip(srv, cloud))
self.assertEqual(PUBLIC_V4, meta.get_server_external_ipv4(cloud, srv))
def test_create_volume_invalidates(self):
fake_volb4 = meta.obj_to_dict(
fakes.FakeVolume('volume1', 'available', ''))
_id = '12345'
fake_vol_creating = meta.obj_to_dict(
fakes.FakeVolume(_id, 'creating', ''))
fake_vol_avail = meta.obj_to_dict(
fakes.FakeVolume(_id, 'available', ''))
def now_deleting(request, context):
fake_vol_avail['status'] = 'deleting'
self.register_uris([
dict(method='GET',
uri=self.get_mock_url('volumev2',
'public',
append=['volumes', 'detail']),
json={'volumes': [fake_volb4]}),
dict(method='POST',
uri=self.get_mock_url('volumev2',
'public',
append=['volumes']),
json={'volume': fake_vol_creating}),
dict(method='GET',
uri=self.get_mock_url('volumev2',
'public',
append=['volumes', 'detail']),
json={'volumes': [fake_volb4, fake_vol_creating]}),
dict(method='GET',
uri=self.get_mock_url('volumev2',
'public',
append=['volumes', 'detail']),
json={'volumes': [fake_volb4, fake_vol_avail]}),
dict(method='GET',
uri=self.get_mock_url('volumev2',
'public',
append=['volumes', 'detail']),
json={'volumes': [fake_volb4, fake_vol_avail]}),
dict(method='DELETE',
uri=self.get_mock_url('volumev2',
'public',
append=['volumes', _id]),
json=now_deleting),
dict(method='GET',
uri=self.get_mock_url('volumev2',
'public',
append=['volumes', 'detail']),
json={'volumes': [fake_volb4]})
])
self.assertEqual([self.cloud._normalize_volume(fake_volb4)],
self.cloud.list_volumes())
volume = dict(display_name='junk_vol',
size=1,
display_description='test junk volume')
self.cloud.create_volume(wait=True, timeout=None, **volume)
# If cache was not invalidated, we would not see our own volume here
# because the first volume was available and thus would already be
# cached.
self.assertEqual([
self.cloud._normalize_volume(fake_volb4),
self.cloud._normalize_volume(fake_vol_avail)
], self.cloud.list_volumes())
self.cloud.delete_volume(_id)
# And now delete and check same thing since list is cached as all
# available
self.assertEqual([self.cloud._normalize_volume(fake_volb4)],
self.cloud.list_volumes())
self.assert_calls()
