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()