class TestFloatingIPPool(base.TestCase): mock_pools = [ {'id': 'pool1_id', 'name': 'pool1'}, {'id': 'pool2_id', 'name': 'pool2'}] def setUp(self): super(TestFloatingIPPool, self).setUp() self.client = OpenStackCloud('cloud', {}) @patch.object(OpenStackCloud, '_has_nova_extension') @patch.object(OpenStackCloud, 'nova_client') def test_list_floating_ip_pools( self, mock_nova_client, mock__has_nova_extension): mock_nova_client.floating_ip_pools.list.return_value = [ FakeFloatingIPPool(**p) for p in self.mock_pools ] mock__has_nova_extension.return_value = True floating_ip_pools = self.client.list_floating_ip_pools() self.assertItemsEqual(floating_ip_pools, self.mock_pools) @patch.object(OpenStackCloud, '_has_nova_extension') @patch.object(OpenStackCloud, 'nova_client') def test_list_floating_ip_pools_exception( self, mock_nova_client, mock__has_nova_extension): mock_nova_client.floating_ip_pools.list.side_effect = \ Exception('whatever') mock__has_nova_extension.return_value = True self.assertRaises( OpenStackCloudException, self.client.list_floating_ip_pools)
class TestFloatingIPPool(base.TestCase): mock_pools = [{"id": "pool1_id", "name": "pool1"}, {"id": "pool2_id", "name": "pool2"}] def setUp(self): super(TestFloatingIPPool, self).setUp() config = os_client_config.OpenStackConfig() self.client = OpenStackCloud(cloud_config=config.get_one_cloud()) @patch.object(OpenStackCloud, "_has_nova_extension") @patch.object(OpenStackCloud, "nova_client") def test_list_floating_ip_pools(self, mock_nova_client, mock__has_nova_extension): mock_nova_client.floating_ip_pools.list.return_value = [FakeFloatingIPPool(**p) for p in self.mock_pools] mock__has_nova_extension.return_value = True floating_ip_pools = self.client.list_floating_ip_pools() self.assertItemsEqual(floating_ip_pools, self.mock_pools) @patch.object(OpenStackCloud, "_has_nova_extension") @patch.object(OpenStackCloud, "nova_client") def test_list_floating_ip_pools_exception(self, mock_nova_client, mock__has_nova_extension): mock_nova_client.floating_ip_pools.list.side_effect = Exception("whatever") mock__has_nova_extension.return_value = True self.assertRaises(OpenStackCloudException, self.client.list_floating_ip_pools)
class TestShade(base.TestCase): def setUp(self): super(TestShade, self).setUp() self.cloud = OpenStackCloud("cloud", {}) @mock.patch.object(swift_client, "Connection") @mock.patch.object(shade.OpenStackCloud, "auth_token", new_callable=mock.PropertyMock) @mock.patch.object(shade.OpenStackCloud, "get_session_endpoint") def test_swift_client(self, endpoint_mock, auth_mock, swift_mock): endpoint_mock.return_value = "danzig" auth_mock.return_value = "yankee" self.cloud.swift_client swift_mock.assert_called_with( preauthurl="danzig", preauthtoken="yankee", auth_version="2", os_options=dict(object_storage_url="danzig", auth_token="yankee", region_name=""), ) @mock.patch.object(shade.OpenStackCloud, "auth_token", new_callable=mock.PropertyMock) @mock.patch.object(shade.OpenStackCloud, "get_session_endpoint") def test_swift_client_no_endpoint(self, endpoint_mock, auth_mock): endpoint_mock.side_effect = KeyError auth_mock.return_value = "quebec" e = self.assertRaises(exc.OpenStackCloudException, lambda: self.cloud.swift_client) self.assertIn("Error constructing swift client", str(e)) @mock.patch.object(shade.OpenStackCloud, "auth_token") @mock.patch.object(shade.OpenStackCloud, "get_session_endpoint") def test_swift_service(self, endpoint_mock, auth_mock): endpoint_mock.return_value = "slayer" auth_mock.return_value = "zulu" self.assertIsInstance(self.cloud.swift_service, swift_service.SwiftService) endpoint_mock.assert_called_with(service_key="object-store") @mock.patch.object(shade.OpenStackCloud, "get_session_endpoint") def test_swift_service_no_endpoint(self, endpoint_mock): endpoint_mock.side_effect = KeyError e = self.assertRaises(exc.OpenStackCloudException, lambda: self.cloud.swift_service) self.assertIn("Error constructing swift client", str(e)) @mock.patch.object(shade.OpenStackCloud, "swift_client") def test_get_object_segment_size(self, swift_mock): swift_mock.get_capabilities.return_value = {"swift": {"max_file_size": 1000}} self.assertEqual(900, self.cloud.get_object_segment_size(900)) self.assertEqual(1000, self.cloud.get_object_segment_size(1000)) self.assertEqual(1000, self.cloud.get_object_segment_size(1100))
class TestDeleteServer(base.TestCase): def setUp(self): super(TestDeleteServer, self).setUp() self.cloud = OpenStackCloud("cloud", {}) @mock.patch('shade.OpenStackCloud.nova_client') def test_delete_server(self, nova_mock): """ Test that novaclient server delete is called when wait=False """ server = mock.MagicMock(id='1234', status='ACTIVE') server.name = 'daffy' nova_mock.servers.list.return_value = [server] self.cloud.delete_server('daffy', wait=False) nova_mock.servers.delete.assert_called_with(server=server) @mock.patch('shade.OpenStackCloud.nova_client') def test_delete_server_already_gone(self, nova_mock): """ Test that we return immediately when server is already gone """ nova_mock.servers.list.return_value = [] self.cloud.delete_server('tweety', wait=False) self.assertFalse(nova_mock.servers.delete.called) @mock.patch('shade.OpenStackCloud.nova_client') def test_delete_server_already_gone_wait(self, nova_mock): self.cloud.delete_server('speedy', wait=True) self.assertFalse(nova_mock.servers.delete.called) @mock.patch('shade.OpenStackCloud.nova_client') def test_delete_server_wait_for_notfound(self, nova_mock): """ Test that delete_server waits for NotFound from novaclient """ server = mock.MagicMock(id='9999', status='ACTIVE') server.name = 'wily' nova_mock.servers.list.return_value = [server] def _delete_wily(*args, **kwargs): self.assertIn('server', kwargs) self.assertEqual('9999', kwargs['server'].id) nova_mock.servers.list.return_value = [] def _raise_notfound(*args, **kwargs): self.assertIn('server', kwargs) self.assertEqual('9999', kwargs['server'].id) raise nova_exc.NotFound(code='404') nova_mock.servers.get.side_effect = _raise_notfound nova_mock.servers.delete.side_effect = _delete_wily self.cloud.delete_server('wily', wait=True) nova_mock.servers.delete.assert_called_with(server=server)
def setUp(self): super(TestFloatingIP, self).setUp() # floating_ip_source='neutron' is default for OpenStackCloud() config = os_client_config.OpenStackConfig() self.client = OpenStackCloud( cloud_config=config.get_one_cloud(validate=False)) self.fake_server = meta.obj_to_dict( fakes.FakeServer( 'server-id', '', 'ACTIVE', addresses={u'test_pnztt_net': [{ u'OS-EXT-IPS:type': u'fixed', u'addr': '192.0.2.129', u'version': 4, u'OS-EXT-IPS-MAC:mac_addr': u'fa:16:3e:ae:7d:42'}]})) self.floating_ip = _utils.normalize_neutron_floating_ips( self.mock_floating_ip_list_rep['floatingips'])[0]
def setUp(self): super(TestObject, self).setUp() config = os_client_config.OpenStackConfig() self.cloud = OpenStackCloud( cloud_config=config.get_one_cloud(validate=False))
class TestCreateVolumeSnapshot(base.TestCase): def setUp(self): super(TestCreateVolumeSnapshot, self).setUp() config = os_client_config.OpenStackConfig() self.client = OpenStackCloud(cloud_config=config.get_one_cloud(validate=False)) @patch.object(OpenStackCloud, "cinder_client") 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( _utils.normalize_volumes([meta.obj_to_dict(fake_snapshot)])[0], self.client.create_volume_snapshot(volume_id="1234", wait=True), ) mock_cinder.volume_snapshots.create.assert_called_with(force=False, volume_id="1234") mock_cinder.volume_snapshots.get.assert_called_with(snapshot_id=meta.obj_to_dict(build_snapshot)["id"]) @patch.object(OpenStackCloud, "cinder_client") def test_create_volume_snapshot_with_timeout(self, mock_cinder): """ Test that a timeout while waiting for the volume snapshot to create raises an exception in create_volume_snapshot. """ build_snapshot = fakes.FakeVolumeSnapshot("1234", "creating", "foo", "derpysnapshot") mock_cinder.volume_snapshots.create.return_value = build_snapshot mock_cinder.volume_snapshots.get.return_value = build_snapshot mock_cinder.volume_snapshots.list.return_value = [build_snapshot] self.assertRaises( OpenStackCloudTimeout, self.client.create_volume_snapshot, volume_id="1234", wait=True, timeout=1 ) mock_cinder.volume_snapshots.create.assert_called_with(force=False, volume_id="1234") mock_cinder.volume_snapshots.get.assert_called_with(snapshot_id=meta.obj_to_dict(build_snapshot)["id"]) @patch.object(OpenStackCloud, "cinder_client") 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(force=False, volume_id="1234") mock_cinder.volume_snapshots.get.assert_called_with(snapshot_id=meta.obj_to_dict(build_snapshot)["id"])
class TestFloatingIP(base.TestCase): def setUp(self): super(TestFloatingIP, self).setUp() self.client = OpenStackCloud("cloud", {}) @patch.object(OpenStackCloud, 'get_floating_ip') @patch.object(OpenStackCloud, 'attach_ip_to_server') @patch.object(OpenStackCloud, 'available_floating_ip') def test_add_auto_ip( self, mock_available_floating_ip, mock_attach_ip_to_server, mock_get_floating_ip): server = FakeServer( id='server-id', name='test-server', status="ACTIVE", addresses={} ) server_dict = meta.obj_to_dict(server) mock_available_floating_ip.return_value = { "id": "this-is-a-floating-ip-id", "fixed_ip_address": None, "floating_ip_address": "203.0.113.29", "network": "this-is-a-net-or-pool-id", "attached": False, "status": "ACTIVE" } self.client.add_auto_ip(server=server_dict) mock_attach_ip_to_server.assert_called_with( timeout=60, wait=False, server_id='server-id', floating_ip_id='this-is-a-floating-ip-id') @patch.object(OpenStackCloud, 'nova_client') @patch.object(OpenStackCloud, 'add_ip_from_pool') def test_add_ips_to_server_pool( self, mock_add_ip_from_pool, mock_nova_client): server = FakeServer( id='server-id', name='test-server', status="ACTIVE", addresses={} ) server_dict = meta.obj_to_dict(server) pool = 'nova' mock_nova_client.servers.get.return_value = server self.client.add_ips_to_server(server_dict, ip_pool=pool) mock_add_ip_from_pool.assert_called_with(server_dict, pool) @patch.object(OpenStackCloud, 'nova_client') @patch.object(OpenStackCloud, 'add_ip_list') def test_add_ips_to_server_ip_list( self, mock_add_ip_list, mock_nova_client): server = FakeServer( id='server-id', name='test-server', status="ACTIVE", addresses={} ) server_dict = meta.obj_to_dict(server) ips = ['203.0.113.29', '172.24.4.229'] mock_nova_client.servers.get.return_value = server self.client.add_ips_to_server(server_dict, ips=ips) mock_add_ip_list.assert_called_with(server_dict, ips) @patch.object(OpenStackCloud, 'nova_client') @patch.object(OpenStackCloud, 'add_auto_ip') 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)
class TestObject(base.TestCase): def setUp(self): super(TestObject, self).setUp() config = os_client_config.OpenStackConfig() self.cloud = OpenStackCloud(cloud_config=config.get_one_cloud( validate=False)) @mock.patch.object(swift_client, 'Connection') @mock.patch.object(shade.OpenStackCloud, 'keystone_session', new_callable=mock.PropertyMock) @mock.patch.object(shade.OpenStackCloud, 'get_session_endpoint') def test_swift_client(self, endpoint_mock, session_mock, swift_mock): endpoint_mock.return_value = 'danzig' session = mock.MagicMock() session.get_token = mock.MagicMock() session.get_token.return_value = 'yankee' session_mock.return_value = session self.cloud.swift_client swift_mock.assert_called_with(preauthurl='danzig', preauthtoken='yankee', auth_version=mock.ANY, timeout=None, os_options=dict( object_storage_url='danzig', auth_token='yankee', region_name='')) @mock.patch.object(shade.OpenStackCloud, 'keystone_session', new_callable=mock.PropertyMock) @mock.patch.object(shade.OpenStackCloud, 'get_session_endpoint') def test_swift_client_no_endpoint(self, endpoint_mock, session_mock): endpoint_mock.side_effect = KeyError e = self.assertRaises(exc.OpenStackCloudException, lambda: self.cloud.swift_client) self.assertIn('Error constructing swift client', str(e)) @mock.patch.object(shade.OpenStackCloud, 'auth_token') @mock.patch.object(shade.OpenStackCloud, 'get_session_endpoint') def test_swift_service(self, endpoint_mock, auth_mock): endpoint_mock.return_value = 'slayer' auth_mock.return_value = 'zulu' self.assertIsInstance(self.cloud.swift_service, swift_service.SwiftService) endpoint_mock.assert_called_with(service_key='object-store') @mock.patch.object(shade.OpenStackCloud, 'get_session_endpoint') def test_swift_service_no_endpoint(self, endpoint_mock): endpoint_mock.side_effect = KeyError e = self.assertRaises(exc.OpenStackCloudException, lambda: self.cloud.swift_service) self.assertIn('Error constructing swift client', str(e)) @mock.patch.object(shade.OpenStackCloud, 'swift_client') def test_get_object_segment_size(self, swift_mock): swift_mock.get_capabilities.return_value = { 'swift': { 'max_file_size': 1000 } } self.assertEqual(900, self.cloud.get_object_segment_size(900)) self.assertEqual(1000, self.cloud.get_object_segment_size(1000)) self.assertEqual(1000, self.cloud.get_object_segment_size(1100)) @mock.patch.object(shade.OpenStackCloud, 'swift_client') def test_get_object_segment_size_http_412(self, swift_mock): swift_mock.get_capabilities.side_effect = swift_exc.ClientException( "Precondition failed", http_status=412) self.assertEqual(shade.openstackcloud.DEFAULT_OBJECT_SEGMENT_SIZE, self.cloud.get_object_segment_size(None))
def setUp(self): super(TestFloatingIP, self).setUp() self.client = OpenStackCloud("cloud", {})
def setUp(self): super(TestPort, self).setUp() config = os_client_config.OpenStackConfig() self.client = OpenStackCloud(cloud_config=config.get_one_cloud())
def setUp(self): super(TestPort, self).setUp() self.client = OpenStackCloud('cloud', {})
def setUp(self): super(TestFloatingIP, self).setUp() config = os_client_config.OpenStackConfig() self.client = OpenStackCloud(cloud_config=config.get_one_cloud())
class TestFloatingIP(base.TestCase): mock_floating_ip_list_rep = [ { 'fixed_ip': None, 'id': 1, 'instance_id': None, 'ip': '203.0.113.1', 'pool': 'nova' }, { 'fixed_ip': None, 'id': 2, 'instance_id': None, 'ip': '203.0.113.2', 'pool': 'nova' }, { 'fixed_ip': '192.0.2.3', 'id': 29, 'instance_id': 'myself', 'ip': '198.51.100.29', 'pool': 'black_hole' } ] mock_floating_ip_pools = [ {'id': 'pool1_id', 'name': 'nova'}, {'id': 'pool2_id', 'name': 'pool2'}] def assertAreInstances(self, elements, elem_type): for e in elements: self.assertIsInstance(e, elem_type) def setUp(self): super(TestFloatingIP, self).setUp() self.client = OpenStackCloud("cloud", {}) @patch.object(OpenStackCloud, 'nova_client') @patch.object(OpenStackCloud, 'has_service') def test_list_floating_ips(self, mock_has_service, mock_nova_client): mock_has_service.side_effect = has_service_side_effect mock_nova_client.floating_ips.list.return_value = [ FakeFloatingIP(**ip) for ip in self.mock_floating_ip_list_rep ] floating_ips = self.client.list_floating_ips() mock_nova_client.floating_ips.list.assert_called_with() self.assertIsInstance(floating_ips, list) self.assertEqual(3, len(floating_ips)) self.assertAreInstances(floating_ips, dict) @patch.object(OpenStackCloud, 'nova_client') @patch.object(OpenStackCloud, 'has_service') def test_search_floating_ips(self, mock_has_service, mock_nova_client): mock_has_service.side_effect = has_service_side_effect mock_nova_client.floating_ips.list.return_value = [ FakeFloatingIP(**ip) for ip in self.mock_floating_ip_list_rep ] floating_ips = self.client.search_floating_ips( filters={'attached': False}) mock_nova_client.floating_ips.list.assert_called_with() self.assertIsInstance(floating_ips, list) self.assertEqual(2, len(floating_ips)) self.assertAreInstances(floating_ips, dict) @patch.object(OpenStackCloud, 'nova_client') @patch.object(OpenStackCloud, 'has_service') def test_get_floating_ip(self, mock_has_service, mock_nova_client): mock_has_service.side_effect = has_service_side_effect mock_nova_client.floating_ips.list.return_value = [ FakeFloatingIP(**ip) for ip in self.mock_floating_ip_list_rep ] floating_ip = self.client.get_floating_ip(id='29') mock_nova_client.floating_ips.list.assert_called_with() self.assertIsInstance(floating_ip, dict) self.assertEqual('198.51.100.29', floating_ip['floating_ip_address']) @patch.object(OpenStackCloud, 'nova_client') @patch.object(OpenStackCloud, 'has_service') def test_get_floating_ip_not_found( self, mock_has_service, mock_nova_client): mock_has_service.side_effect = has_service_side_effect mock_nova_client.floating_ips.list.return_value = [ FakeFloatingIP(**ip) for ip in self.mock_floating_ip_list_rep ] floating_ip = self.client.get_floating_ip(id='666') self.assertIsNone(floating_ip) @patch.object(OpenStackCloud, 'nova_client') @patch.object(OpenStackCloud, 'has_service') def test_create_floating_ip(self, mock_has_service, mock_nova_client): mock_has_service.side_effect = has_service_side_effect mock_nova_client.floating_ips.create.return_value = FakeFloatingIP( **self.mock_floating_ip_list_rep[1]) self.client.create_floating_ip(network='nova') mock_nova_client.floating_ips.create.assert_called_with(pool='nova') @patch.object(OpenStackCloud, '_nova_list_floating_ips') @patch.object(OpenStackCloud, 'has_service') def test_available_floating_ip_existing( self, mock_has_service, mock__nova_list_floating_ips): mock_has_service.side_effect = has_service_side_effect mock__nova_list_floating_ips.return_value = \ self.mock_floating_ip_list_rep[:1] ip = self.client.available_floating_ip(network='nova') self.assertEqual(self.mock_floating_ip_list_rep[0]['ip'], ip['floating_ip_address']) @patch.object(OpenStackCloud, 'nova_client') @patch.object(OpenStackCloud, '_nova_list_floating_ips') @patch.object(OpenStackCloud, 'has_service') def test_available_floating_ip_new( self, mock_has_service, mock__nova_list_floating_ips, mock_nova_client): mock_has_service.side_effect = has_service_side_effect mock__nova_list_floating_ips.return_value = [] mock_nova_client.floating_ips.create.return_value = \ FakeFloatingIP(**self.mock_floating_ip_list_rep[0]) ip = self.client.available_floating_ip(network='nova') self.assertEqual(self.mock_floating_ip_list_rep[0]['ip'], ip['floating_ip_address']) @patch.object(OpenStackCloud, 'nova_client') @patch.object(OpenStackCloud, 'has_service') def test_delete_floating_ip_existing( self, mock_has_service, mock_nova_client): mock_has_service.side_effect = has_service_side_effect mock_nova_client.floating_ips.delete.return_value = None ret = self.client.delete_floating_ip( floating_ip_id='a-wild-id-appears') mock_nova_client.floating_ips.delete.assert_called_with( floating_ip='a-wild-id-appears') self.assertTrue(ret) @patch.object(OpenStackCloud, 'nova_client') @patch.object(OpenStackCloud, 'has_service') def test_delete_floating_ip_not_found( self, mock_has_service, mock_nova_client): mock_has_service.side_effect = has_service_side_effect mock_nova_client.floating_ips.delete.side_effect = n_exc.NotFound( code=404) ret = self.client.delete_floating_ip( floating_ip_id='a-wild-id-appears') self.assertFalse(ret) @patch.object(OpenStackCloud, 'nova_client') @patch.object(OpenStackCloud, 'has_service') def test_attach_ip_to_server(self, mock_has_service, mock_nova_client): mock_has_service.side_effect = has_service_side_effect mock_nova_client.floating_ips.list.return_value = [ FakeFloatingIP(**ip) for ip in self.mock_floating_ip_list_rep ] self.client.attach_ip_to_server( server_id='server-id', floating_ip_id=1, fixed_address='192.0.2.129') mock_nova_client.servers.add_floating_ip.assert_called_with( server='server-id', address='203.0.113.1', fixed_address='192.0.2.129') @patch.object(OpenStackCloud, 'nova_client') @patch.object(OpenStackCloud, 'has_service') def test_detach_ip_from_server(self, mock_has_service, mock_nova_client): mock_has_service.side_effect = has_service_side_effect mock_nova_client.floating_ips.list.return_value = [ FakeFloatingIP(**ip) for ip in self.mock_floating_ip_list_rep ] self.client.detach_ip_from_server( server_id='server-id', floating_ip_id=1) mock_nova_client.servers.remove_floating_ip.assert_called_with( server='server-id', address='203.0.113.1') @patch.object(OpenStackCloud, 'nova_client') @patch.object(OpenStackCloud, 'has_service') def test_add_ip_from_pool(self, mock_has_service, mock_nova_client): mock_has_service.side_effect = has_service_side_effect mock_nova_client.floating_ips.list.return_value = [ FakeFloatingIP(**ip) for ip in self.mock_floating_ip_list_rep ] ip = self.client.add_ip_from_pool( server_id='server-id', network='nova', fixed_address='192.0.2.129') self.assertEqual('203.0.113.1', ip['floating_ip_address'])
class TestCreateServer(base.TestCase): def setUp(self): super(TestCreateServer, self).setUp() config = os_client_config.OpenStackConfig() self.client = OpenStackCloud( cloud_config=config.get_one_cloud(validate=False)) self.client._SERVER_AGE = 0 def test_create_server_with_create_exception(self): """ Test that an exception in the novaclient create raises an exception in create_server. """ with patch("shade.OpenStackCloud"): config = { "servers.create.side_effect": Exception("exception"), } OpenStackCloud.nova_client = Mock(**config) self.assertRaises( OpenStackCloudException, self.client.create_server, 'server-name', 'image-id', 'flavor-id') def test_create_server_with_get_exception(self): """ Test that an exception when attempting to get the server instance via the novaclient raises an exception in create_server. """ with patch("shade.OpenStackCloud"): config = { "servers.create.return_value": Mock(status="BUILD"), "servers.get.side_effect": Exception("exception") } OpenStackCloud.nova_client = Mock(**config) self.assertRaises( OpenStackCloudException, self.client.create_server, 'server-name', 'image-id', 'flavor-id') def test_create_server_with_server_error(self): """ Test that a server error before we return or begin waiting for the server instance spawn raises an exception in create_server. """ build_server = fakes.FakeServer('1234', '', 'BUILD') error_server = fakes.FakeServer('1234', '', 'ERROR') with patch("shade.OpenStackCloud"): config = { "servers.create.return_value": build_server, "servers.get.return_value": error_server, } OpenStackCloud.nova_client = Mock(**config) self.assertRaises( OpenStackCloudException, self.client.create_server, 'server-name', 'image-id', 'flavor-id') def test_create_server_wait_server_error(self): """ Test that a server error while waiting for the server to spawn raises an exception in create_server. """ with patch("shade.OpenStackCloud"): build_server = fakes.FakeServer('1234', '', 'BUILD') error_server = fakes.FakeServer('1234', '', 'ERROR') config = { "servers.create.return_value": build_server, "servers.get.return_value": build_server, "servers.list.side_effect": [ [build_server], [error_server]] } OpenStackCloud.nova_client = Mock(**config) self.assertRaises( OpenStackCloudException, self.client.create_server, 'server-name', 'image-id', 'flavor-id', wait=True) def test_create_server_with_timeout(self): """ Test that a timeout while waiting for the server to spawn raises an exception in create_server. """ with patch("shade.OpenStackCloud"): fake_server = fakes.FakeServer('1234', '', 'BUILD') config = { "servers.create.return_value": fake_server, "servers.get.return_value": fake_server, "servers.list.return_value": [fake_server], } OpenStackCloud.nova_client = Mock(**config) self.assertRaises( OpenStackCloudTimeout, self.client.create_server, 'server-name', 'image-id', 'flavor-id', wait=True, timeout=1) def test_create_server_no_wait(self): """ Test that create_server with no wait and no exception in the novaclient create call returns the server instance. """ with patch("shade.OpenStackCloud"): fake_server = fakes.FakeServer('1234', '', 'BUILD') config = { "servers.create.return_value": fake_server, "servers.get.return_value": fake_server } OpenStackCloud.nova_client = Mock(**config) self.assertEqual( _utils.normalize_server( meta.obj_to_dict(fake_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')) 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='******') config = { "servers.create.return_value": fake_create_server, "servers.get.return_value": fake_server } 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='******')) @patch.object(OpenStackCloud, "wait_for_server") @patch.object(OpenStackCloud, "nova_client") 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) ) @patch.object(OpenStackCloud, "get_active_server") @patch.object(OpenStackCloud, "get_server") def test_wait_for_server(self, mock_get_server, mock_get_active_server): """ Test that waiting for a server returns the server instance when its status changes to "ACTIVE". """ building_server = {'id': 'fake_server_id', 'status': 'BUILDING'} active_server = {'id': 'fake_server_id', 'status': 'ACTIVE'} mock_get_server.side_effect = iter([building_server, active_server]) mock_get_active_server.side_effect = iter([ building_server, active_server]) server = self.client.wait_for_server(building_server) self.assertEqual(2, mock_get_server.call_count) mock_get_server.assert_has_calls([ mock.call(building_server['id']), mock.call(active_server['id']), ]) self.assertEqual(2, mock_get_active_server.call_count) mock_get_active_server.assert_has_calls([ mock.call(server=building_server, reuse=True, auto_ip=True, ips=None, ip_pool=None, wait=True, timeout=mock.ANY), mock.call(server=active_server, reuse=True, auto_ip=True, ips=None, ip_pool=None, wait=True, timeout=mock.ANY), ]) self.assertEqual('ACTIVE', server['status']) @patch.object(OpenStackCloud, 'wait_for_server') @patch.object(OpenStackCloud, 'nova_client') def test_create_server_wait(self, mock_nova, mock_wait): """ Test that create_server with a wait actually does the wait. """ fake_server = {'id': 'fake_server_id', 'status': 'BUILDING'} mock_nova.servers.create.return_value = fake_server self.client.create_server( 'server-name', 'image-id', 'flavor-id', wait=True), mock_wait.assert_called_once_with( fake_server, auto_ip=True, ips=None, ip_pool=None, reuse=True, timeout=180 ) @patch('time.sleep') def test_create_server_no_addresses(self, mock_sleep): """ Test that create_server with a wait throws an exception if the server doesn't have addresses. """ with patch("shade.OpenStackCloud"): build_server = fakes.FakeServer('1234', '', 'BUILD') fake_server = fakes.FakeServer('1234', '', 'ACTIVE') config = { "servers.create.return_value": build_server, "servers.get.return_value": [build_server, None], "servers.list.side_effect": [ [build_server], [fake_server]], "servers.delete.return_value": None, } OpenStackCloud.nova_client = Mock(**config) self.client._SERVER_AGE = 0 with patch.object(OpenStackCloud, "add_ips_to_server", return_value=fake_server): self.assertRaises( OpenStackCloudException, self.client.create_server, 'server-name', 'image-id', 'flavor-id', wait=True) @patch('shade.OpenStackCloud.nova_client') @patch('shade.OpenStackCloud.get_network') def test_create_server_network_with_no_nics(self, mock_get_network, mock_nova): """ Verify that if 'network' is supplied, and 'nics' is not, that we attempt to get the network for the server. """ self.client.create_server('server-name', 'image-id', 'flavor-id', network='network-name') mock_get_network.assert_called_once_with(name_or_id='network-name') @patch('shade.OpenStackCloud.nova_client') @patch('shade.OpenStackCloud.get_network') def test_create_server_network_with_empty_nics(self, mock_get_network, mock_nova): """ Verify that if 'network' is supplied, along with an empty 'nics' list, it's treated the same as if 'nics' were not included. """ self.client.create_server('server-name', 'image-id', 'flavor-id', network='network-name', nics=[]) mock_get_network.assert_called_once_with(name_or_id='network-name')
class TestRebuildServer(base.TestCase): def setUp(self): super(TestRebuildServer, self).setUp() config = os_client_config.OpenStackConfig() self.client = OpenStackCloud(cloud_config=config.get_one_cloud()) def test_rebuild_server_rebuild_exception(self): """ Test that an exception in the novaclient rebuild raises an exception in rebuild_server. """ with patch("shade.OpenStackCloud"): config = { "servers.rebuild.side_effect": Exception("exception"), } OpenStackCloud.nova_client = Mock(**config) self.assertRaises(OpenStackCloudException, self.client.rebuild_server, "a", "b") def test_rebuild_server_server_error(self): """ Test that a server error while waiting for the server to rebuild raises an exception in rebuild_server. """ with patch("shade.OpenStackCloud"): config = { "servers.rebuild.return_value": Mock(status="REBUILD"), "servers.get.return_value": Mock(status="ERROR") } OpenStackCloud.nova_client = Mock(**config) self.assertRaises(OpenStackCloudException, self.client.rebuild_server, "a", "b", wait=True) def test_rebuild_server_timeout(self): """ Test that a timeout while waiting for the server to rebuild raises an exception in rebuild_server. """ with patch("shade.OpenStackCloud"): config = { "servers.rebuild.return_value": Mock(status="REBUILD"), "servers.get.return_value": Mock(status="REBUILD") } OpenStackCloud.nova_client = Mock(**config) self.assertRaises(OpenStackCloudTimeout, self.client.rebuild_server, "a", "b", wait=True, timeout=0.001) def test_rebuild_server_no_wait(self): """ Test that rebuild_server with no wait and no exception in the novaclient rebuild call returns the server instance. """ with patch("shade.OpenStackCloud"): mock_server = Mock(status="ACTIVE") config = {"servers.rebuild.return_value": mock_server} OpenStackCloud.nova_client = Mock(**config) self.assertEqual(meta.obj_to_dict(mock_server), self.client.rebuild_server("a", "b")) def test_rebuild_server_wait(self): """ Test that rebuild_server with a wait returns the server instance when its status changes to "ACTIVE". """ with patch("shade.OpenStackCloud"): mock_server = Mock(status="ACTIVE") config = { "servers.rebuild.return_value": Mock(status="REBUILD"), "servers.get.return_value": mock_server } OpenStackCloud.nova_client = Mock(**config) self.assertEqual(meta.obj_to_dict(mock_server), self.client.rebuild_server("a", "b", wait=True))
class TestFloatingIP(base.TestCase): mock_floating_ip_list_rep = { 'floatingips': [{ 'router_id': 'd23abc8d-2991-4a55-ba98-2aaea84cc72f', 'tenant_id': '4969c491a3c74ee4af974e6d800c62de', 'floating_network_id': '376da547-b977-4cfe-9cba-275c80debf57', 'fixed_ip_address': '192.0.2.29', 'floating_ip_address': '203.0.113.29', 'port_id': 'ce705c24-c1ef-408a-bda3-7bbd946164ab', 'id': '2f245a7b-796b-4f26-9cf9-9e82d248fda7', 'status': 'ACTIVE' }, { 'router_id': None, 'tenant_id': '4969c491a3c74ee4af974e6d800c62de', 'floating_network_id': '376da547-b977-4cfe-9cba-275c80debf57', 'fixed_ip_address': None, 'floating_ip_address': '203.0.113.30', 'port_id': None, 'id': '61cea855-49cb-4846-997d-801b70c71bdd', 'status': 'DOWN' }] } mock_floating_ip_new_rep = { 'floatingip': { 'fixed_ip_address': '10.0.0.4', 'floating_ip_address': '172.24.4.229', 'floating_network_id': 'my-network-id', 'id': '2f245a7b-796b-4f26-9cf9-9e82d248fda8', 'port_id': None, 'router_id': None, 'status': 'ACTIVE', 'tenant_id': '4969c491a3c74ee4af974e6d800c62df' } } mock_get_network_rep = { 'status': 'ACTIVE', 'subnets': ['54d6f61d-db07-451c-9ab3-b9609b6b6f0b'], 'name': 'my-network', 'provider:physical_network': None, 'admin_state_up': True, 'tenant_id': '4fd44f30292945e481c7b8a0c8908869', 'provider:network_type': 'local', 'router:external': True, 'shared': True, 'id': 'my-network-id', 'provider:segmentation_id': None } mock_search_ports_rep = [{ 'status': 'ACTIVE', 'binding:host_id': 'devstack', 'name': 'first-port', 'allowed_address_pairs': [], 'admin_state_up': True, 'network_id': '70c1db1f-b701-45bd-96e0-a313ee3430b3', 'tenant_id': '', 'extra_dhcp_opts': [], 'binding:vif_details': { 'port_filter': True, 'ovs_hybrid_plug': True }, 'binding:vif_type': 'ovs', 'device_owner': 'compute:None', 'mac_address': 'fa:16:3e:58:42:ed', 'binding:profile': {}, 'binding:vnic_type': 'normal', 'fixed_ips': [{ 'subnet_id': '008ba151-0b8c-4a67-98b5-0d2b87666062', 'ip_address': u'172.24.4.2' }], 'id': 'ce705c24-c1ef-408a-bda3-7bbd946164ac', 'security_groups': [], 'device_id': 'server_id' }] def assertAreInstances(self, elements, elem_type): for e in elements: self.assertIsInstance(e, elem_type) def setUp(self): super(TestFloatingIP, self).setUp() # floating_ip_source='neutron' is default for OpenStackCloud() config = os_client_config.OpenStackConfig() self.client = OpenStackCloud(cloud_config=config.get_one_cloud( validate=False)) self.fake_server = meta.obj_to_dict( fakes.FakeServer('server-id', '', 'ACTIVE', addresses={ u'test_pnztt_net': [{ u'OS-EXT-IPS:type': u'fixed', u'addr': '192.0.2.129', u'version': 4, u'OS-EXT-IPS-MAC:mac_addr': u'fa:16:3e:ae:7d:42' }] })) self.floating_ip = _utils.normalize_neutron_floating_ips( self.mock_floating_ip_list_rep['floatingips'])[0] @patch.object(OpenStackCloud, 'neutron_client') @patch.object(OpenStackCloud, 'has_service') def test_list_floating_ips(self, mock_has_service, mock_neutron_client): mock_has_service.return_value = True mock_neutron_client.list_floatingips.return_value = \ self.mock_floating_ip_list_rep floating_ips = self.client.list_floating_ips() mock_neutron_client.list_floatingips.assert_called_with() self.assertIsInstance(floating_ips, list) self.assertAreInstances(floating_ips, dict) self.assertEqual(2, len(floating_ips)) @patch.object(OpenStackCloud, 'neutron_client') @patch.object(OpenStackCloud, 'has_service') def test_search_floating_ips(self, mock_has_service, mock_neutron_client): mock_has_service.return_value = True mock_neutron_client.list_floatingips.return_value = \ self.mock_floating_ip_list_rep floating_ips = self.client.search_floating_ips( filters={'attached': False}) mock_neutron_client.list_floatingips.assert_called_with() self.assertIsInstance(floating_ips, list) self.assertAreInstances(floating_ips, dict) self.assertEqual(1, len(floating_ips)) @patch.object(OpenStackCloud, 'neutron_client') @patch.object(OpenStackCloud, 'has_service') def test_get_floating_ip(self, mock_has_service, mock_neutron_client): mock_has_service.return_value = True mock_neutron_client.list_floatingips.return_value = \ self.mock_floating_ip_list_rep floating_ip = self.client.get_floating_ip( id='2f245a7b-796b-4f26-9cf9-9e82d248fda7') mock_neutron_client.list_floatingips.assert_called_with() self.assertIsInstance(floating_ip, dict) self.assertEqual('203.0.113.29', floating_ip['floating_ip_address']) @patch.object(OpenStackCloud, 'neutron_client') @patch.object(OpenStackCloud, 'has_service') def test_get_floating_ip_not_found(self, mock_has_service, mock_neutron_client): mock_has_service.return_value = True mock_neutron_client.list_floatingips.return_value = \ self.mock_floating_ip_list_rep floating_ip = self.client.get_floating_ip(id='non-existent') self.assertIsNone(floating_ip) @patch.object(OpenStackCloud, 'neutron_client') @patch.object(OpenStackCloud, 'search_networks') @patch.object(OpenStackCloud, 'has_service') def test_create_floating_ip(self, mock_has_service, mock_search_networks, mock_neutron_client): mock_has_service.return_value = True mock_search_networks.return_value = [self.mock_get_network_rep] mock_neutron_client.create_floatingip.return_value = \ self.mock_floating_ip_new_rep ip = self.client.create_floating_ip(network='my-network') mock_neutron_client.create_floatingip.assert_called_with( body={'floatingip': { 'floating_network_id': 'my-network-id' }}) self.assertEqual( self.mock_floating_ip_new_rep['floatingip']['floating_ip_address'], ip['floating_ip_address']) @patch.object(OpenStackCloud, 'keystone_session') @patch.object(OpenStackCloud, '_neutron_list_floating_ips') @patch.object(OpenStackCloud, 'search_networks') @patch.object(OpenStackCloud, 'has_service') def test_available_floating_ip_existing(self, mock_has_service, mock_search_networks, mock__neutron_list_floating_ips, mock_keystone_session): mock_has_service.return_value = True mock_search_networks.return_value = [self.mock_get_network_rep] mock__neutron_list_floating_ips.return_value = \ [self.mock_floating_ip_new_rep['floatingip']] mock_keystone_session.get_project_id.return_value = \ '4969c491a3c74ee4af974e6d800c62df' ip = self.client.available_floating_ip(network='my-network') self.assertEqual( self.mock_floating_ip_new_rep['floatingip']['floating_ip_address'], ip['floating_ip_address']) @patch.object(OpenStackCloud, 'nova_client') @patch.object(OpenStackCloud, 'keystone_session') @patch.object(OpenStackCloud, '_neutron_create_floating_ip') @patch.object(OpenStackCloud, '_attach_ip_to_server') @patch.object(OpenStackCloud, 'has_service') def test_auto_ip_pool_no_reuse(self, mock_has_service, mock_attach_ip_to_server, mock__neutron_create_floating_ip, mock_keystone_session, mock_nova_client): mock_has_service.return_value = True mock__neutron_create_floating_ip.return_value = \ self.mock_floating_ip_list_rep['floatingips'][0] mock_keystone_session.get_project_id.return_value = \ '4969c491a3c74ee4af974e6d800c62df' self.client.add_ips_to_server(dict(id='1234'), ip_pool='my-network', reuse=False) mock__neutron_create_floating_ip.assert_called_once_with( network_name_or_id='my-network', server=None) mock_attach_ip_to_server.assert_called_once_with( server={'id': '1234'}, fixed_address=None, floating_ip=self.floating_ip) @patch.object(OpenStackCloud, 'keystone_session') @patch.object(OpenStackCloud, '_neutron_create_floating_ip') @patch.object(OpenStackCloud, '_neutron_list_floating_ips') @patch.object(OpenStackCloud, 'search_networks') @patch.object(OpenStackCloud, 'has_service') def test_available_floating_ip_new(self, mock_has_service, mock_search_networks, mock__neutron_list_floating_ips, mock__neutron_create_floating_ip, mock_keystone_session): mock_has_service.return_value = True mock_search_networks.return_value = [self.mock_get_network_rep] mock__neutron_list_floating_ips.return_value = [] mock__neutron_create_floating_ip.return_value = \ self.mock_floating_ip_new_rep['floatingip'] mock_keystone_session.get_project_id.return_value = \ '4969c491a3c74ee4af974e6d800c62df' ip = self.client.available_floating_ip(network='my-network') self.assertEqual( self.mock_floating_ip_new_rep['floatingip']['floating_ip_address'], ip['floating_ip_address']) @patch.object(OpenStackCloud, 'get_floating_ip') @patch.object(OpenStackCloud, 'neutron_client') @patch.object(OpenStackCloud, 'has_service') def test_delete_floating_ip_existing(self, mock_has_service, mock_neutron_client, mock_get_floating_ip): mock_has_service.return_value = True mock_get_floating_ip.return_value = { 'id': '2f245a7b-796b-4f26-9cf9-9e82d248fda7', } mock_neutron_client.delete_floatingip.return_value = None ret = self.client.delete_floating_ip( floating_ip_id='2f245a7b-796b-4f26-9cf9-9e82d248fda7') mock_neutron_client.delete_floatingip.assert_called_with( floatingip='2f245a7b-796b-4f26-9cf9-9e82d248fda7') self.assertTrue(ret) @patch.object(OpenStackCloud, 'neutron_client') @patch.object(OpenStackCloud, 'has_service') def test_delete_floating_ip_not_found(self, mock_has_service, mock_neutron_client): mock_has_service.return_value = True mock_neutron_client.delete_floatingip.side_effect = \ n_exc.NotFound() ret = self.client.delete_floating_ip( floating_ip_id='a-wild-id-appears') self.assertFalse(ret) @patch.object(OpenStackCloud, 'search_ports') @patch.object(OpenStackCloud, 'neutron_client') @patch.object(OpenStackCloud, 'has_service') def test_attach_ip_to_server(self, mock_has_service, mock_neutron_client, mock_search_ports): mock_has_service.return_value = True mock_search_ports.return_value = self.mock_search_ports_rep mock_neutron_client.list_floatingips.return_value = \ self.mock_floating_ip_list_rep self.client._attach_ip_to_server(server=self.fake_server, floating_ip=self.floating_ip) mock_neutron_client.update_floatingip.assert_called_with( floatingip=self.mock_floating_ip_list_rep['floatingips'][0]['id'], body={ 'floatingip': { 'port_id': self.mock_search_ports_rep[0]['id'], 'fixed_ip_address': self.mock_search_ports_rep[0]['fixed_ips'][0]['ip_address'] } }) @patch.object(OpenStackCloud, 'get_floating_ip') @patch.object(OpenStackCloud, 'neutron_client') @patch.object(OpenStackCloud, 'has_service') def test_detach_ip_from_server(self, mock_has_service, mock_neutron_client, mock_get_floating_ip): mock_has_service.return_value = True mock_get_floating_ip.return_value = \ _utils.normalize_neutron_floating_ips( self.mock_floating_ip_list_rep['floatingips'])[0] self.client.detach_ip_from_server( server_id='server-id', floating_ip_id='2f245a7b-796b-4f26-9cf9-9e82d248fda7') mock_neutron_client.update_floatingip.assert_called_with( floatingip='2f245a7b-796b-4f26-9cf9-9e82d248fda7', body={'floatingip': { 'port_id': None }}) @patch.object(OpenStackCloud, '_attach_ip_to_server') @patch.object(OpenStackCloud, 'available_floating_ip') @patch.object(OpenStackCloud, 'has_service') def test_add_ip_from_pool(self, mock_has_service, mock_available_floating_ip, mock_attach_ip_to_server): mock_has_service.return_value = True mock_available_floating_ip.return_value = \ _utils.normalize_neutron_floating_ips([ self.mock_floating_ip_new_rep['floatingip']])[0] mock_attach_ip_to_server.return_value = None ip = self.client._add_ip_from_pool(server=self.fake_server, network='network-name', fixed_address='192.0.2.129') self.assertEqual( self.mock_floating_ip_new_rep['floatingip']['floating_ip_address'], ip['floating_ip_address'])
def setUp(self): super(TestFloatingIP, self).setUp() # floating_ip_source='neutron' is default for OpenStackCloud() config = os_client_config.OpenStackConfig() self.client = OpenStackCloud(cloud_config=config.get_one_cloud())
def setUp(self): super(TestShade, self).setUp() self.cloud = OpenStackCloud('cloud', {})
def setUp(self): super(TestDeleteVolumeSnapshot, self).setUp() config = os_client_config.OpenStackConfig() self.client = OpenStackCloud( cloud_config=config.get_one_cloud(validate=False))
class TestFloatingIP(base.TestCase): mock_floating_ip_list_rep = { 'floatingips': [ { 'router_id': 'd23abc8d-2991-4a55-ba98-2aaea84cc72f', 'tenant_id': '4969c491a3c74ee4af974e6d800c62de', 'floating_network_id': '376da547-b977-4cfe-9cba-275c80debf57', 'fixed_ip_address': '192.0.2.29', 'floating_ip_address': '203.0.113.29', 'port_id': 'ce705c24-c1ef-408a-bda3-7bbd946164ab', 'id': '2f245a7b-796b-4f26-9cf9-9e82d248fda7', 'status': 'ACTIVE' }, { 'router_id': None, 'tenant_id': '4969c491a3c74ee4af974e6d800c62de', 'floating_network_id': '376da547-b977-4cfe-9cba-275c80debf57', 'fixed_ip_address': None, 'floating_ip_address': '203.0.113.30', 'port_id': None, 'id': '61cea855-49cb-4846-997d-801b70c71bdd', 'status': 'DOWN' } ] } mock_floating_ip_new_rep = { 'floatingip': { 'fixed_ip_address': '10.0.0.4', 'floating_ip_address': '172.24.4.229', 'floating_network_id': 'my-network-id', 'id': '2f245a7b-796b-4f26-9cf9-9e82d248fda8', 'port_id': None, 'router_id': None, 'status': 'ACTIVE', 'tenant_id': '4969c491a3c74ee4af974e6d800c62df' } } mock_get_network_rep = { 'status': 'ACTIVE', 'subnets': [ '54d6f61d-db07-451c-9ab3-b9609b6b6f0b' ], 'name': 'my-network', 'provider:physical_network': None, 'admin_state_up': True, 'tenant_id': '4fd44f30292945e481c7b8a0c8908869', 'provider:network_type': 'local', 'router:external': True, 'shared': True, 'id': 'my-network-id', 'provider:segmentation_id': None } mock_search_ports_rep = [ { 'status': 'ACTIVE', 'binding:host_id': 'devstack', 'name': 'first-port', 'allowed_address_pairs': [], 'admin_state_up': True, 'network_id': '70c1db1f-b701-45bd-96e0-a313ee3430b3', 'tenant_id': '', 'extra_dhcp_opts': [], 'binding:vif_details': { 'port_filter': True, 'ovs_hybrid_plug': True }, 'binding:vif_type': 'ovs', 'device_owner': 'compute:None', 'mac_address': 'fa:16:3e:58:42:ed', 'binding:profile': {}, 'binding:vnic_type': 'normal', 'fixed_ips': [ { 'subnet_id': '008ba151-0b8c-4a67-98b5-0d2b87666062', 'ip_address': u'172.24.4.2' } ], 'id': 'ce705c24-c1ef-408a-bda3-7bbd946164ac', 'security_groups': [], 'device_id': 'server_id' } ] def assertAreInstances(self, elements, elem_type): for e in elements: self.assertIsInstance(e, elem_type) def setUp(self): super(TestFloatingIP, self).setUp() # floating_ip_source='neutron' is default for OpenStackCloud() config = os_client_config.OpenStackConfig() self.client = OpenStackCloud( cloud_config=config.get_one_cloud(validate=False)) self.fake_server = meta.obj_to_dict( fakes.FakeServer( 'server-id', '', 'ACTIVE', addresses={u'test_pnztt_net': [{ u'OS-EXT-IPS:type': u'fixed', u'addr': '192.0.2.129', u'version': 4, u'OS-EXT-IPS-MAC:mac_addr': u'fa:16:3e:ae:7d:42'}]})) self.floating_ip = _utils.normalize_neutron_floating_ips( self.mock_floating_ip_list_rep['floatingips'])[0] @patch.object(OpenStackCloud, 'neutron_client') @patch.object(OpenStackCloud, 'has_service') def test_list_floating_ips(self, mock_has_service, mock_neutron_client): mock_has_service.return_value = True mock_neutron_client.list_floatingips.return_value = \ self.mock_floating_ip_list_rep floating_ips = self.client.list_floating_ips() mock_neutron_client.list_floatingips.assert_called_with() self.assertIsInstance(floating_ips, list) self.assertAreInstances(floating_ips, dict) self.assertEqual(2, len(floating_ips)) @patch.object(OpenStackCloud, 'neutron_client') @patch.object(OpenStackCloud, 'has_service') def test_search_floating_ips(self, mock_has_service, mock_neutron_client): mock_has_service.return_value = True mock_neutron_client.list_floatingips.return_value = \ self.mock_floating_ip_list_rep floating_ips = self.client.search_floating_ips( filters={'attached': False}) mock_neutron_client.list_floatingips.assert_called_with() self.assertIsInstance(floating_ips, list) self.assertAreInstances(floating_ips, dict) self.assertEqual(1, len(floating_ips)) @patch.object(OpenStackCloud, 'neutron_client') @patch.object(OpenStackCloud, 'has_service') def test_get_floating_ip(self, mock_has_service, mock_neutron_client): mock_has_service.return_value = True mock_neutron_client.list_floatingips.return_value = \ self.mock_floating_ip_list_rep floating_ip = self.client.get_floating_ip( id='2f245a7b-796b-4f26-9cf9-9e82d248fda7') mock_neutron_client.list_floatingips.assert_called_with() self.assertIsInstance(floating_ip, dict) self.assertEqual('203.0.113.29', floating_ip['floating_ip_address']) @patch.object(OpenStackCloud, 'neutron_client') @patch.object(OpenStackCloud, 'has_service') def test_get_floating_ip_not_found( self, mock_has_service, mock_neutron_client): mock_has_service.return_value = True mock_neutron_client.list_floatingips.return_value = \ self.mock_floating_ip_list_rep floating_ip = self.client.get_floating_ip(id='non-existent') self.assertIsNone(floating_ip) @patch.object(OpenStackCloud, 'neutron_client') @patch.object(OpenStackCloud, 'search_networks') @patch.object(OpenStackCloud, 'has_service') def test_create_floating_ip( self, mock_has_service, mock_search_networks, mock_neutron_client): mock_has_service.return_value = True mock_search_networks.return_value = [self.mock_get_network_rep] mock_neutron_client.create_floatingip.return_value = \ self.mock_floating_ip_new_rep ip = self.client.create_floating_ip(network='my-network') mock_neutron_client.create_floatingip.assert_called_with( body={'floatingip': {'floating_network_id': 'my-network-id'}} ) self.assertEqual( self.mock_floating_ip_new_rep['floatingip']['floating_ip_address'], ip['floating_ip_address']) @patch.object(OpenStackCloud, 'keystone_session') @patch.object(OpenStackCloud, '_neutron_list_floating_ips') @patch.object(OpenStackCloud, 'search_networks') @patch.object(OpenStackCloud, 'has_service') def test_available_floating_ip_existing( self, mock_has_service, mock_search_networks, mock__neutron_list_floating_ips, mock_keystone_session): mock_has_service.return_value = True mock_search_networks.return_value = [self.mock_get_network_rep] mock__neutron_list_floating_ips.return_value = \ [self.mock_floating_ip_new_rep['floatingip']] mock_keystone_session.get_project_id.return_value = \ '4969c491a3c74ee4af974e6d800c62df' ip = self.client.available_floating_ip(network='my-network') self.assertEqual( self.mock_floating_ip_new_rep['floatingip']['floating_ip_address'], ip['floating_ip_address']) @patch.object(OpenStackCloud, 'nova_client') @patch.object(OpenStackCloud, 'keystone_session') @patch.object(OpenStackCloud, '_neutron_create_floating_ip') @patch.object(OpenStackCloud, '_attach_ip_to_server') @patch.object(OpenStackCloud, 'has_service') def test_auto_ip_pool_no_reuse( self, mock_has_service, mock_attach_ip_to_server, mock__neutron_create_floating_ip, mock_keystone_session, mock_nova_client): mock_has_service.return_value = True mock__neutron_create_floating_ip.return_value = \ self.mock_floating_ip_list_rep['floatingips'][0] mock_keystone_session.get_project_id.return_value = \ '4969c491a3c74ee4af974e6d800c62df' self.client.add_ips_to_server( dict(id='1234'), ip_pool='my-network', reuse=False) mock__neutron_create_floating_ip.assert_called_once_with( network_name_or_id='my-network', server=None) mock_attach_ip_to_server.assert_called_once_with( server={'id': '1234'}, fixed_address=None, floating_ip=self.floating_ip, wait=False, timeout=60) @patch.object(OpenStackCloud, 'keystone_session') @patch.object(OpenStackCloud, '_neutron_create_floating_ip') @patch.object(OpenStackCloud, '_neutron_list_floating_ips') @patch.object(OpenStackCloud, 'search_networks') @patch.object(OpenStackCloud, 'has_service') def test_available_floating_ip_new( self, mock_has_service, mock_search_networks, mock__neutron_list_floating_ips, mock__neutron_create_floating_ip, mock_keystone_session): mock_has_service.return_value = True mock_search_networks.return_value = [self.mock_get_network_rep] mock__neutron_list_floating_ips.return_value = [] mock__neutron_create_floating_ip.return_value = \ self.mock_floating_ip_new_rep['floatingip'] mock_keystone_session.get_project_id.return_value = \ '4969c491a3c74ee4af974e6d800c62df' ip = self.client.available_floating_ip(network='my-network') self.assertEqual( self.mock_floating_ip_new_rep['floatingip']['floating_ip_address'], ip['floating_ip_address']) @patch.object(OpenStackCloud, 'get_floating_ip') @patch.object(OpenStackCloud, 'neutron_client') @patch.object(OpenStackCloud, 'has_service') def test_delete_floating_ip_existing( self, mock_has_service, mock_neutron_client, mock_get_floating_ip): mock_has_service.return_value = True mock_get_floating_ip.return_value = { 'id': '2f245a7b-796b-4f26-9cf9-9e82d248fda7', } mock_neutron_client.delete_floatingip.return_value = None ret = self.client.delete_floating_ip( floating_ip_id='2f245a7b-796b-4f26-9cf9-9e82d248fda7') mock_neutron_client.delete_floatingip.assert_called_with( floatingip='2f245a7b-796b-4f26-9cf9-9e82d248fda7' ) self.assertTrue(ret) @patch.object(OpenStackCloud, 'neutron_client') @patch.object(OpenStackCloud, 'has_service') def test_delete_floating_ip_not_found( self, mock_has_service, mock_neutron_client): mock_has_service.return_value = True mock_neutron_client.delete_floatingip.side_effect = \ n_exc.NotFound() ret = self.client.delete_floating_ip( floating_ip_id='a-wild-id-appears') self.assertFalse(ret) @patch.object(OpenStackCloud, 'search_ports') @patch.object(OpenStackCloud, 'neutron_client') @patch.object(OpenStackCloud, 'has_service') def test_attach_ip_to_server( self, mock_has_service, mock_neutron_client, mock_search_ports): mock_has_service.return_value = True mock_search_ports.return_value = self.mock_search_ports_rep mock_neutron_client.list_floatingips.return_value = \ self.mock_floating_ip_list_rep self.client._attach_ip_to_server( server=self.fake_server, floating_ip=self.floating_ip) mock_neutron_client.update_floatingip.assert_called_with( floatingip=self.mock_floating_ip_list_rep['floatingips'][0]['id'], body={ 'floatingip': { 'port_id': self.mock_search_ports_rep[0]['id'], 'fixed_ip_address': self.mock_search_ports_rep[0][ 'fixed_ips'][0]['ip_address'] } } ) @patch.object(OpenStackCloud, 'get_floating_ip') @patch.object(OpenStackCloud, 'neutron_client') @patch.object(OpenStackCloud, 'has_service') def test_detach_ip_from_server( self, mock_has_service, mock_neutron_client, mock_get_floating_ip): mock_has_service.return_value = True mock_get_floating_ip.return_value = \ _utils.normalize_neutron_floating_ips( self.mock_floating_ip_list_rep['floatingips'])[0] self.client.detach_ip_from_server( server_id='server-id', floating_ip_id='2f245a7b-796b-4f26-9cf9-9e82d248fda7') mock_neutron_client.update_floatingip.assert_called_with( floatingip='2f245a7b-796b-4f26-9cf9-9e82d248fda7', body={ 'floatingip': { 'port_id': None } } ) @patch.object(OpenStackCloud, '_attach_ip_to_server') @patch.object(OpenStackCloud, 'available_floating_ip') @patch.object(OpenStackCloud, 'has_service') def test_add_ip_from_pool( self, mock_has_service, mock_available_floating_ip, mock_attach_ip_to_server): mock_has_service.return_value = True mock_available_floating_ip.return_value = \ _utils.normalize_neutron_floating_ips([ self.mock_floating_ip_new_rep['floatingip']])[0] mock_attach_ip_to_server.return_value = self.fake_server server = self.client._add_ip_from_pool( server=self.fake_server, network='network-name', fixed_address='192.0.2.129') self.assertEqual(server, self.fake_server)
class TestCreateVolumeSnapshot(base.TestCase): def setUp(self): super(TestCreateVolumeSnapshot, self).setUp() config = os_client_config.OpenStackConfig() self.client = OpenStackCloud( cloud_config=config.get_one_cloud(validate=False)) @patch.object(OpenStackCloud, 'cinder_client') 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'] ) @patch.object(OpenStackCloud, 'cinder_client') def test_create_volume_snapshot_with_timeout(self, mock_cinder): """ Test that a timeout while waiting for the volume snapshot to create raises an exception in create_volume_snapshot. """ build_snapshot = fakes.FakeVolumeSnapshot('1234', 'creating', 'foo', 'derpysnapshot') mock_cinder.volume_snapshots.create.return_value = build_snapshot mock_cinder.volume_snapshots.get.return_value = build_snapshot mock_cinder.volume_snapshots.list.return_value = [build_snapshot] self.assertRaises( OpenStackCloudTimeout, self.client.create_volume_snapshot, volume_id='1234', wait=True, timeout=1) 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'] ) @patch.object(OpenStackCloud, 'cinder_client') 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'] )
class TestDeleteServer(base.TestCase): novaclient_exceptions = (nova_exc.BadRequest, nova_exc.Unauthorized, nova_exc.Forbidden, nova_exc.MethodNotAllowed, nova_exc.Conflict, nova_exc.OverLimit, nova_exc.RateLimit, nova_exc.HTTPNotImplemented) def setUp(self): super(TestDeleteServer, self).setUp() self.cloud = OpenStackCloud("cloud", {}) @mock.patch('shade.OpenStackCloud.nova_client') def test_delete_server(self, nova_mock): """ Test that novaclient server delete is called when wait=False """ server = fakes.FakeServer('1234', 'daffy', 'ACTIVE') nova_mock.servers.list.return_value = [server] self.cloud.delete_server('daffy', wait=False) nova_mock.servers.delete.assert_called_with(server=server.id) @mock.patch('shade.OpenStackCloud.nova_client') def test_delete_server_already_gone(self, nova_mock): """ Test that we return immediately when server is already gone """ nova_mock.servers.list.return_value = [] self.cloud.delete_server('tweety', wait=False) self.assertFalse(nova_mock.servers.delete.called) @mock.patch('shade.OpenStackCloud.nova_client') def test_delete_server_already_gone_wait(self, nova_mock): self.cloud.delete_server('speedy', wait=True) self.assertFalse(nova_mock.servers.delete.called) @mock.patch('shade.OpenStackCloud.nova_client') def test_delete_server_wait_for_notfound(self, nova_mock): """ Test that delete_server waits for NotFound from novaclient """ server = fakes.FakeServer('9999', 'wily', 'ACTIVE') nova_mock.servers.list.return_value = [server] def _delete_wily(*args, **kwargs): self.assertIn('server', kwargs) self.assertEqual('9999', kwargs['server']) nova_mock.servers.list.return_value = [] def _raise_notfound(*args, **kwargs): self.assertIn('server', kwargs) self.assertEqual('9999', kwargs['server']) raise nova_exc.NotFound(code='404') nova_mock.servers.get.side_effect = _raise_notfound nova_mock.servers.delete.side_effect = _delete_wily self.cloud.delete_server('wily', wait=True) nova_mock.servers.delete.assert_called_with(server=server.id) @mock.patch('shade.OpenStackCloud.nova_client') def test_delete_server_fails(self, nova_mock): """ Test that delete_server wraps novaclient exceptions """ nova_mock.servers.list.return_value = [fakes.FakeServer('1212', 'speedy', 'ACTIVE')] for fail in self.novaclient_exceptions: def _raise_fail(server): raise fail(code=fail.http_status) nova_mock.servers.delete.side_effect = _raise_fail exc = self.assertRaises(shade_exc.OpenStackCloudException, self.cloud.delete_server, 'speedy', wait=False) # Note that message is deprecated from Exception, but not in # the novaclient exceptions. self.assertIn(fail.message, str(exc)) @mock.patch('shade.OpenStackCloud.nova_client') def test_delete_server_get_fails(self, nova_mock): """ Test that delete_server wraps novaclient exceptions on wait fails """ nova_mock.servers.list.return_value = [fakes.FakeServer('2000', 'yosemite', 'ACTIVE')] for fail in self.novaclient_exceptions: def _raise_fail(server): raise fail(code=fail.http_status) nova_mock.servers.get.side_effect = _raise_fail exc = self.assertRaises(shade_exc.OpenStackCloudException, self.cloud.delete_server, 'yosemite', wait=True) # Note that message is deprecated from Exception, but not in # the novaclient exceptions. self.assertIn(fail.message, str(exc))
class TestRebuildServer(base.TestCase): def setUp(self): super(TestRebuildServer, self).setUp() config = os_client_config.OpenStackConfig() self.client = OpenStackCloud(cloud_config=config.get_one_cloud( validate=False)) def test_rebuild_server_rebuild_exception(self): """ Test that an exception in the novaclient rebuild raises an exception in rebuild_server. """ with patch("shade.OpenStackCloud"): config = { "servers.rebuild.side_effect": Exception("exception"), } OpenStackCloud.nova_client = Mock(**config) self.assertRaises(OpenStackCloudException, self.client.rebuild_server, "a", "b") def test_rebuild_server_server_error(self): """ Test that a server error while waiting for the server to rebuild raises an exception in rebuild_server. """ rebuild_server = fakes.FakeServer('1234', '', 'REBUILD') error_server = fakes.FakeServer('1234', '', 'ERROR') with patch("shade.OpenStackCloud"): config = { "servers.rebuild.return_value": rebuild_server, "servers.get.return_value": error_server, } OpenStackCloud.nova_client = Mock(**config) self.assertRaises(OpenStackCloudException, self.client.rebuild_server, "a", "b", wait=True) def test_rebuild_server_timeout(self): """ Test that a timeout while waiting for the server to rebuild raises an exception in rebuild_server. """ rebuild_server = fakes.FakeServer('1234', '', 'REBUILD') with patch("shade.OpenStackCloud"): config = { "servers.rebuild.return_value": rebuild_server, "servers.get.return_value": rebuild_server, } OpenStackCloud.nova_client = Mock(**config) self.assertRaises(OpenStackCloudTimeout, self.client.rebuild_server, "a", "b", wait=True, timeout=0.001) def test_rebuild_server_no_wait(self): """ Test that rebuild_server with no wait and no exception in the novaclient rebuild call returns the server instance. """ with patch("shade.OpenStackCloud"): rebuild_server = fakes.FakeServer('1234', '', 'REBUILD') config = {"servers.rebuild.return_value": rebuild_server} OpenStackCloud.nova_client = Mock(**config) self.assertEqual(meta.obj_to_dict(rebuild_server), self.client.rebuild_server("a", "b")) def test_rebuild_server_with_admin_pass_no_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='******') config = { "servers.rebuild.return_value": rebuild_server, } OpenStackCloud.nova_client = Mock(**config) self.assertEqual( meta.obj_to_dict(rebuild_server), self.client.rebuild_server('a', 'b', admin_pass='******')) 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='******') config = { "servers.rebuild.return_value": rebuild_server, "servers.get.return_value": active_server, } 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_rebuild_server_wait(self): """ Test that rebuild_server with a wait returns the server instance when its status changes to "ACTIVE". """ with patch("shade.OpenStackCloud"): rebuild_server = fakes.FakeServer('1234', '', 'REBUILD') active_server = fakes.FakeServer('1234', '', 'ACTIVE') config = { "servers.rebuild.return_value": rebuild_server, "servers.get.return_value": active_server } OpenStackCloud.nova_client = Mock(**config) self.client.name = 'cloud-name' self.assertEqual( _utils.normalize_server(meta.obj_to_dict(active_server), cloud_name='cloud-name', region_name=''), self.client.rebuild_server("a", "b", wait=True))
class TestRebuildServer(base.TestCase): def setUp(self): super(TestRebuildServer, self).setUp() config = os_client_config.OpenStackConfig() self.client = OpenStackCloud( cloud_config=config.get_one_cloud(validate=False)) def test_rebuild_server_rebuild_exception(self): """ Test that an exception in the novaclient rebuild raises an exception in rebuild_server. """ with patch("shade.OpenStackCloud"): config = { "servers.rebuild.side_effect": Exception("exception"), } OpenStackCloud.nova_client = Mock(**config) self.assertRaises( OpenStackCloudException, self.client.rebuild_server, "a", "b") def test_rebuild_server_server_error(self): """ Test that a server error while waiting for the server to rebuild raises an exception in rebuild_server. """ rebuild_server = fakes.FakeServer('1234', '', 'REBUILD') error_server = fakes.FakeServer('1234', '', 'ERROR') with patch("shade.OpenStackCloud"): config = { "servers.rebuild.return_value": rebuild_server, "servers.get.return_value": error_server, } OpenStackCloud.nova_client = Mock(**config) self.assertRaises( OpenStackCloudException, self.client.rebuild_server, "a", "b", wait=True) def test_rebuild_server_timeout(self): """ Test that a timeout while waiting for the server to rebuild raises an exception in rebuild_server. """ rebuild_server = fakes.FakeServer('1234', '', 'REBUILD') with patch("shade.OpenStackCloud"): config = { "servers.rebuild.return_value": rebuild_server, "servers.get.return_value": rebuild_server, } OpenStackCloud.nova_client = Mock(**config) self.assertRaises( OpenStackCloudTimeout, self.client.rebuild_server, "a", "b", wait=True, timeout=0.001) def test_rebuild_server_no_wait(self): """ Test that rebuild_server with no wait and no exception in the novaclient rebuild call returns the server instance. """ with patch("shade.OpenStackCloud"): rebuild_server = fakes.FakeServer('1234', '', 'REBUILD') config = { "servers.rebuild.return_value": rebuild_server } OpenStackCloud.nova_client = Mock(**config) self.assertEqual(meta.obj_to_dict(rebuild_server), self.client.rebuild_server("a", "b")) def test_rebuild_server_with_admin_pass_no_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='******') config = { "servers.rebuild.return_value": rebuild_server, } OpenStackCloud.nova_client = Mock(**config) self.assertEqual( meta.obj_to_dict(rebuild_server), self.client.rebuild_server('a', 'b', admin_pass='******')) 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='******') config = { "servers.rebuild.return_value": rebuild_server, "servers.get.return_value": active_server, } 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_rebuild_server_wait(self): """ Test that rebuild_server with a wait returns the server instance when its status changes to "ACTIVE". """ with patch("shade.OpenStackCloud"): rebuild_server = fakes.FakeServer('1234', '', 'REBUILD') active_server = fakes.FakeServer('1234', '', 'ACTIVE') config = { "servers.rebuild.return_value": rebuild_server, "servers.get.return_value": active_server } OpenStackCloud.nova_client = Mock(**config) self.client.name = 'cloud-name' self.assertEqual( _utils.normalize_server( meta.obj_to_dict(active_server), cloud_name='cloud-name', region_name=''), self.client.rebuild_server("a", "b", wait=True))
def setUp(self): super(TestFloatingIP, self).setUp() # floating_ip_source='neutron' is default for OpenStackCloud() self.client = OpenStackCloud("cloud", {})
class TestFloatingIP(base.TestCase): mock_floating_ip_list_rep = [ { 'fixed_ip': None, 'id': 1, 'instance_id': None, 'ip': '203.0.113.1', 'pool': 'nova' }, { 'fixed_ip': None, 'id': 2, 'instance_id': None, 'ip': '203.0.113.2', 'pool': 'nova' }, { 'fixed_ip': '192.0.2.3', 'id': 29, 'instance_id': 'myself', 'ip': '198.51.100.29', 'pool': 'black_hole' } ] def assertAreInstances(self, elements, elem_type): for e in elements: self.assertIsInstance(e, elem_type) def setUp(self): super(TestFloatingIP, self).setUp() self.client = OpenStackCloud("cloud", {}) @patch.object(OpenStackCloud, 'nova_client') @patch.object(OpenStackCloud, 'has_service') def test_list_floating_ips(self, mock_has_service, mock_nova_client): mock_has_service.side_effect = has_service_side_effect mock_nova_client.floating_ips.list.return_value = [ FakeFloatingIP(**ip) for ip in self.mock_floating_ip_list_rep ] floating_ips = self.client.list_floating_ips() mock_nova_client.floating_ips.list.assert_called_with() self.assertIsInstance(floating_ips, list) self.assertEqual(3, len(floating_ips)) self.assertAreInstances(floating_ips, dict) @patch.object(OpenStackCloud, 'nova_client') @patch.object(OpenStackCloud, 'has_service') def test_search_floating_ips(self, mock_has_service, mock_nova_client): mock_has_service.side_effect = has_service_side_effect mock_nova_client.floating_ips.list.return_value = [ FakeFloatingIP(**ip) for ip in self.mock_floating_ip_list_rep ] floating_ips = self.client.search_floating_ips( filters={'attached': False}) mock_nova_client.floating_ips.list.assert_called_with() self.assertIsInstance(floating_ips, list) self.assertEqual(2, len(floating_ips)) self.assertAreInstances(floating_ips, dict) @patch.object(OpenStackCloud, 'nova_client') @patch.object(OpenStackCloud, 'has_service') def test_get_floating_ip(self, mock_has_service, mock_nova_client): mock_has_service.side_effect = has_service_side_effect mock_nova_client.floating_ips.list.return_value = [ FakeFloatingIP(**ip) for ip in self.mock_floating_ip_list_rep ] floating_ip = self.client.get_floating_ip(id='29') mock_nova_client.floating_ips.list.assert_called_with() self.assertIsInstance(floating_ip, dict) self.assertEqual('198.51.100.29', floating_ip['floating_ip_address']) @patch.object(OpenStackCloud, 'nova_client') @patch.object(OpenStackCloud, 'has_service') def test_get_floating_ip_not_found( self, mock_has_service, mock_nova_client): mock_has_service.side_effect = has_service_side_effect mock_nova_client.floating_ips.list.return_value = [ FakeFloatingIP(**ip) for ip in self.mock_floating_ip_list_rep ] floating_ip = self.client.get_floating_ip(id='666') self.assertIsNone(floating_ip)
class TestDeleteServer(base.TestCase): novaclient_exceptions = ( nova_exc.BadRequest, nova_exc.Unauthorized, nova_exc.Forbidden, nova_exc.MethodNotAllowed, nova_exc.Conflict, nova_exc.OverLimit, nova_exc.RateLimit, nova_exc.HTTPNotImplemented, ) def setUp(self): super(TestDeleteServer, self).setUp() config = os_client_config.OpenStackConfig() self.cloud = OpenStackCloud(cloud_config=config.get_one_cloud(validate=False)) @mock.patch("shade.OpenStackCloud.nova_client") def test_delete_server(self, nova_mock): """ Test that novaclient server delete is called when wait=False """ server = fakes.FakeServer("1234", "daffy", "ACTIVE") nova_mock.servers.list.return_value = [server] self.assertTrue(self.cloud.delete_server("daffy", wait=False)) nova_mock.servers.delete.assert_called_with(server=server.id) @mock.patch("shade.OpenStackCloud.nova_client") def test_delete_server_already_gone(self, nova_mock): """ Test that we return immediately when server is already gone """ nova_mock.servers.list.return_value = [] self.assertFalse(self.cloud.delete_server("tweety", wait=False)) self.assertFalse(nova_mock.servers.delete.called) @mock.patch("shade.OpenStackCloud.nova_client") def test_delete_server_already_gone_wait(self, nova_mock): self.assertFalse(self.cloud.delete_server("speedy", wait=True)) self.assertFalse(nova_mock.servers.delete.called) @mock.patch("shade.OpenStackCloud.nova_client") def test_delete_server_wait_for_notfound(self, nova_mock): """ Test that delete_server waits for NotFound from novaclient """ server = fakes.FakeServer("9999", "wily", "ACTIVE") nova_mock.servers.list.return_value = [server] def _delete_wily(*args, **kwargs): self.assertIn("server", kwargs) self.assertEqual("9999", kwargs["server"]) nova_mock.servers.list.return_value = [] def _raise_notfound(*args, **kwargs): self.assertIn("server", kwargs) self.assertEqual("9999", kwargs["server"]) raise nova_exc.NotFound(code="404") nova_mock.servers.get.side_effect = _raise_notfound nova_mock.servers.delete.side_effect = _delete_wily self.assertTrue(self.cloud.delete_server("wily", wait=True)) nova_mock.servers.delete.assert_called_with(server=server.id) @mock.patch("shade.OpenStackCloud.nova_client") def test_delete_server_fails(self, nova_mock): """ Test that delete_server wraps novaclient exceptions """ nova_mock.servers.list.return_value = [fakes.FakeServer("1212", "speedy", "ACTIVE")] for fail in self.novaclient_exceptions: def _raise_fail(server): raise fail(code=fail.http_status) nova_mock.servers.delete.side_effect = _raise_fail exc = self.assertRaises(shade_exc.OpenStackCloudException, self.cloud.delete_server, "speedy", wait=False) # Note that message is deprecated from Exception, but not in # the novaclient exceptions. self.assertIn(fail.message, str(exc)) @mock.patch("shade.OpenStackCloud.nova_client") def test_delete_server_get_fails(self, nova_mock): """ Test that delete_server wraps novaclient exceptions on wait fails """ nova_mock.servers.list.return_value = [fakes.FakeServer("2000", "yosemite", "ACTIVE")] for fail in self.novaclient_exceptions: def _raise_fail(server): raise fail(code=fail.http_status) nova_mock.servers.get.side_effect = _raise_fail exc = self.assertRaises(shade_exc.OpenStackCloudException, self.cloud.delete_server, "yosemite", wait=True) # Note that message is deprecated from Exception, but not in # the novaclient exceptions. self.assertIn(fail.message, str(exc)) @mock.patch("shade.OpenStackCloud.get_volume") @mock.patch("shade.OpenStackCloud.nova_client") def test_delete_server_no_cinder(self, nova_mock, cinder_mock): """ Test that novaclient server delete is called when wait=False """ server = fakes.FakeServer("1234", "porky", "ACTIVE") nova_mock.servers.list.return_value = [server] with mock.patch("shade.OpenStackCloud.has_service", return_value=False): self.assertTrue(self.cloud.delete_server("porky", wait=False)) nova_mock.servers.delete.assert_called_with(server=server.id) self.assertFalse(cinder_mock.called)
class TestObject(base.TestCase): def setUp(self): super(TestObject, self).setUp() config = os_client_config.OpenStackConfig() self.cloud = OpenStackCloud(cloud_config=config.get_one_cloud( validate=False)) @mock.patch.object(cloud_config.CloudConfig, 'get_session') def test_swift_client_no_endpoint(self, get_session_mock): session_mock = mock.Mock() session_mock.get_endpoint.return_value = None get_session_mock.return_value = session_mock e = self.assertRaises(exc.OpenStackCloudException, lambda: self.cloud.swift_client) self.assertIn('Failed to instantiate object-store client.', str(e)) @mock.patch.object(shade.OpenStackCloud, 'auth_token') @mock.patch.object(shade.OpenStackCloud, 'get_session_endpoint') def test_swift_service(self, endpoint_mock, auth_mock): endpoint_mock.return_value = 'slayer' auth_mock.return_value = 'zulu' self.assertIsInstance(self.cloud.swift_service, swift_service.SwiftService) endpoint_mock.assert_called_with(service_key='object-store') @mock.patch.object(shade.OpenStackCloud, 'get_session_endpoint') def test_swift_service_no_endpoint(self, endpoint_mock): endpoint_mock.side_effect = KeyError e = self.assertRaises(exc.OpenStackCloudException, lambda: self.cloud.swift_service) self.assertIn('Error constructing swift client', str(e)) @mock.patch.object(shade.OpenStackCloud, 'swift_client') def test_get_object_segment_size(self, swift_mock): swift_mock.get_capabilities.return_value = { 'swift': { 'max_file_size': 1000 } } self.assertEqual(900, self.cloud.get_object_segment_size(900)) self.assertEqual(1000, self.cloud.get_object_segment_size(1000)) self.assertEqual(1000, self.cloud.get_object_segment_size(1100)) @mock.patch.object(shade.OpenStackCloud, 'swift_client') def test_get_object_segment_size_http_412(self, swift_mock): swift_mock.get_capabilities.side_effect = swift_exc.ClientException( "Precondition failed", http_status=412) self.assertEqual(shade.openstackcloud.DEFAULT_OBJECT_SEGMENT_SIZE, self.cloud.get_object_segment_size(None)) @mock.patch.object(shade.OpenStackCloud, 'swift_client') def test_create_container(self, mock_swift): """Test creating a (private) container""" name = 'test_container' mock_swift.head_container.return_value = None self.cloud.create_container(name) expected_head_container_calls = [ # once for exist test mock.call(container=name), # once for the final return mock.call(container=name, skip_cache=True) ] self.assertTrue(expected_head_container_calls, mock_swift.head_container.call_args_list) mock_swift.put_container.assert_called_once_with(container=name) # Because the default is 'private', we shouldn't be calling update self.assertFalse(mock_swift.post_container.called) @mock.patch.object(shade.OpenStackCloud, 'swift_client') def test_create_container_public(self, mock_swift): """Test creating a public container""" name = 'test_container' mock_swift.head_container.return_value = None self.cloud.create_container(name, public=True) expected_head_container_calls = [ # once for exist test mock.call(container=name), # once for the final return mock.call(container=name, skip_cache=True) ] self.assertTrue(expected_head_container_calls, mock_swift.head_container.call_args_list) mock_swift.put_container.assert_called_once_with(container=name) mock_swift.post_container.assert_called_once_with( container=name, headers={ 'x-container-read': shade.openstackcloud.OBJECT_CONTAINER_ACLS['public'] }) @mock.patch.object(shade.OpenStackCloud, 'swift_client') def test_create_container_exists(self, mock_swift): """Test creating a container that already exists""" name = 'test_container' fake_container = dict(id='1', name='name') mock_swift.head_container.return_value = fake_container container = self.cloud.create_container(name) mock_swift.head_container.assert_called_once_with(container=name) self.assertEqual(fake_container, container) @mock.patch.object(shade.OpenStackCloud, 'swift_client') def test_delete_container(self, mock_swift): name = 'test_container' self.cloud.delete_container(name) mock_swift.delete_container.assert_called_once_with(container=name) @mock.patch.object(shade.OpenStackCloud, 'swift_client') def test_delete_container_404(self, mock_swift): """No exception when deleting a container that does not exist""" name = 'test_container' mock_swift.delete_container.side_effect = swift_exc.ClientException( 'ERROR', http_status=404) self.cloud.delete_container(name) mock_swift.delete_container.assert_called_once_with(container=name) @mock.patch.object(shade.OpenStackCloud, 'swift_client') def test_delete_container_error(self, mock_swift): """Non-404 swift error re-raised as OSCE""" mock_swift.delete_container.side_effect = swift_exc.ClientException( 'ERROR') self.assertRaises(shade.OpenStackCloudException, self.cloud.delete_container, '') @mock.patch.object(shade.OpenStackCloud, 'swift_client') def test_update_container(self, mock_swift): name = 'test_container' headers = { 'x-container-read': shade.openstackcloud.OBJECT_CONTAINER_ACLS['public'] } self.cloud.update_container(name, headers) mock_swift.post_container.assert_called_once_with(container=name, headers=headers) @mock.patch.object(shade.OpenStackCloud, 'swift_client') def test_update_container_error(self, mock_swift): """Swift error re-raised as OSCE""" mock_swift.post_container.side_effect = swift_exc.ClientException( 'ERROR') self.assertRaises(shade.OpenStackCloudException, self.cloud.update_container, '', '') @mock.patch.object(shade.OpenStackCloud, 'swift_client') def test_set_container_access_public(self, mock_swift): name = 'test_container' self.cloud.set_container_access(name, 'public') mock_swift.post_container.assert_called_once_with( container=name, headers={ 'x-container-read': shade.openstackcloud.OBJECT_CONTAINER_ACLS['public'] }) @mock.patch.object(shade.OpenStackCloud, 'swift_client') def test_set_container_access_private(self, mock_swift): name = 'test_container' self.cloud.set_container_access(name, 'private') mock_swift.post_container.assert_called_once_with( container=name, headers={ 'x-container-read': shade.openstackcloud.OBJECT_CONTAINER_ACLS['private'] }) @mock.patch.object(shade.OpenStackCloud, 'swift_client') def test_set_container_access_invalid(self, mock_swift): self.assertRaises(shade.OpenStackCloudException, self.cloud.set_container_access, '', 'invalid') @mock.patch.object(shade.OpenStackCloud, 'swift_client') def test_get_container(self, mock_swift): fake_container = { 'x-container-read': shade.openstackcloud.OBJECT_CONTAINER_ACLS['public'] } mock_swift.head_container.return_value = fake_container access = self.cloud.get_container_access('foo') self.assertEqual('public', access) @mock.patch.object(shade.OpenStackCloud, 'swift_client') def test_get_container_invalid(self, mock_swift): fake_container = {'x-container-read': 'invalid'} mock_swift.head_container.return_value = fake_container with testtools.ExpectedException( exc.OpenStackCloudException, "Could not determine container access for ACL: invalid"): self.cloud.get_container_access('foo') @mock.patch.object(shade.OpenStackCloud, 'swift_client') def test_get_container_access_not_found(self, mock_swift): name = 'invalid_container' mock_swift.head_container.return_value = None with testtools.ExpectedException(exc.OpenStackCloudException, "Container not found: %s" % name): self.cloud.get_container_access(name) @mock.patch.object(shade.OpenStackCloud, 'swift_client') def test_list_containers(self, mock_swift): containers = [dict(id='1', name='containter1')] mock_swift.get_account.return_value = ('response_headers', containers) ret = self.cloud.list_containers() mock_swift.get_account.assert_called_once_with(full_listing=True) self.assertEqual(containers, ret) @mock.patch.object(shade.OpenStackCloud, 'swift_client') def test_list_containers_not_full(self, mock_swift): containers = [dict(id='1', name='containter1')] mock_swift.get_account.return_value = ('response_headers', containers) ret = self.cloud.list_containers(full_listing=False) mock_swift.get_account.assert_called_once_with(full_listing=False) self.assertEqual(containers, ret) @mock.patch.object(shade.OpenStackCloud, 'swift_client') def test_list_containers_exception(self, mock_swift): mock_swift.get_account.side_effect = swift_exc.ClientException("ERROR") self.assertRaises(exc.OpenStackCloudException, self.cloud.list_containers) @mock.patch.object(shade.OpenStackCloud, 'swift_client') def test_list_objects(self, mock_swift): objects = [dict(id='1', name='object1')] mock_swift.get_container.return_value = ('response_headers', objects) ret = self.cloud.list_objects('container_name') mock_swift.get_container.assert_called_once_with( container='container_name', full_listing=True) self.assertEqual(objects, ret) @mock.patch.object(shade.OpenStackCloud, 'swift_client') def test_list_objects_not_full(self, mock_swift): objects = [dict(id='1', name='object1')] mock_swift.get_container.return_value = ('response_headers', objects) ret = self.cloud.list_objects('container_name', full_listing=False) mock_swift.get_container.assert_called_once_with( container='container_name', full_listing=False) self.assertEqual(objects, ret) @mock.patch.object(shade.OpenStackCloud, 'swift_client') def test_list_objects_exception(self, mock_swift): mock_swift.get_container.side_effect = swift_exc.ClientException( "ERROR") self.assertRaises(exc.OpenStackCloudException, self.cloud.list_objects, 'container_name') @mock.patch.object(shade.OpenStackCloud, 'get_object_metadata') @mock.patch.object(shade.OpenStackCloud, 'swift_client') def test_delete_object(self, mock_swift, mock_get_meta): container_name = 'container_name' object_name = 'object_name' mock_get_meta.return_value = {'object': object_name} self.assertTrue(self.cloud.delete_object(container_name, object_name)) mock_get_meta.assert_called_once_with(container_name, object_name) mock_swift.delete_object.assert_called_once_with( container=container_name, obj=object_name) @mock.patch.object(shade.OpenStackCloud, 'get_object_metadata') @mock.patch.object(shade.OpenStackCloud, 'swift_client') def test_delete_object_not_found(self, mock_swift, mock_get_meta): container_name = 'container_name' object_name = 'object_name' mock_get_meta.return_value = None self.assertFalse(self.cloud.delete_object(container_name, object_name)) mock_get_meta.assert_called_once_with(container_name, object_name) self.assertFalse(mock_swift.delete_object.called) @mock.patch.object(shade.OpenStackCloud, 'get_object_metadata') @mock.patch.object(shade.OpenStackCloud, 'swift_client') def test_delete_object_exception(self, mock_swift, mock_get_meta): container_name = 'container_name' object_name = 'object_name' mock_get_meta.return_value = {'object': object_name} mock_swift.delete_object.side_effect = swift_exc.ClientException( "ERROR") self.assertRaises(shade.OpenStackCloudException, self.cloud.delete_object, container_name, object_name) @mock.patch.object(shade.OpenStackCloud, 'swift_client') def test_get_object(self, mock_swift): fake_resp = ({'headers': 'yup'}, 'test body') mock_swift.get_object.return_value = fake_resp container_name = 'container_name' object_name = 'object_name' resp = self.cloud.get_object(container_name, object_name) self.assertEqual(fake_resp, resp) @mock.patch.object(shade.OpenStackCloud, 'swift_client') def test_get_object_not_found(self, mock_swift): mock_swift.get_object.side_effect = swift_exc.ClientException( 'ERROR', http_status=404) container_name = 'container_name' object_name = 'object_name' self.assertIsNone(self.cloud.get_object(container_name, object_name)) mock_swift.get_object.assert_called_once_with(container=container_name, obj=object_name, query_string=None, resp_chunk_size=None) @mock.patch.object(shade.OpenStackCloud, 'swift_client') def test_get_object_exception(self, mock_swift): mock_swift.get_object.side_effect = swift_exc.ClientException("ERROR") container_name = 'container_name' object_name = 'object_name' self.assertRaises(shade.OpenStackCloudException, self.cloud.get_object, container_name, object_name)
def setUp(self): super(TestRebuildServer, self).setUp() self.client = OpenStackCloud("cloud", {})
class TestDeleteServer(base.TestCase): novaclient_exceptions = (nova_exc.BadRequest, nova_exc.Unauthorized, nova_exc.Forbidden, nova_exc.MethodNotAllowed, nova_exc.Conflict, nova_exc.OverLimit, nova_exc.RateLimit, nova_exc.HTTPNotImplemented) def setUp(self): super(TestDeleteServer, self).setUp() config = os_client_config.OpenStackConfig() self.cloud = OpenStackCloud(cloud_config=config.get_one_cloud()) @mock.patch('shade.OpenStackCloud.nova_client') def test_delete_server(self, nova_mock): """ Test that novaclient server delete is called when wait=False """ server = fakes.FakeServer('1234', 'daffy', 'ACTIVE') nova_mock.servers.list.return_value = [server] self.cloud.delete_server('daffy', wait=False) nova_mock.servers.delete.assert_called_with(server=server.id) @mock.patch('shade.OpenStackCloud.nova_client') def test_delete_server_already_gone(self, nova_mock): """ Test that we return immediately when server is already gone """ nova_mock.servers.list.return_value = [] self.cloud.delete_server('tweety', wait=False) self.assertFalse(nova_mock.servers.delete.called) @mock.patch('shade.OpenStackCloud.nova_client') def test_delete_server_already_gone_wait(self, nova_mock): self.cloud.delete_server('speedy', wait=True) self.assertFalse(nova_mock.servers.delete.called) @mock.patch('shade.OpenStackCloud.nova_client') def test_delete_server_wait_for_notfound(self, nova_mock): """ Test that delete_server waits for NotFound from novaclient """ server = fakes.FakeServer('9999', 'wily', 'ACTIVE') nova_mock.servers.list.return_value = [server] def _delete_wily(*args, **kwargs): self.assertIn('server', kwargs) self.assertEqual('9999', kwargs['server']) nova_mock.servers.list.return_value = [] def _raise_notfound(*args, **kwargs): self.assertIn('server', kwargs) self.assertEqual('9999', kwargs['server']) raise nova_exc.NotFound(code='404') nova_mock.servers.get.side_effect = _raise_notfound nova_mock.servers.delete.side_effect = _delete_wily self.cloud.delete_server('wily', wait=True) nova_mock.servers.delete.assert_called_with(server=server.id) @mock.patch('shade.OpenStackCloud.nova_client') def test_delete_server_fails(self, nova_mock): """ Test that delete_server wraps novaclient exceptions """ nova_mock.servers.list.return_value = [ fakes.FakeServer('1212', 'speedy', 'ACTIVE') ] for fail in self.novaclient_exceptions: def _raise_fail(server): raise fail(code=fail.http_status) nova_mock.servers.delete.side_effect = _raise_fail exc = self.assertRaises(shade_exc.OpenStackCloudException, self.cloud.delete_server, 'speedy', wait=False) # Note that message is deprecated from Exception, but not in # the novaclient exceptions. self.assertIn(fail.message, str(exc)) @mock.patch('shade.OpenStackCloud.nova_client') def test_delete_server_get_fails(self, nova_mock): """ Test that delete_server wraps novaclient exceptions on wait fails """ nova_mock.servers.list.return_value = [ fakes.FakeServer('2000', 'yosemite', 'ACTIVE') ] for fail in self.novaclient_exceptions: def _raise_fail(server): raise fail(code=fail.http_status) nova_mock.servers.get.side_effect = _raise_fail exc = self.assertRaises(shade_exc.OpenStackCloudException, self.cloud.delete_server, 'yosemite', wait=True) # Note that message is deprecated from Exception, but not in # the novaclient exceptions. self.assertIn(fail.message, str(exc))
def setUp(self): super(TestDeleteServer, self).setUp() self.cloud = OpenStackCloud("cloud", {})
def setUp(self): super(TestFloatingIPPool, self).setUp() self.client = OpenStackCloud('cloud', {})
def setUp(self): super(TestDeleteServer, self).setUp() config = os_client_config.OpenStackConfig() self.cloud = OpenStackCloud(cloud_config=config.get_one_cloud())
class TestFloatingIP(base.TestCase): def setUp(self): super(TestFloatingIP, self).setUp() config = os_client_config.OpenStackConfig() self.client = OpenStackCloud(cloud_config=config.get_one_cloud(validate=False)) @patch.object(OpenStackCloud, "get_floating_ip") @patch.object(OpenStackCloud, "_attach_ip_to_server") @patch.object(OpenStackCloud, "available_floating_ip") def test_add_auto_ip(self, mock_available_floating_ip, mock_attach_ip_to_server, mock_get_floating_ip): server = FakeServer(id="server-id", name="test-server", status="ACTIVE", addresses={}) server_dict = meta.obj_to_dict(server) floating_ip_dict = { "id": "this-is-a-floating-ip-id", "fixed_ip_address": None, "floating_ip_address": "203.0.113.29", "network": "this-is-a-net-or-pool-id", "attached": False, "status": "ACTIVE", } mock_available_floating_ip.return_value = floating_ip_dict self.client.add_auto_ip(server=server_dict) mock_attach_ip_to_server.assert_called_with( timeout=60, wait=False, server=server_dict, floating_ip=floating_ip_dict, skip_attach=False ) @patch.object(OpenStackCloud, "nova_client") @patch.object(OpenStackCloud, "_add_ip_from_pool") def test_add_ips_to_server_pool(self, mock_add_ip_from_pool, mock_nova_client): server = FakeServer(id="romeo", name="test-server", status="ACTIVE", addresses={}) server_dict = meta.obj_to_dict(server) pool = "nova" mock_nova_client.servers.get.return_value = server self.client.add_ips_to_server(server_dict, ip_pool=pool) mock_add_ip_from_pool.assert_called_with(server_dict, pool, reuse=True) @patch.object(OpenStackCloud, "nova_client") @patch.object(OpenStackCloud, "add_ip_list") def test_add_ips_to_server_ip_list(self, mock_add_ip_list, mock_nova_client): server = FakeServer(id="server-id", name="test-server", status="ACTIVE", addresses={}) server_dict = meta.obj_to_dict(server) ips = ["203.0.113.29", "172.24.4.229"] mock_nova_client.servers.get.return_value = server self.client.add_ips_to_server(server_dict, ips=ips) mock_add_ip_list.assert_called_with(server_dict, ips) @patch.object(OpenStackCloud, "nova_client") @patch.object(OpenStackCloud, "add_auto_ip") 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)
class TestFloatingIP(base.TestCase): mock_floating_ip_list_rep = [{ 'fixed_ip': None, 'id': 1, 'instance_id': None, 'ip': '203.0.113.1', 'pool': 'nova' }, { 'fixed_ip': None, 'id': 2, 'instance_id': None, 'ip': '203.0.113.2', 'pool': 'nova' }, { 'fixed_ip': '192.0.2.3', 'id': 29, 'instance_id': 'myself', 'ip': '198.51.100.29', 'pool': 'black_hole' }] mock_floating_ip_pools = [{ 'id': 'pool1_id', 'name': 'nova' }, { 'id': 'pool2_id', 'name': 'pool2' }] def assertAreInstances(self, elements, elem_type): for e in elements: self.assertIsInstance(e, elem_type) def setUp(self): super(TestFloatingIP, self).setUp() config = os_client_config.OpenStackConfig() self.client = OpenStackCloud(cloud_config=config.get_one_cloud( validate=False)) self.floating_ips = [ fakes.FakeFloatingIP(**ip) for ip in self.mock_floating_ip_list_rep ] self.fake_server = meta.obj_to_dict( fakes.FakeServer('server-id', '', 'ACTIVE', addresses={ u'test_pnztt_net': [{ u'OS-EXT-IPS:type': u'fixed', u'addr': '192.0.2.129', u'version': 4, u'OS-EXT-IPS-MAC:mac_addr': u'fa:16:3e:ae:7d:42' }] })) self.floating_ip = _utils.normalize_nova_floating_ips( meta.obj_list_to_dict(self.floating_ips))[0] @patch.object(OpenStackCloud, 'nova_client') @patch.object(OpenStackCloud, 'has_service') def test_list_floating_ips(self, mock_has_service, mock_nova_client): mock_has_service.side_effect = has_service_side_effect mock_nova_client.floating_ips.list.return_value = self.floating_ips floating_ips = self.client.list_floating_ips() mock_nova_client.floating_ips.list.assert_called_with() self.assertIsInstance(floating_ips, list) self.assertEqual(3, len(floating_ips)) self.assertAreInstances(floating_ips, dict) @patch.object(OpenStackCloud, 'nova_client') @patch.object(OpenStackCloud, 'has_service') def test_search_floating_ips(self, mock_has_service, mock_nova_client): mock_has_service.side_effect = has_service_side_effect mock_nova_client.floating_ips.list.return_value = self.floating_ips floating_ips = self.client.search_floating_ips( filters={'attached': False}) mock_nova_client.floating_ips.list.assert_called_with() self.assertIsInstance(floating_ips, list) self.assertEqual(2, len(floating_ips)) self.assertAreInstances(floating_ips, dict) @patch.object(OpenStackCloud, 'nova_client') @patch.object(OpenStackCloud, 'has_service') def test_get_floating_ip(self, mock_has_service, mock_nova_client): mock_has_service.side_effect = has_service_side_effect mock_nova_client.floating_ips.list.return_value = self.floating_ips floating_ip = self.client.get_floating_ip(id='29') mock_nova_client.floating_ips.list.assert_called_with() self.assertIsInstance(floating_ip, dict) self.assertEqual('198.51.100.29', floating_ip['floating_ip_address']) @patch.object(OpenStackCloud, 'nova_client') @patch.object(OpenStackCloud, 'has_service') def test_get_floating_ip_not_found(self, mock_has_service, mock_nova_client): mock_has_service.side_effect = has_service_side_effect mock_nova_client.floating_ips.list.return_value = self.floating_ips floating_ip = self.client.get_floating_ip(id='666') self.assertIsNone(floating_ip) @patch.object(OpenStackCloud, 'nova_client') @patch.object(OpenStackCloud, 'has_service') def test_create_floating_ip(self, mock_has_service, mock_nova_client): mock_has_service.side_effect = has_service_side_effect mock_nova_client.floating_ips.create.return_value =\ fakes.FakeFloatingIP(**self.mock_floating_ip_list_rep[1]) self.client.create_floating_ip(network='nova') mock_nova_client.floating_ips.create.assert_called_with(pool='nova') @patch.object(OpenStackCloud, '_nova_list_floating_ips') @patch.object(OpenStackCloud, 'has_service') def test_available_floating_ip_existing(self, mock_has_service, mock__nova_list_floating_ips): mock_has_service.side_effect = has_service_side_effect mock__nova_list_floating_ips.return_value = \ self.mock_floating_ip_list_rep[:1] ip = self.client.available_floating_ip(network='nova') self.assertEqual(self.mock_floating_ip_list_rep[0]['ip'], ip['floating_ip_address']) @patch.object(OpenStackCloud, 'nova_client') @patch.object(OpenStackCloud, '_nova_list_floating_ips') @patch.object(OpenStackCloud, 'has_service') def test_available_floating_ip_new(self, mock_has_service, mock__nova_list_floating_ips, mock_nova_client): mock_has_service.side_effect = has_service_side_effect mock__nova_list_floating_ips.return_value = [] mock_nova_client.floating_ips.create.return_value = \ fakes.FakeFloatingIP(**self.mock_floating_ip_list_rep[0]) ip = self.client.available_floating_ip(network='nova') self.assertEqual(self.mock_floating_ip_list_rep[0]['ip'], ip['floating_ip_address']) @patch.object(OpenStackCloud, 'nova_client') @patch.object(OpenStackCloud, 'has_service') def test_delete_floating_ip_existing(self, mock_has_service, mock_nova_client): mock_has_service.side_effect = has_service_side_effect mock_nova_client.floating_ips.delete.return_value = None ret = self.client.delete_floating_ip( floating_ip_id='a-wild-id-appears') mock_nova_client.floating_ips.delete.assert_called_with( floating_ip='a-wild-id-appears') self.assertTrue(ret) @patch.object(OpenStackCloud, 'nova_client') @patch.object(OpenStackCloud, 'get_floating_ip') def test_delete_floating_ip_not_found(self, mock_get_floating_ip, mock_nova_client): mock_get_floating_ip.return_value = None mock_nova_client.floating_ips.delete.side_effect = n_exc.NotFound( code=404) ret = self.client.delete_floating_ip( floating_ip_id='a-wild-id-appears') self.assertFalse(ret) @patch.object(OpenStackCloud, 'nova_client') @patch.object(OpenStackCloud, 'has_service') def test_attach_ip_to_server(self, mock_has_service, mock_nova_client): mock_has_service.side_effect = has_service_side_effect mock_nova_client.floating_ips.list.return_value = self.floating_ips self.client._attach_ip_to_server(server=self.fake_server, floating_ip=self.floating_ip, fixed_address='192.0.2.129') mock_nova_client.servers.add_floating_ip.assert_called_with( server='server-id', address='203.0.113.1', fixed_address='192.0.2.129') @patch.object(OpenStackCloud, 'nova_client') @patch.object(OpenStackCloud, 'has_service') def test_detach_ip_from_server(self, mock_has_service, mock_nova_client): mock_has_service.side_effect = has_service_side_effect mock_nova_client.floating_ips.list.return_value = [ fakes.FakeFloatingIP(**ip) for ip in self.mock_floating_ip_list_rep ] self.client.detach_ip_from_server(server_id='server-id', floating_ip_id=1) mock_nova_client.servers.remove_floating_ip.assert_called_with( server='server-id', address='203.0.113.1') @patch.object(OpenStackCloud, 'nova_client') @patch.object(OpenStackCloud, 'has_service') def test_add_ip_from_pool(self, mock_has_service, mock_nova_client): mock_has_service.side_effect = has_service_side_effect mock_nova_client.floating_ips.list.return_value = self.floating_ips ip = self.client._add_ip_from_pool(server=self.fake_server, network='nova', fixed_address='192.0.2.129') self.assertEqual('203.0.113.1', ip['floating_ip_address'])
class TestRebuildServer(base.TestCase): def setUp(self): super(TestRebuildServer, self).setUp() self.client = OpenStackCloud("cloud", {}) def test_rebuild_server_rebuild_exception(self): """ Test that an exception in the novaclient rebuild raises an exception in rebuild_server. """ with patch("shade.OpenStackCloud"): config = { "servers.rebuild.side_effect": Exception("exception"), } OpenStackCloud.nova_client = Mock(**config) self.assertRaises( OpenStackCloudException, self.client.rebuild_server, "a", "b") def test_rebuild_server_server_error(self): """ Test that a server error while waiting for the server to rebuild raises an exception in rebuild_server. """ with patch("shade.OpenStackCloud"): config = { "servers.rebuild.return_value": Mock(status="REBUILD"), "servers.get.return_value": Mock(status="ERROR") } OpenStackCloud.nova_client = Mock(**config) self.assertRaises( OpenStackCloudException, self.client.rebuild_server, "a", "b", wait=True) def test_rebuild_server_timeout(self): """ Test that a timeout while waiting for the server to rebuild raises an exception in rebuild_server. """ with patch("shade.OpenStackCloud"): config = { "servers.rebuild.return_value": Mock(status="REBUILD"), "servers.get.return_value": Mock(status="REBUILD") } OpenStackCloud.nova_client = Mock(**config) self.assertRaises( OpenStackCloudTimeout, self.client.rebuild_server, "a", "b", wait=True, timeout=0.001) def test_rebuild_server_no_wait(self): """ Test that rebuild_server with no wait and no exception in the novaclient rebuild call returns the server instance. """ with patch("shade.OpenStackCloud"): mock_server = Mock(status="ACTIVE") config = { "servers.rebuild.return_value": mock_server } OpenStackCloud.nova_client = Mock(**config) self.assertEqual( self.client.rebuild_server("a", "b"), mock_server) def test_rebuild_server_wait(self): """ Test that rebuild_server with a wait returns the server instance when its status changes to "ACTIVE". """ with patch("shade.OpenStackCloud"): mock_server = Mock(status="ACTIVE") config = { "servers.rebuild.return_value": Mock(status="REBUILD"), "servers.get.return_value": mock_server } OpenStackCloud.nova_client = Mock(**config) self.assertEqual( self.client.rebuild_server("a", "b", wait=True), mock_server)
class TestCreateServer(base.TestCase): def setUp(self): super(TestCreateServer, self).setUp() config = os_client_config.OpenStackConfig() self.client = OpenStackCloud(cloud_config=config.get_one_cloud( validate=False)) self.client._SERVER_AGE = 0 def test_create_server_with_create_exception(self): """ Test that an exception in the novaclient create raises an exception in create_server. """ with patch("shade.OpenStackCloud"): config = { "servers.create.side_effect": Exception("exception"), } OpenStackCloud.nova_client = Mock(**config) self.assertRaises(OpenStackCloudException, self.client.create_server, 'server-name', 'image-id', 'flavor-id') def test_create_server_with_get_exception(self): """ Test that an exception when attempting to get the server instance via the novaclient raises an exception in create_server. """ with patch("shade.OpenStackCloud"): config = { "servers.create.return_value": Mock(status="BUILD"), "servers.get.side_effect": Exception("exception") } OpenStackCloud.nova_client = Mock(**config) self.assertRaises(OpenStackCloudException, self.client.create_server, 'server-name', 'image-id', 'flavor-id') def test_create_server_with_server_error(self): """ Test that a server error before we return or begin waiting for the server instance spawn raises an exception in create_server. """ build_server = fakes.FakeServer('1234', '', 'BUILD') error_server = fakes.FakeServer('1234', '', 'ERROR') with patch("shade.OpenStackCloud"): config = { "servers.create.return_value": build_server, "servers.get.return_value": error_server, } OpenStackCloud.nova_client = Mock(**config) self.assertRaises(OpenStackCloudException, self.client.create_server, 'server-name', 'image-id', 'flavor-id') def test_create_server_wait_server_error(self): """ Test that a server error while waiting for the server to spawn raises an exception in create_server. """ with patch("shade.OpenStackCloud"): build_server = fakes.FakeServer('1234', '', 'BUILD') error_server = fakes.FakeServer('1234', '', 'ERROR') config = { "servers.create.return_value": build_server, "servers.get.return_value": build_server, "servers.list.side_effect": [[build_server], [error_server]] } OpenStackCloud.nova_client = Mock(**config) self.assertRaises(OpenStackCloudException, self.client.create_server, 'server-name', 'image-id', 'flavor-id', wait=True) def test_create_server_with_timeout(self): """ Test that a timeout while waiting for the server to spawn raises an exception in create_server. """ with patch("shade.OpenStackCloud"): fake_server = fakes.FakeServer('1234', '', 'BUILD') config = { "servers.create.return_value": fake_server, "servers.get.return_value": fake_server, "servers.list.return_value": [fake_server], } OpenStackCloud.nova_client = Mock(**config) self.assertRaises(OpenStackCloudTimeout, self.client.create_server, 'server-name', 'image-id', 'flavor-id', wait=True, timeout=1) def test_create_server_no_wait(self): """ Test that create_server with no wait and no exception in the novaclient create call returns the server instance. """ with patch("shade.OpenStackCloud"): fake_server = fakes.FakeServer('1234', '', 'BUILD') config = { "servers.create.return_value": fake_server, "servers.get.return_value": fake_server } OpenStackCloud.nova_client = Mock(**config) self.assertEqual( _utils.normalize_server(meta.obj_to_dict(fake_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')) 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='******') config = { "servers.create.return_value": fake_create_server, "servers.get.return_value": fake_server } 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_server_with_admin_pass_wait(self): """ Test that a server with an admin_pass passed returns the password """ with patch("shade.OpenStackCloud"): build_server = fakes.FakeServer('1234', '', 'BUILD', addresses=dict(public='1.1.1.1'), adminPass='******') next_server = fakes.FakeServer('1234', '', 'BUILD', addresses=dict(public='1.1.1.1')) fake_server = fakes.FakeServer('1234', '', 'ACTIVE', addresses=dict(public='1.1.1.1')) ret_fake_server = fakes.FakeServer( '1234', '', 'ACTIVE', addresses=dict(public='1.1.1.1'), adminPass='******') config = { "servers.create.return_value": build_server, "servers.get.return_value": next_server, "servers.list.side_effect": [[next_server], [fake_server]] } OpenStackCloud.nova_client = Mock(**config) with patch.object(OpenStackCloud, "add_ips_to_server", return_value=fake_server): self.assertEqual( _utils.normalize_server( meta.obj_to_dict(ret_fake_server), cloud_name=self.client.name, region_name=self.client.region_name), _utils.normalize_server( meta.obj_to_dict( self.client.create_server( 'server-name', 'image-id', 'flavor-id', wait=True, admin_pass='******')), cloud_name=self.client.name, region_name=self.client.region_name)) def test_create_server_wait(self): """ Test that create_server with a wait returns the server instance when its status changes to "ACTIVE". """ with patch("shade.OpenStackCloud"): build_server = fakes.FakeServer('1234', '', 'ACTIVE', addresses=dict(public='1.1.1.1')) fake_server = fakes.FakeServer('1234', '', 'ACTIVE', addresses=dict(public='1.1.1.1')) config = { "servers.create.return_value": build_server, "servers.get.return_value": build_server, "servers.list.side_effect": [[build_server], [fake_server]] } OpenStackCloud.nova_client = Mock(**config) with patch.object(OpenStackCloud, "add_ips_to_server", return_value=fake_server): self.assertEqual( self.client.create_server('server-name', 'image-id', 'flavor-id', wait=True), fake_server) @patch('time.sleep') def test_create_server_no_addresses(self, mock_sleep): """ Test that create_server with a wait throws an exception if the server doesn't have addresses. """ with patch("shade.OpenStackCloud"): build_server = fakes.FakeServer('1234', '', 'BUILD') fake_server = fakes.FakeServer('1234', '', 'ACTIVE') config = { "servers.create.return_value": build_server, "servers.get.return_value": [build_server, None], "servers.list.side_effect": [[build_server], [fake_server]], "servers.delete.return_value": None, } OpenStackCloud.nova_client = Mock(**config) self.client._SERVER_AGE = 0 with patch.object(OpenStackCloud, "add_ips_to_server", return_value=fake_server): self.assertRaises(OpenStackCloudException, self.client.create_server, 'server-name', 'image-id', 'flavor-id', wait=True) @patch('shade.OpenStackCloud.nova_client') @patch('shade.OpenStackCloud.get_network') def test_create_server_network_with_no_nics(self, mock_get_network, mock_nova): """ Verify that if 'network' is supplied, and 'nics' is not, that we attempt to get the network for the server. """ self.client.create_server('server-name', 'image-id', 'flavor-id', network='network-name') mock_get_network.assert_called_once_with(name_or_id='network-name') @patch('shade.OpenStackCloud.nova_client') @patch('shade.OpenStackCloud.get_network') def test_create_server_network_with_empty_nics(self, mock_get_network, mock_nova): """ Verify that if 'network' is supplied, along with an empty 'nics' list, it's treated the same as if 'nics' were not included. """ self.client.create_server('server-name', 'image-id', 'flavor-id', network='network-name', nics=[]) mock_get_network.assert_called_once_with(name_or_id='network-name')
class TestObject(base.TestCase): def setUp(self): super(TestObject, self).setUp() config = os_client_config.OpenStackConfig() self.cloud = OpenStackCloud( cloud_config=config.get_one_cloud(validate=False)) @mock.patch.object(swift_client, 'Connection') @mock.patch.object(cloud_config.CloudConfig, 'get_session') def test_swift_client(self, get_session_mock, swift_mock): session_mock = mock.Mock() session_mock.get_endpoint.return_value = 'danzig' session_mock.get_token.return_value = 'yankee' get_session_mock.return_value = session_mock self.cloud.swift_client swift_mock.assert_called_with( preauthurl='danzig', preauthtoken='yankee', auth_version=mock.ANY, os_options=dict( object_storage_url='danzig', auth_token='yankee', region_name='')) @mock.patch.object(cloud_config.CloudConfig, 'get_session') def test_swift_client_no_endpoint(self, get_session_mock): session_mock = mock.Mock() session_mock.get_endpoint.return_value = None get_session_mock.return_value = session_mock e = self.assertRaises( exc.OpenStackCloudException, lambda: self.cloud.swift_client) self.assertIn( 'Failed to instantiate object-store client.', str(e)) @mock.patch.object(shade.OpenStackCloud, 'auth_token') @mock.patch.object(shade.OpenStackCloud, 'get_session_endpoint') def test_swift_service(self, endpoint_mock, auth_mock): endpoint_mock.return_value = 'slayer' auth_mock.return_value = 'zulu' self.assertIsInstance(self.cloud.swift_service, swift_service.SwiftService) endpoint_mock.assert_called_with(service_key='object-store') @mock.patch.object(shade.OpenStackCloud, 'get_session_endpoint') def test_swift_service_no_endpoint(self, endpoint_mock): endpoint_mock.side_effect = KeyError e = self.assertRaises(exc.OpenStackCloudException, lambda: self.cloud.swift_service) self.assertIn( 'Error constructing swift client', str(e)) @mock.patch.object(shade.OpenStackCloud, 'swift_client') def test_get_object_segment_size(self, swift_mock): swift_mock.get_capabilities.return_value = {'swift': {'max_file_size': 1000}} self.assertEqual(900, self.cloud.get_object_segment_size(900)) self.assertEqual(1000, self.cloud.get_object_segment_size(1000)) self.assertEqual(1000, self.cloud.get_object_segment_size(1100)) @mock.patch.object(shade.OpenStackCloud, 'swift_client') def test_get_object_segment_size_http_412(self, swift_mock): swift_mock.get_capabilities.side_effect = swift_exc.ClientException( "Precondition failed", http_status=412) self.assertEqual(shade.openstackcloud.DEFAULT_OBJECT_SEGMENT_SIZE, self.cloud.get_object_segment_size(None)) @mock.patch.object(shade.OpenStackCloud, 'swift_client') def test_create_container(self, mock_swift): """Test creating a (private) container""" name = 'test_container' mock_swift.head_container.return_value = None self.cloud.create_container(name) expected_head_container_calls = [ # once for exist test mock.call(container=name), # once for the final return mock.call(container=name, skip_cache=True) ] self.assertTrue(expected_head_container_calls, mock_swift.head_container.call_args_list) mock_swift.put_container.assert_called_once_with(container=name) # Because the default is 'private', we shouldn't be calling update self.assertFalse(mock_swift.post_container.called) @mock.patch.object(shade.OpenStackCloud, 'swift_client') def test_create_container_public(self, mock_swift): """Test creating a public container""" name = 'test_container' mock_swift.head_container.return_value = None self.cloud.create_container(name, public=True) expected_head_container_calls = [ # once for exist test mock.call(container=name), # once for the final return mock.call(container=name, skip_cache=True) ] self.assertTrue(expected_head_container_calls, mock_swift.head_container.call_args_list) mock_swift.put_container.assert_called_once_with(container=name) mock_swift.post_container.assert_called_once_with( container=name, headers={'x-container-read': shade.openstackcloud.OBJECT_CONTAINER_ACLS['public']} ) @mock.patch.object(shade.OpenStackCloud, 'swift_client') def test_create_container_exists(self, mock_swift): """Test creating a container that already exists""" name = 'test_container' fake_container = dict(id='1', name='name') mock_swift.head_container.return_value = fake_container container = self.cloud.create_container(name) mock_swift.head_container.assert_called_once_with(container=name) self.assertEqual(fake_container, container) @mock.patch.object(shade.OpenStackCloud, 'swift_client') def test_delete_container(self, mock_swift): name = 'test_container' self.cloud.delete_container(name) mock_swift.delete_container.assert_called_once_with(container=name) @mock.patch.object(shade.OpenStackCloud, 'swift_client') def test_delete_container_404(self, mock_swift): """No exception when deleting a container that does not exist""" name = 'test_container' mock_swift.delete_container.side_effect = swift_exc.ClientException( 'ERROR', http_status=404) self.cloud.delete_container(name) mock_swift.delete_container.assert_called_once_with(container=name) @mock.patch.object(shade.OpenStackCloud, 'swift_client') def test_delete_container_error(self, mock_swift): """Non-404 swift error re-raised as OSCE""" mock_swift.delete_container.side_effect = swift_exc.ClientException( 'ERROR') self.assertRaises(shade.OpenStackCloudException, self.cloud.delete_container, '') @mock.patch.object(shade.OpenStackCloud, 'swift_client') def test_update_container(self, mock_swift): name = 'test_container' headers = {'x-container-read': shade.openstackcloud.OBJECT_CONTAINER_ACLS['public']} self.cloud.update_container(name, headers) mock_swift.post_container.assert_called_once_with( container=name, headers=headers) @mock.patch.object(shade.OpenStackCloud, 'swift_client') def test_update_container_error(self, mock_swift): """Swift error re-raised as OSCE""" mock_swift.post_container.side_effect = swift_exc.ClientException( 'ERROR') self.assertRaises(shade.OpenStackCloudException, self.cloud.update_container, '', '') @mock.patch.object(shade.OpenStackCloud, 'swift_client') def test_set_container_access_public(self, mock_swift): name = 'test_container' self.cloud.set_container_access(name, 'public') mock_swift.post_container.assert_called_once_with( container=name, headers={'x-container-read': shade.openstackcloud.OBJECT_CONTAINER_ACLS['public']}) @mock.patch.object(shade.OpenStackCloud, 'swift_client') def test_set_container_access_private(self, mock_swift): name = 'test_container' self.cloud.set_container_access(name, 'private') mock_swift.post_container.assert_called_once_with( container=name, headers={'x-container-read': shade.openstackcloud.OBJECT_CONTAINER_ACLS['private']}) @mock.patch.object(shade.OpenStackCloud, 'swift_client') def test_set_container_access_invalid(self, mock_swift): self.assertRaises(shade.OpenStackCloudException, self.cloud.set_container_access, '', 'invalid') @mock.patch.object(shade.OpenStackCloud, 'swift_client') def test_get_container(self, mock_swift): fake_container = { 'x-container-read': shade.openstackcloud.OBJECT_CONTAINER_ACLS['public'] } mock_swift.head_container.return_value = fake_container access = self.cloud.get_container_access('foo') self.assertEqual('public', access) @mock.patch.object(shade.OpenStackCloud, 'swift_client') def test_get_container_invalid(self, mock_swift): fake_container = {'x-container-read': 'invalid'} mock_swift.head_container.return_value = fake_container with testtools.ExpectedException( exc.OpenStackCloudException, "Could not determine container access for ACL: invalid" ): self.cloud.get_container_access('foo') @mock.patch.object(shade.OpenStackCloud, 'swift_client') def test_get_container_access_not_found(self, mock_swift): name = 'invalid_container' mock_swift.head_container.return_value = None with testtools.ExpectedException( exc.OpenStackCloudException, "Container not found: %s" % name ): self.cloud.get_container_access(name) @mock.patch.object(shade.OpenStackCloud, 'swift_client') def test_list_containers(self, mock_swift): containers = [dict(id='1', name='containter1')] mock_swift.get_account.return_value = ('response_headers', containers) ret = self.cloud.list_containers() mock_swift.get_account.assert_called_once_with(full_listing=True) self.assertEqual(containers, ret) @mock.patch.object(shade.OpenStackCloud, 'swift_client') def test_list_containers_not_full(self, mock_swift): containers = [dict(id='1', name='containter1')] mock_swift.get_account.return_value = ('response_headers', containers) ret = self.cloud.list_containers(full_listing=False) mock_swift.get_account.assert_called_once_with(full_listing=False) self.assertEqual(containers, ret) @mock.patch.object(shade.OpenStackCloud, 'swift_client') def test_list_containers_exception(self, mock_swift): mock_swift.get_account.side_effect = swift_exc.ClientException("ERROR") self.assertRaises(exc.OpenStackCloudException, self.cloud.list_containers) @mock.patch.object(shade.OpenStackCloud, 'swift_client') def test_list_objects(self, mock_swift): objects = [dict(id='1', name='object1')] mock_swift.get_container.return_value = ('response_headers', objects) ret = self.cloud.list_objects('container_name') mock_swift.get_container.assert_called_once_with( container='container_name', full_listing=True) self.assertEqual(objects, ret) @mock.patch.object(shade.OpenStackCloud, 'swift_client') def test_list_objects_not_full(self, mock_swift): objects = [dict(id='1', name='object1')] mock_swift.get_container.return_value = ('response_headers', objects) ret = self.cloud.list_objects('container_name', full_listing=False) mock_swift.get_container.assert_called_once_with( container='container_name', full_listing=False) self.assertEqual(objects, ret) @mock.patch.object(shade.OpenStackCloud, 'swift_client') def test_list_objects_exception(self, mock_swift): mock_swift.get_container.side_effect = swift_exc.ClientException( "ERROR") self.assertRaises(exc.OpenStackCloudException, self.cloud.list_objects, 'container_name') @mock.patch.object(shade.OpenStackCloud, 'get_object_metadata') @mock.patch.object(shade.OpenStackCloud, 'swift_client') def test_delete_object(self, mock_swift, mock_get_meta): container_name = 'container_name' object_name = 'object_name' mock_get_meta.return_value = {'object': object_name} self.assertTrue(self.cloud.delete_object(container_name, object_name)) mock_get_meta.assert_called_once_with(container_name, object_name) mock_swift.delete_object.assert_called_once_with( container=container_name, obj=object_name ) @mock.patch.object(shade.OpenStackCloud, 'get_object_metadata') @mock.patch.object(shade.OpenStackCloud, 'swift_client') def test_delete_object_not_found(self, mock_swift, mock_get_meta): container_name = 'container_name' object_name = 'object_name' mock_get_meta.return_value = None self.assertFalse(self.cloud.delete_object(container_name, object_name)) mock_get_meta.assert_called_once_with(container_name, object_name) self.assertFalse(mock_swift.delete_object.called) @mock.patch.object(shade.OpenStackCloud, 'get_object_metadata') @mock.patch.object(shade.OpenStackCloud, 'swift_client') def test_delete_object_exception(self, mock_swift, mock_get_meta): container_name = 'container_name' object_name = 'object_name' mock_get_meta.return_value = {'object': object_name} mock_swift.delete_object.side_effect = swift_exc.ClientException( "ERROR") self.assertRaises(shade.OpenStackCloudException, self.cloud.delete_object, container_name, object_name) @mock.patch.object(shade.OpenStackCloud, 'swift_client') def test_get_object(self, mock_swift): fake_resp = ({'headers': 'yup'}, 'test body') mock_swift.get_object.return_value = fake_resp container_name = 'container_name' object_name = 'object_name' resp = self.cloud.get_object(container_name, object_name) self.assertEqual(fake_resp, resp) @mock.patch.object(shade.OpenStackCloud, 'swift_client') def test_get_object_not_found(self, mock_swift): mock_swift.get_object.side_effect = swift_exc.ClientException( 'ERROR', http_status=404) container_name = 'container_name' object_name = 'object_name' self.assertIsNone(self.cloud.get_object(container_name, object_name)) mock_swift.get_object.assert_called_once_with( container=container_name, obj=object_name, query_string=None, resp_chunk_size=None) @mock.patch.object(shade.OpenStackCloud, 'swift_client') def test_get_object_exception(self, mock_swift): mock_swift.get_object.side_effect = swift_exc.ClientException("ERROR") container_name = 'container_name' object_name = 'object_name' self.assertRaises(shade.OpenStackCloudException, self.cloud.get_object, container_name, object_name)
def setUp(self): super(TestCreateServer, self).setUp() config = os_client_config.OpenStackConfig() self.client = OpenStackCloud(cloud_config=config.get_one_cloud( validate=False)) self.client._SERVER_AGE = 0
class TestDeleteVolumeSnapshot(base.TestCase): def setUp(self): super(TestDeleteVolumeSnapshot, self).setUp() config = os_client_config.OpenStackConfig() self.client = OpenStackCloud( cloud_config=config.get_one_cloud(validate=False)) @patch.object(OpenStackCloud, 'cinder_client') def test_delete_volume_snapshot(self, mock_cinder): """ Test that delete_volume_snapshot without a wait returns True instance when the volume snapshot deletes. """ fake_snapshot = fakes.FakeVolumeSnapshot('1234', 'available', 'foo', 'derpysnapshot') mock_cinder.volume_snapshots.list.return_value = [fake_snapshot] self.assertEqual( True, self.client.delete_volume_snapshot(name_or_id='1234', wait=False) ) mock_cinder.volume_snapshots.list.assert_called_with(detailed=True, search_opts=None) @patch.object(OpenStackCloud, 'cinder_client') def test_delete_volume_snapshot_with_error(self, mock_cinder): """ Test that a exception while deleting a volume snapshot will cause an OpenStackCloudException. """ fake_snapshot = fakes.FakeVolumeSnapshot('1234', 'available', 'foo', 'derpysnapshot') mock_cinder.volume_snapshots.delete.side_effect = Exception( "exception") mock_cinder.volume_snapshots.list.return_value = [fake_snapshot] self.assertRaises( OpenStackCloudException, self.client.delete_volume_snapshot, name_or_id='1234', wait=True, timeout=1) mock_cinder.volume_snapshots.delete.assert_called_with( snapshot='1234') @patch.object(OpenStackCloud, 'cinder_client') def test_delete_volume_snapshot_with_timeout(self, mock_cinder): """ Test that a timeout while waiting for the volume snapshot to delete raises an exception in delete_volume_snapshot. """ fake_snapshot = fakes.FakeVolumeSnapshot('1234', 'available', 'foo', 'derpysnapshot') mock_cinder.volume_snapshots.list.return_value = [fake_snapshot] self.assertRaises( OpenStackCloudTimeout, self.client.delete_volume_snapshot, name_or_id='1234', wait=True, timeout=1) mock_cinder.volume_snapshots.list.assert_called_with(detailed=True, search_opts=None)
class TestFloatingIP(base.TestCase): def setUp(self): super(TestFloatingIP, self).setUp() config = os_client_config.OpenStackConfig() self.client = OpenStackCloud(cloud_config=config.get_one_cloud( validate=False)) @patch.object(OpenStackCloud, 'get_floating_ip') @patch.object(OpenStackCloud, '_attach_ip_to_server') @patch.object(OpenStackCloud, 'available_floating_ip') def test_add_auto_ip(self, mock_available_floating_ip, mock_attach_ip_to_server, mock_get_floating_ip): server = FakeServer(id='server-id', name='test-server', status="ACTIVE", addresses={}) server_dict = meta.obj_to_dict(server) floating_ip_dict = { "id": "this-is-a-floating-ip-id", "fixed_ip_address": None, "internal_network": None, "floating_ip_address": "203.0.113.29", "network": "this-is-a-net-or-pool-id", "attached": False, "status": "ACTIVE" } mock_available_floating_ip.return_value = floating_ip_dict self.client.add_auto_ip(server=server_dict) mock_attach_ip_to_server.assert_called_with( timeout=60, wait=False, server=server_dict, floating_ip=floating_ip_dict, skip_attach=False) @patch.object(OpenStackCloud, 'nova_client') @patch.object(OpenStackCloud, '_add_ip_from_pool') def test_add_ips_to_server_pool(self, mock_add_ip_from_pool, mock_nova_client): server = FakeServer(id='romeo', name='test-server', status="ACTIVE", addresses={}) server_dict = meta.obj_to_dict(server) pool = 'nova' mock_nova_client.servers.get.return_value = server self.client.add_ips_to_server(server_dict, ip_pool=pool) mock_add_ip_from_pool.assert_called_with(server_dict, pool, reuse=True, wait=False, timeout=60, fixed_address=None, nat_destination=None) @patch.object(OpenStackCloud, 'nova_client') @patch.object(OpenStackCloud, 'add_ip_list') def test_add_ips_to_server_ip_list(self, mock_add_ip_list, mock_nova_client): server = FakeServer(id='server-id', name='test-server', status="ACTIVE", addresses={}) server_dict = meta.obj_to_dict(server) ips = ['203.0.113.29', '172.24.4.229'] mock_nova_client.servers.get.return_value = server self.client.add_ips_to_server(server_dict, ips=ips) mock_add_ip_list.assert_called_with(server_dict, ips, wait=False, timeout=60, fixed_address=None) @patch.object(OpenStackCloud, 'nova_client') @patch.object(OpenStackCloud, '_add_auto_ip') 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)
class TestCreateServer(base.TestCase): def setUp(self): super(TestCreateServer, self).setUp() self.client = OpenStackCloud("cloud", {}) def test_create_server_with_create_exception(self): """ Test that an exception in the novaclient create raises an exception in create_server. """ with patch("shade.OpenStackCloud"): config = { "servers.create.side_effect": Exception("exception"), } OpenStackCloud.nova_client = Mock(**config) self.assertRaises(OpenStackCloudException, self.client.create_server) def test_create_server_with_get_exception(self): """ Test that an exception when attempting to get the server instance via the novaclient raises an exception in create_server. """ with patch("shade.OpenStackCloud"): config = { "servers.create.return_value": Mock(status="BUILD"), "servers.get.side_effect": Exception("exception") } OpenStackCloud.nova_client = Mock(**config) self.assertRaises(OpenStackCloudException, self.client.create_server) def test_create_server_with_server_error(self): """ Test that a server error before we return or begin waiting for the server instance spawn raises an exception in create_server. """ with patch("shade.OpenStackCloud"): config = { "servers.create.return_value": Mock(status="BUILD"), "servers.get.return_value": Mock(status="ERROR") } OpenStackCloud.nova_client = Mock(**config) self.assertRaises(OpenStackCloudException, self.client.create_server) def test_create_server_wait_server_error(self): """ Test that a server error while waiting for the server to spawn raises an exception in create_server. """ with patch("shade.OpenStackCloud"): config = { "servers.create.return_value": Mock(status="BUILD"), "servers.get.side_effect": [Mock(status="BUILD"), Mock(status="ERROR")] } OpenStackCloud.nova_client = Mock(**config) self.assertRaises(OpenStackCloudException, self.client.create_server, wait=True) def test_create_server_with_timeout(self): """ Test that a timeout while waiting for the server to spawn raises an exception in create_server. """ with patch("shade.OpenStackCloud"): config = { "servers.create.return_value": Mock(status="BUILD"), "servers.get.return_value": Mock(status="BUILD") } OpenStackCloud.nova_client = Mock(**config) self.assertRaises(OpenStackCloudTimeout, self.client.create_server, wait=True, timeout=1) def test_create_server_no_wait(self): """ Test that create_server with no wait and no exception in the novaclient create call returns the server instance. """ with patch("shade.OpenStackCloud"): mock_server = Mock(status="BUILD") config = { "servers.create.return_value": mock_server, "servers.get.return_value": mock_server } OpenStackCloud.nova_client = Mock(**config) self.assertEqual(self.client.create_server(), mock_server) def test_create_server_wait(self): """ Test that create_server with a wait returns the server instance when its status changes to "ACTIVE". """ with patch("shade.OpenStackCloud"): mock_server = Mock(status="ACTIVE") config = { "servers.create.return_value": Mock(status="BUILD"), "servers.get.side_effect": [Mock(status="BUILD"), mock_server] } OpenStackCloud.nova_client = Mock(**config) with patch.object(OpenStackCloud, "add_ips_to_server", return_value=mock_server): self.assertEqual(self.client.create_server(wait=True), mock_server)
def setUp(self): super(TestCreateServer, self).setUp() self.client = OpenStackCloud("cloud", {})
class TestCreateServer(base.TestCase): def setUp(self): super(TestCreateServer, self).setUp() config = os_client_config.OpenStackConfig() self.client = OpenStackCloud(cloud_config=config.get_one_cloud()) def test_create_server_with_create_exception(self): """ Test that an exception in the novaclient create raises an exception in create_server. """ with patch("shade.OpenStackCloud"): config = { "servers.create.side_effect": Exception("exception"), } OpenStackCloud.nova_client = Mock(**config) self.assertRaises( OpenStackCloudException, self.client.create_server) def test_create_server_with_get_exception(self): """ Test that an exception when attempting to get the server instance via the novaclient raises an exception in create_server. """ with patch("shade.OpenStackCloud"): config = { "servers.create.return_value": Mock(status="BUILD"), "servers.get.side_effect": Exception("exception") } OpenStackCloud.nova_client = Mock(**config) self.assertRaises( OpenStackCloudException, self.client.create_server) def test_create_server_with_server_error(self): """ Test that a server error before we return or begin waiting for the server instance spawn raises an exception in create_server. """ with patch("shade.OpenStackCloud"): config = { "servers.create.return_value": Mock(status="BUILD"), "servers.get.return_value": Mock(status="ERROR") } OpenStackCloud.nova_client = Mock(**config) self.assertRaises( OpenStackCloudException, self.client.create_server) def test_create_server_wait_server_error(self): """ Test that a server error while waiting for the server to spawn raises an exception in create_server. """ with patch("shade.OpenStackCloud"): config = { "servers.create.return_value": Mock(status="BUILD"), "servers.get.side_effect": [ Mock(status="BUILD"), Mock(status="ERROR")] } OpenStackCloud.nova_client = Mock(**config) self.assertRaises( OpenStackCloudException, self.client.create_server, wait=True) def test_create_server_with_timeout(self): """ Test that a timeout while waiting for the server to spawn raises an exception in create_server. """ with patch("shade.OpenStackCloud"): config = { "servers.create.return_value": Mock(status="BUILD"), "servers.get.return_value": Mock(status="BUILD") } OpenStackCloud.nova_client = Mock(**config) self.assertRaises( OpenStackCloudTimeout, self.client.create_server, wait=True, timeout=1) def test_create_server_no_wait(self): """ Test that create_server with no wait and no exception in the novaclient create call returns the server instance. """ with patch("shade.OpenStackCloud"): fake_server = fakes.FakeServer('', '', 'BUILD') config = { "servers.create.return_value": fake_server, "servers.get.return_value": fake_server } OpenStackCloud.nova_client = Mock(**config) self.assertEqual(meta.obj_to_dict(fake_server), self.client.create_server()) def test_create_server_wait(self): """ Test that create_server with a wait returns the server instance when its status changes to "ACTIVE". """ with patch("shade.OpenStackCloud"): fake_server = fakes.FakeServer( '', '', 'ACTIVE', addresses=dict(public='1.1.1.1')) config = { "servers.create.return_value": fakes.FakeServer('', '', 'ACTIVE'), "servers.get.side_effect": [ Mock(status="BUILD"), fake_server] } OpenStackCloud.nova_client = Mock(**config) with patch.object(OpenStackCloud, "add_ips_to_server", return_value=fake_server): self.assertEqual( self.client.create_server(wait=True), fake_server) def test_create_server_no_addresses(self): """ Test that create_server with a wait throws an exception if the server doesn't have addresses. """ with patch("shade.OpenStackCloud"): fake_server = fakes.FakeServer('', '', 'ACTIVE') config = { "servers.create.return_value": fakes.FakeServer('', '', 'ACTIVE'), "servers.get.side_effect": [ Mock(status="BUILD"), fake_server] } OpenStackCloud.nova_client = Mock(**config) with patch.object(OpenStackCloud, "add_ips_to_server", return_value=fake_server): self.assertRaises( OpenStackCloudException, self.client.create_server, wait=True)
def setUp(self): super(TestPort, self).setUp() config = os_client_config.OpenStackConfig() self.client = OpenStackCloud( cloud_config=config.get_one_cloud(validate=False))
class TestFloatingIP(base.TestCase): mock_floating_ip_list_rep = [ { 'fixed_ip': None, 'id': 1, 'instance_id': None, 'ip': '203.0.113.1', 'pool': 'nova' }, { 'fixed_ip': None, 'id': 2, 'instance_id': None, 'ip': '203.0.113.2', 'pool': 'nova' }, { 'fixed_ip': '192.0.2.3', 'id': 29, 'instance_id': 'myself', 'ip': '198.51.100.29', 'pool': 'black_hole' } ] mock_floating_ip_pools = [ {'id': 'pool1_id', 'name': 'nova'}, {'id': 'pool2_id', 'name': 'pool2'}] def assertAreInstances(self, elements, elem_type): for e in elements: self.assertIsInstance(e, elem_type) def setUp(self): super(TestFloatingIP, self).setUp() config = os_client_config.OpenStackConfig() self.client = OpenStackCloud( cloud_config=config.get_one_cloud(validate=False)) self.floating_ips = [ fakes.FakeFloatingIP(**ip) for ip in self.mock_floating_ip_list_rep ] self.fake_server = meta.obj_to_dict( fakes.FakeServer( 'server-id', '', 'ACTIVE', addresses={u'test_pnztt_net': [{ u'OS-EXT-IPS:type': u'fixed', u'addr': '192.0.2.129', u'version': 4, u'OS-EXT-IPS-MAC:mac_addr': u'fa:16:3e:ae:7d:42'}]})) self.floating_ip = _utils.normalize_nova_floating_ips( meta.obj_list_to_dict(self.floating_ips))[0] @patch.object(OpenStackCloud, 'nova_client') @patch.object(OpenStackCloud, 'has_service') def test_list_floating_ips(self, mock_has_service, mock_nova_client): mock_has_service.side_effect = has_service_side_effect mock_nova_client.floating_ips.list.return_value = self.floating_ips floating_ips = self.client.list_floating_ips() mock_nova_client.floating_ips.list.assert_called_with() self.assertIsInstance(floating_ips, list) self.assertEqual(3, len(floating_ips)) self.assertAreInstances(floating_ips, dict) @patch.object(OpenStackCloud, 'nova_client') @patch.object(OpenStackCloud, 'has_service') def test_search_floating_ips(self, mock_has_service, mock_nova_client): mock_has_service.side_effect = has_service_side_effect mock_nova_client.floating_ips.list.return_value = self.floating_ips floating_ips = self.client.search_floating_ips( filters={'attached': False}) mock_nova_client.floating_ips.list.assert_called_with() self.assertIsInstance(floating_ips, list) self.assertEqual(2, len(floating_ips)) self.assertAreInstances(floating_ips, dict) @patch.object(OpenStackCloud, 'nova_client') @patch.object(OpenStackCloud, 'has_service') def test_get_floating_ip(self, mock_has_service, mock_nova_client): mock_has_service.side_effect = has_service_side_effect mock_nova_client.floating_ips.list.return_value = self.floating_ips floating_ip = self.client.get_floating_ip(id='29') mock_nova_client.floating_ips.list.assert_called_with() self.assertIsInstance(floating_ip, dict) self.assertEqual('198.51.100.29', floating_ip['floating_ip_address']) @patch.object(OpenStackCloud, 'nova_client') @patch.object(OpenStackCloud, 'has_service') def test_get_floating_ip_not_found( self, mock_has_service, mock_nova_client): mock_has_service.side_effect = has_service_side_effect mock_nova_client.floating_ips.list.return_value = self.floating_ips floating_ip = self.client.get_floating_ip(id='666') self.assertIsNone(floating_ip) @patch.object(OpenStackCloud, 'nova_client') @patch.object(OpenStackCloud, 'has_service') def test_create_floating_ip(self, mock_has_service, mock_nova_client): mock_has_service.side_effect = has_service_side_effect mock_nova_client.floating_ips.create.return_value =\ fakes.FakeFloatingIP(**self.mock_floating_ip_list_rep[1]) self.client.create_floating_ip(network='nova') mock_nova_client.floating_ips.create.assert_called_with(pool='nova') @patch.object(OpenStackCloud, '_nova_list_floating_ips') @patch.object(OpenStackCloud, 'has_service') def test_available_floating_ip_existing( self, mock_has_service, mock__nova_list_floating_ips): mock_has_service.side_effect = has_service_side_effect mock__nova_list_floating_ips.return_value = \ self.mock_floating_ip_list_rep[:1] ip = self.client.available_floating_ip(network='nova') self.assertEqual(self.mock_floating_ip_list_rep[0]['ip'], ip['floating_ip_address']) @patch.object(OpenStackCloud, 'nova_client') @patch.object(OpenStackCloud, '_nova_list_floating_ips') @patch.object(OpenStackCloud, 'has_service') def test_available_floating_ip_new( self, mock_has_service, mock__nova_list_floating_ips, mock_nova_client): mock_has_service.side_effect = has_service_side_effect mock__nova_list_floating_ips.return_value = [] mock_nova_client.floating_ips.create.return_value = \ fakes.FakeFloatingIP(**self.mock_floating_ip_list_rep[0]) ip = self.client.available_floating_ip(network='nova') self.assertEqual(self.mock_floating_ip_list_rep[0]['ip'], ip['floating_ip_address']) @patch.object(OpenStackCloud, 'nova_client') @patch.object(OpenStackCloud, 'has_service') def test_delete_floating_ip_existing( self, mock_has_service, mock_nova_client): mock_has_service.side_effect = has_service_side_effect mock_nova_client.floating_ips.delete.return_value = None ret = self.client.delete_floating_ip( floating_ip_id='a-wild-id-appears') mock_nova_client.floating_ips.delete.assert_called_with( floating_ip='a-wild-id-appears') self.assertTrue(ret) @patch.object(OpenStackCloud, 'nova_client') @patch.object(OpenStackCloud, 'get_floating_ip') def test_delete_floating_ip_not_found( self, mock_get_floating_ip, mock_nova_client): mock_get_floating_ip.return_value = None mock_nova_client.floating_ips.delete.side_effect = n_exc.NotFound( code=404) ret = self.client.delete_floating_ip( floating_ip_id='a-wild-id-appears') self.assertFalse(ret) @patch.object(OpenStackCloud, 'nova_client') @patch.object(OpenStackCloud, 'has_service') def test_attach_ip_to_server(self, mock_has_service, mock_nova_client): mock_has_service.side_effect = has_service_side_effect mock_nova_client.floating_ips.list.return_value = self.floating_ips self.client._attach_ip_to_server( server=self.fake_server, floating_ip=self.floating_ip, fixed_address='192.0.2.129') mock_nova_client.servers.add_floating_ip.assert_called_with( server='server-id', address='203.0.113.1', fixed_address='192.0.2.129') @patch.object(OpenStackCloud, 'nova_client') @patch.object(OpenStackCloud, 'has_service') def test_detach_ip_from_server(self, mock_has_service, mock_nova_client): mock_has_service.side_effect = has_service_side_effect mock_nova_client.floating_ips.list.return_value = [ fakes.FakeFloatingIP(**ip) for ip in self.mock_floating_ip_list_rep ] self.client.detach_ip_from_server( server_id='server-id', floating_ip_id=1) mock_nova_client.servers.remove_floating_ip.assert_called_with( server='server-id', address='203.0.113.1') @patch.object(OpenStackCloud, 'nova_client') @patch.object(OpenStackCloud, 'has_service') def test_add_ip_from_pool(self, mock_has_service, mock_nova_client): mock_has_service.side_effect = has_service_side_effect mock_nova_client.floating_ips.list.return_value = self.floating_ips server = self.client._add_ip_from_pool( server=self.fake_server, network='nova', fixed_address='192.0.2.129') self.assertEqual(server, self.fake_server)
class TestPort(base.TestCase): mock_neutron_port_create_rep = { 'port': { 'status': 'DOWN', 'binding:host_id': '', 'name': 'test-port-name', 'allowed_address_pairs': [], 'admin_state_up': True, 'network_id': 'test-net-id', 'tenant_id': 'test-tenant-id', 'binding:vif_details': {}, 'binding:vnic_type': 'normal', 'binding:vif_type': 'unbound', 'device_owner': '', 'mac_address': '50:1c:0d:e4:f0:0d', 'binding:profile': {}, 'fixed_ips': [ { 'subnet_id': 'test-subnet-id', 'ip_address': '29.29.29.29' } ], 'id': 'test-port-id', 'security_groups': [], 'device_id': '' } } mock_neutron_port_update_rep = { 'port': { 'status': 'DOWN', 'binding:host_id': '', 'name': 'test-port-name-updated', 'allowed_address_pairs': [], 'admin_state_up': True, 'network_id': 'test-net-id', 'tenant_id': 'test-tenant-id', 'binding:vif_details': {}, 'binding:vnic_type': 'normal', 'binding:vif_type': 'unbound', 'device_owner': '', 'mac_address': '50:1c:0d:e4:f0:0d', 'binding:profile': {}, 'fixed_ips': [ { 'subnet_id': 'test-subnet-id', 'ip_address': '29.29.29.29' } ], 'id': 'test-port-id', 'security_groups': [], 'device_id': '' } } mock_neutron_port_list_rep = { 'ports': [ { 'status': 'ACTIVE', 'binding:host_id': 'devstack', 'name': 'first-port', 'allowed_address_pairs': [], 'admin_state_up': True, 'network_id': '70c1db1f-b701-45bd-96e0-a313ee3430b3', 'tenant_id': '', 'extra_dhcp_opts': [], 'binding:vif_details': { 'port_filter': True, 'ovs_hybrid_plug': True }, 'binding:vif_type': 'ovs', 'device_owner': 'network:router_gateway', 'mac_address': 'fa:16:3e:58:42:ed', 'binding:profile': {}, 'binding:vnic_type': 'normal', 'fixed_ips': [ { 'subnet_id': '008ba151-0b8c-4a67-98b5-0d2b87666062', 'ip_address': '172.24.4.2' } ], 'id': 'd80b1a3b-4fc1-49f3-952e-1e2ab7081d8b', 'security_groups': [], 'device_id': '9ae135f4-b6e0-4dad-9e91-3c223e385824' }, { 'status': 'ACTIVE', 'binding:host_id': 'devstack', 'name': '', 'allowed_address_pairs': [], 'admin_state_up': True, 'network_id': 'f27aa545-cbdd-4907-b0c6-c9e8b039dcc2', 'tenant_id': 'd397de8a63f341818f198abb0966f6f3', 'extra_dhcp_opts': [], 'binding:vif_details': { 'port_filter': True, 'ovs_hybrid_plug': True }, 'binding:vif_type': 'ovs', 'device_owner': 'network:router_interface', 'mac_address': 'fa:16:3e:bb:3c:e4', 'binding:profile': {}, 'binding:vnic_type': 'normal', 'fixed_ips': [ { 'subnet_id': '288bf4a1-51ba-43b6-9d0a-520e9005db17', 'ip_address': '10.0.0.1' } ], 'id': 'f71a6703-d6de-4be1-a91a-a570ede1d159', 'security_groups': [], 'device_id': '9ae135f4-b6e0-4dad-9e91-3c223e385824' } ] } def setUp(self): super(TestPort, self).setUp() config = os_client_config.OpenStackConfig() self.client = OpenStackCloud( cloud_config=config.get_one_cloud(validate=False)) @patch.object(OpenStackCloud, 'neutron_client') def test_create_port(self, mock_neutron_client): mock_neutron_client.create_port.return_value = \ self.mock_neutron_port_create_rep port = self.client.create_port( network_id='test-net-id', name='test-port-name', admin_state_up=True) mock_neutron_client.create_port.assert_called_with( body={'port': dict(network_id='test-net-id', name='test-port-name', admin_state_up=True)}) self.assertEqual(self.mock_neutron_port_create_rep['port'], port) def test_create_port_parameters(self): """Test that we detect invalid arguments passed to create_port""" self.assertRaises( TypeError, self.client.create_port, network_id='test-net-id', nome='test-port-name', stato_amministrativo_porta=True) @patch.object(OpenStackCloud, 'neutron_client') def test_create_port_exception(self, mock_neutron_client): mock_neutron_client.create_port.side_effect = Exception('blah') self.assertRaises( OpenStackCloudException, self.client.create_port, network_id='test-net-id', name='test-port-name', admin_state_up=True) @patch.object(OpenStackCloud, 'neutron_client') def test_update_port(self, mock_neutron_client): mock_neutron_client.list_ports.return_value = \ self.mock_neutron_port_list_rep mock_neutron_client.update_port.return_value = \ self.mock_neutron_port_update_rep port = self.client.update_port( name_or_id='d80b1a3b-4fc1-49f3-952e-1e2ab7081d8b', name='test-port-name-updated') mock_neutron_client.update_port.assert_called_with( port='d80b1a3b-4fc1-49f3-952e-1e2ab7081d8b', body={'port': dict(name='test-port-name-updated')}) self.assertEqual(self.mock_neutron_port_update_rep['port'], port) def test_update_port_parameters(self): """Test that we detect invalid arguments passed to update_port""" self.assertRaises( TypeError, self.client.update_port, name_or_id='test-port-id', nome='test-port-name-updated') @patch.object(OpenStackCloud, 'neutron_client') def test_update_port_exception(self, mock_neutron_client): mock_neutron_client.list_ports.return_value = \ self.mock_neutron_port_list_rep mock_neutron_client.update_port.side_effect = Exception('blah') self.assertRaises( OpenStackCloudException, self.client.update_port, name_or_id='d80b1a3b-4fc1-49f3-952e-1e2ab7081d8b', name='test-port-name-updated') @patch.object(OpenStackCloud, 'neutron_client') def test_list_ports(self, mock_neutron_client): mock_neutron_client.list_ports.return_value = \ self.mock_neutron_port_list_rep ports = self.client.list_ports() mock_neutron_client.list_ports.assert_called_with() self.assertItemsEqual(self.mock_neutron_port_list_rep['ports'], ports) @patch.object(OpenStackCloud, 'neutron_client') def test_list_ports_exception(self, mock_neutron_client): mock_neutron_client.list_ports.side_effect = Exception('blah') self.assertRaises(OpenStackCloudException, self.client.list_ports) @patch.object(OpenStackCloud, 'neutron_client') def test_search_ports_by_id(self, mock_neutron_client): mock_neutron_client.list_ports.return_value = \ self.mock_neutron_port_list_rep ports = self.client.search_ports( name_or_id='f71a6703-d6de-4be1-a91a-a570ede1d159') mock_neutron_client.list_ports.assert_called_with() self.assertEquals(1, len(ports)) self.assertEquals('fa:16:3e:bb:3c:e4', ports[0]['mac_address']) @patch.object(OpenStackCloud, 'neutron_client') def test_search_ports_by_name(self, mock_neutron_client): mock_neutron_client.list_ports.return_value = \ self.mock_neutron_port_list_rep ports = self.client.search_ports(name_or_id='first-port') mock_neutron_client.list_ports.assert_called_with() self.assertEquals(1, len(ports)) self.assertEquals('fa:16:3e:58:42:ed', ports[0]['mac_address']) @patch.object(OpenStackCloud, 'neutron_client') def test_search_ports_not_found(self, mock_neutron_client): mock_neutron_client.list_ports.return_value = \ self.mock_neutron_port_list_rep ports = self.client.search_ports(name_or_id='non-existent') mock_neutron_client.list_ports.assert_called_with() self.assertEquals(0, len(ports)) @patch.object(OpenStackCloud, 'neutron_client') def test_delete_port(self, mock_neutron_client): mock_neutron_client.list_ports.return_value = \ self.mock_neutron_port_list_rep self.client.delete_port(name_or_id='first-port') mock_neutron_client.delete_port.assert_called_with( port='d80b1a3b-4fc1-49f3-952e-1e2ab7081d8b')
def setUp(self): super(TestCreateServer, self).setUp() config = os_client_config.OpenStackConfig() self.client = OpenStackCloud( cloud_config=config.get_one_cloud(validate=False)) self.client._SERVER_AGE = 0
class TestPort(base.TestCase): mock_neutron_port_create_rep = { 'port': { 'status': 'DOWN', 'binding:host_id': '', 'name': 'test-port-name', 'allowed_address_pairs': [], 'admin_state_up': True, 'network_id': 'test-net-id', 'tenant_id': 'test-tenant-id', 'binding:vif_details': {}, 'binding:vnic_type': 'normal', 'binding:vif_type': 'unbound', 'device_owner': '', 'mac_address': '50:1c:0d:e4:f0:0d', 'binding:profile': {}, 'fixed_ips': [ { 'subnet_id': 'test-subnet-id', 'ip_address': '29.29.29.29' } ], 'id': 'test-port-id', 'security_groups': [], 'device_id': '' } } mock_neutron_port_update_rep = { 'port': { 'status': 'DOWN', 'binding:host_id': '', 'name': 'test-port-name-updated', 'allowed_address_pairs': [], 'admin_state_up': True, 'network_id': 'test-net-id', 'tenant_id': 'test-tenant-id', 'binding:vif_details': {}, 'binding:vnic_type': 'normal', 'binding:vif_type': 'unbound', 'device_owner': '', 'mac_address': '50:1c:0d:e4:f0:0d', 'binding:profile': {}, 'fixed_ips': [ { 'subnet_id': 'test-subnet-id', 'ip_address': '29.29.29.29' } ], 'id': 'test-port-id', 'security_groups': [], 'device_id': '' } } mock_neutron_port_list_rep = { 'ports': [ { 'status': 'ACTIVE', 'binding:host_id': 'devstack', 'name': 'first-port', 'allowed_address_pairs': [], 'admin_state_up': True, 'network_id': '70c1db1f-b701-45bd-96e0-a313ee3430b3', 'tenant_id': '', 'extra_dhcp_opts': [], 'binding:vif_details': { 'port_filter': True, 'ovs_hybrid_plug': True }, 'binding:vif_type': 'ovs', 'device_owner': 'network:router_gateway', 'mac_address': 'fa:16:3e:58:42:ed', 'binding:profile': {}, 'binding:vnic_type': 'normal', 'fixed_ips': [ { 'subnet_id': '008ba151-0b8c-4a67-98b5-0d2b87666062', 'ip_address': '172.24.4.2' } ], 'id': 'd80b1a3b-4fc1-49f3-952e-1e2ab7081d8b', 'security_groups': [], 'device_id': '9ae135f4-b6e0-4dad-9e91-3c223e385824' }, { 'status': 'ACTIVE', 'binding:host_id': 'devstack', 'name': '', 'allowed_address_pairs': [], 'admin_state_up': True, 'network_id': 'f27aa545-cbdd-4907-b0c6-c9e8b039dcc2', 'tenant_id': 'd397de8a63f341818f198abb0966f6f3', 'extra_dhcp_opts': [], 'binding:vif_details': { 'port_filter': True, 'ovs_hybrid_plug': True }, 'binding:vif_type': 'ovs', 'device_owner': 'network:router_interface', 'mac_address': 'fa:16:3e:bb:3c:e4', 'binding:profile': {}, 'binding:vnic_type': 'normal', 'fixed_ips': [ { 'subnet_id': '288bf4a1-51ba-43b6-9d0a-520e9005db17', 'ip_address': '10.0.0.1' } ], 'id': 'f71a6703-d6de-4be1-a91a-a570ede1d159', 'security_groups': [], 'device_id': '9ae135f4-b6e0-4dad-9e91-3c223e385824' } ] } def setUp(self): super(TestPort, self).setUp() self.client = OpenStackCloud('cloud', {}) @patch.object(OpenStackCloud, 'neutron_client') def test_create_port(self, mock_neutron_client): mock_neutron_client.create_port.return_value = \ self.mock_neutron_port_create_rep port = self.client.create_port( network_id='test-net-id', name='test-port-name', admin_state_up=True) mock_neutron_client.create_port.assert_called_with( body={'port': dict(network_id='test-net-id', name='test-port-name', admin_state_up=True)}) self.assertEqual(self.mock_neutron_port_create_rep['port'], port) def test_create_port_parameters(self): """Test that we detect invalid arguments passed to create_port""" self.assertRaises( TypeError, self.client.create_port, network_id='test-net-id', nome='test-port-name', stato_amministrativo_porta=True) @patch.object(OpenStackCloud, 'neutron_client') def test_create_port_exception(self, mock_neutron_client): mock_neutron_client.create_port.side_effect = Exception('blah') self.assertRaises( OpenStackCloudException, self.client.create_port, network_id='test-net-id', name='test-port-name', admin_state_up=True) @patch.object(OpenStackCloud, 'neutron_client') def test_update_port(self, mock_neutron_client): mock_neutron_client.list_ports.return_value = \ self.mock_neutron_port_list_rep mock_neutron_client.update_port.return_value = \ self.mock_neutron_port_update_rep port = self.client.update_port( name_or_id='d80b1a3b-4fc1-49f3-952e-1e2ab7081d8b', name='test-port-name-updated') mock_neutron_client.update_port.assert_called_with( port='d80b1a3b-4fc1-49f3-952e-1e2ab7081d8b', body={'port': dict(name='test-port-name-updated')}) self.assertEqual(self.mock_neutron_port_update_rep['port'], port) def test_update_port_parameters(self): """Test that we detect invalid arguments passed to update_port""" self.assertRaises( TypeError, self.client.update_port, name_or_id='test-port-id', nome='test-port-name-updated') @patch.object(OpenStackCloud, 'neutron_client') def test_update_port_exception(self, mock_neutron_client): mock_neutron_client.list_ports.return_value = \ self.mock_neutron_port_list_rep mock_neutron_client.update_port.side_effect = Exception('blah') self.assertRaises( OpenStackCloudException, self.client.update_port, name_or_id='d80b1a3b-4fc1-49f3-952e-1e2ab7081d8b', name='test-port-name-updated') @patch.object(OpenStackCloud, 'neutron_client') def test_list_ports(self, mock_neutron_client): mock_neutron_client.list_ports.return_value = \ self.mock_neutron_port_list_rep ports = self.client.list_ports() mock_neutron_client.list_ports.assert_called_with() self.assertItemsEqual(self.mock_neutron_port_list_rep['ports'], ports) @patch.object(OpenStackCloud, 'neutron_client') def test_list_ports_exception(self, mock_neutron_client): mock_neutron_client.list_ports.side_effect = Exception('blah') self.assertRaises(OpenStackCloudException, self.client.list_ports) @patch.object(OpenStackCloud, 'neutron_client') def test_search_ports_by_id(self, mock_neutron_client): mock_neutron_client.list_ports.return_value = \ self.mock_neutron_port_list_rep ports = self.client.search_ports( name_or_id='f71a6703-d6de-4be1-a91a-a570ede1d159') mock_neutron_client.list_ports.assert_called_with() self.assertEquals(1, len(ports)) self.assertEquals('fa:16:3e:bb:3c:e4', ports[0]['mac_address']) @patch.object(OpenStackCloud, 'neutron_client') def test_search_ports_by_name(self, mock_neutron_client): mock_neutron_client.list_ports.return_value = \ self.mock_neutron_port_list_rep ports = self.client.search_ports(name_or_id='first-port') mock_neutron_client.list_ports.assert_called_with() self.assertEquals(1, len(ports)) self.assertEquals('fa:16:3e:58:42:ed', ports[0]['mac_address']) @patch.object(OpenStackCloud, 'neutron_client') def test_search_ports_not_found(self, mock_neutron_client): mock_neutron_client.list_ports.return_value = \ self.mock_neutron_port_list_rep ports = self.client.search_ports(name_or_id='non-existent') mock_neutron_client.list_ports.assert_called_with() self.assertEquals(0, len(ports)) @patch.object(OpenStackCloud, 'neutron_client') def test_delete_port(self, mock_neutron_client): mock_neutron_client.list_ports.return_value = \ self.mock_neutron_port_list_rep self.client.delete_port(name_or_id='first-port') mock_neutron_client.delete_port.assert_called_with( port='d80b1a3b-4fc1-49f3-952e-1e2ab7081d8b')
def setUp(self): super(TestRebuildServer, self).setUp() config = os_client_config.OpenStackConfig() self.client = OpenStackCloud( cloud_config=config.get_one_cloud(validate=False))
class TestCreateServer(base.TestCase): def setUp(self): super(TestCreateServer, self).setUp() config = os_client_config.OpenStackConfig() self.client = OpenStackCloud(cloud_config=config.get_one_cloud( validate=False)) def test_create_server_with_create_exception(self): """ Test that an exception in the novaclient create raises an exception in create_server. """ with patch("shade.OpenStackCloud"): config = { "servers.create.side_effect": Exception("exception"), } OpenStackCloud.nova_client = Mock(**config) self.assertRaises(OpenStackCloudException, self.client.create_server, 'server-name', 'image-id', 'flavor-id') def test_create_server_with_get_exception(self): """ Test that an exception when attempting to get the server instance via the novaclient raises an exception in create_server. """ with patch("shade.OpenStackCloud"): config = { "servers.create.return_value": Mock(status="BUILD"), "servers.get.side_effect": Exception("exception") } OpenStackCloud.nova_client = Mock(**config) self.assertRaises(OpenStackCloudException, self.client.create_server, 'server-name', 'image-id', 'flavor-id') def test_create_server_with_server_error(self): """ Test that a server error before we return or begin waiting for the server instance spawn raises an exception in create_server. """ build_server = fakes.FakeServer('1234', '', 'BUILD') error_server = fakes.FakeServer('1234', '', 'ERROR') with patch("shade.OpenStackCloud"): config = { "servers.create.return_value": build_server, "servers.get.return_value": error_server, } OpenStackCloud.nova_client = Mock(**config) self.assertRaises(OpenStackCloudException, self.client.create_server, 'server-name', 'image-id', 'flavor-id') def test_create_server_wait_server_error(self): """ Test that a server error while waiting for the server to spawn raises an exception in create_server. """ with patch("shade.OpenStackCloud"): build_server = fakes.FakeServer('1234', '', 'BUILD') error_server = fakes.FakeServer('1234', '', 'ERROR') config = { "servers.create.return_value": build_server, "servers.get.return_value": build_server, "servers.list.side_effect": [[build_server], [error_server]] } OpenStackCloud.nova_client = Mock(**config) self.assertRaises(OpenStackCloudException, self.client.create_server, 'server-name', 'image-id', 'flavor-id', wait=True) def test_create_server_with_timeout(self): """ Test that a timeout while waiting for the server to spawn raises an exception in create_server. """ with patch("shade.OpenStackCloud"): fake_server = fakes.FakeServer('1234', '', 'BUILD') config = { "servers.create.return_value": fake_server, "servers.get.return_value": fake_server, "servers.list.return_value": [fake_server], } OpenStackCloud.nova_client = Mock(**config) self.assertRaises(OpenStackCloudTimeout, self.client.create_server, 'server-name', 'image-id', 'flavor-id', wait=True, timeout=1) def test_create_server_no_wait(self): """ Test that create_server with no wait and no exception in the novaclient create call returns the server instance. """ with patch("shade.OpenStackCloud"): fake_server = fakes.FakeServer('1234', '', 'BUILD') config = { "servers.create.return_value": fake_server, "servers.get.return_value": fake_server } OpenStackCloud.nova_client = Mock(**config) self.assertEqual( meta.obj_to_dict(fake_server), self.client.create_server(name='server-name', image='image=id', flavor='flavor-id')) def test_create_server_wait(self): """ Test that create_server with a wait returns the server instance when its status changes to "ACTIVE". """ with patch("shade.OpenStackCloud"): build_server = fakes.FakeServer('1234', '', 'ACTIVE', addresses=dict(public='1.1.1.1')) fake_server = fakes.FakeServer('1234', '', 'ACTIVE', addresses=dict(public='1.1.1.1')) config = { "servers.create.return_value": build_server, "servers.get.return_value": build_server, "servers.list.side_effect": [[build_server], [fake_server]] } OpenStackCloud.nova_client = Mock(**config) with patch.object(OpenStackCloud, "add_ips_to_server", return_value=fake_server): self.assertEqual( self.client.create_server('server-name', 'image-id', 'flavor-id', wait=True), fake_server) def test_create_server_no_addresses(self): """ Test that create_server with a wait throws an exception if the server doesn't have addresses. """ with patch("shade.OpenStackCloud"): build_server = fakes.FakeServer('1234', '', 'BUILD') fake_server = fakes.FakeServer('1234', '', 'ACTIVE') config = { "servers.create.return_value": build_server, "servers.get.return_value": build_server, "servers.list.side_effect": [[build_server], [fake_server]] } OpenStackCloud.nova_client = Mock(**config) with patch.object(OpenStackCloud, "add_ips_to_server", return_value=fake_server): self.assertRaises(OpenStackCloudException, self.client.create_server, 'server-name', 'image-id', 'flavor-id', wait=True)