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_get_server_cloud_rackspace_v6( self, mock_list_networks, mock_has_service, mock_get_flavor_name, mock_get_image_name, mock_list_server_security_groups, mock_list_subnets, mock_list_floating_ips): self.cloud._floating_ip_source = None self.cloud.force_ipv4 = False self.cloud._local_ipv6 = True mock_get_image_name.return_value = 'cirros-0.3.4-x86_64-uec' mock_get_flavor_name.return_value = 'm1.tiny' mock_has_service.return_value = False srv = self.cloud.get_openstack_vars( meta.obj_to_dict( fakes.FakeServer( id='test-id', name='test-name', status='ACTIVE', flavor={u'id': u'1'}, image={ 'name': u'cirros-0.3.4-x86_64-uec', u'id': u'f93d000b-7c29-4489-b375-3641a1758fe1' }, addresses={ 'private': [{ 'addr': "10.223.160.141", 'version': 4 }], 'public': [{ 'addr': "104.130.246.91", 'version': 4 }, { 'addr': "2001:4800:7819:103:be76:4eff:fe05:8525", 'version': 6 }] }))) self.assertEqual("10.223.160.141", srv['private_v4']) self.assertEqual("104.130.246.91", srv['public_v4']) self.assertEqual("2001:4800:7819:103:be76:4eff:fe05:8525", srv['public_v6']) self.assertEqual("2001:4800:7819:103:be76:4eff:fe05:8525", srv['interface_ip']) mock_list_subnets.assert_not_called() mock_list_networks.assert_not_called() mock_list_floating_ips.assert_not_called()
def setUp(self): super(TestFloatingIP, self).setUp() 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]
def test_list_hosts_no_detail(self, mock_cloud, mock_add, mock_config): mock_config.return_value.get_all_clouds.return_value = [{}] inv = inventory.OpenStackInventory() server = _utils.normalize_server(meta.obj_to_dict( fakes.FakeServer('1234', 'test', 'ACTIVE', addresses={})), region_name='', cloud_name='') self.assertIsInstance(inv.clouds, list) self.assertEqual(1, len(inv.clouds)) inv.clouds[0].list_servers.return_value = [server] inv.list_hosts(expand=False) inv.clouds[0].list_servers.assert_called_once_with() self.assertFalse(inv.clouds[0].get_openstack_vars.called) mock_add.assert_called_once_with(inv.clouds[0], server)
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.list.return_value": [rebuild_server], } OpenStackCloud.nova_client = Mock(**config) self.assertRaises(OpenStackCloudTimeout, self.cloud.rebuild_server, "a", "b", wait=True, timeout=0.001)
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.cloud.rebuild_server('a', 'b', admin_pass='******'))
def test_get_server_external_ipv4_nova_none(self, mock_get_server_ip, mock_has_service): # Testing Clouds w/o Neutron and a globally routable IP mock_has_service.return_value = False mock_get_server_ip.return_value = None srv = meta.obj_to_dict( fakes.FakeServer(id='test-id', name='test-name', status='ACTIVE', addresses={'test-net': [{ 'addr': PRIVATE_V4 }]})) ip = meta.get_server_external_ipv4( cloud=shade.openstack_cloud(validate=False), server=srv) self.assertIsNone(ip) self.assertTrue(mock_get_server_ip.called)
def test_get_server_multiple_private_ip(self): self.register_uris([ dict( method='GET', uri='https://network.example.com/v2.0/networks.json', json={'networks': [{ 'id': 'test-net-id', 'name': 'test-net' }]}), dict(method='GET', uri='https://network.example.com/v2.0/subnets.json', json={'subnets': SUBNETS_WITH_NAT}) ]) shared_mac = '11:22:33:44:55:66' distinct_mac = '66:55:44:33:22:11' srv = meta.obj_to_dict( fakes.FakeServer(id='test-id', name='test-name', status='ACTIVE', addresses={ 'test-net': [{ 'OS-EXT-IPS:type': 'fixed', 'OS-EXT-IPS-MAC:mac_addr': distinct_mac, 'addr': '10.0.0.100', 'version': 4 }, { 'OS-EXT-IPS:type': 'fixed', 'OS-EXT-IPS-MAC:mac_addr': shared_mac, 'addr': '10.0.0.101', 'version': 4 }], 'public': [{ 'OS-EXT-IPS:type': 'floating', 'OS-EXT-IPS-MAC:mac_addr': shared_mac, 'addr': PUBLIC_V4, 'version': 4 }] })) self.assertEqual('10.0.0.101', meta.get_server_private_ip(srv, self.cloud)) self.assert_calls()
def test_get_server_external_ipv4_neutron_exception(self): # Testing Clouds with a non working Neutron self.register_uri('GET', 'https://network.example.com/v2.0/networks.json', status_code=404) srv = meta.obj_to_dict( fakes.FakeServer( id='test-id', name='test-name', status='ACTIVE', addresses={'public': [{ 'addr': PUBLIC_V4, 'version': 4 }]})) ip = meta.get_server_external_ipv4(cloud=self.cloud, server=srv) self.assertEqual(PUBLIC_V4, ip) self.assert_calls()
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_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))
def test_get_server_external_ipv4_neutron( self, mock_search_networks, mock_has_service): # Testing Clouds with Neutron mock_has_service.return_value = True mock_search_networks.return_value = [{ 'id': 'test-net-id', 'name': 'test-net' }] srv = meta.obj_to_dict(fakes.FakeServer( id='test-id', name='test-name', status='ACTIVE', addresses={'test-net': [{ 'addr': PUBLIC_V4, 'version': 4}]}, )) ip = meta.get_server_external_ipv4( cloud=shade.openstack_cloud(validate=False), server=srv) self.assertEqual(PUBLIC_V4, ip)
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.nova_client"): fake_server = fakes.FakeServer('1234', '', 'BUILD') fake_floating_ip = fakes.FakeFloatingIP('1234', 'ippool', '1.1.1.1', '2.2.2.2', '5678') config = { "servers.create.return_value": fake_server, "servers.get.return_value": fake_server, "floating_ips.list.return_value": [fake_floating_ip] } OpenStackCloud.nova_client = Mock(**config) self.assertEqual( self.cloud._normalize_server(meta.obj_to_dict(fake_server)), self.cloud.create_server(name='server-name', image=dict(id='image=id'), flavor=dict(id='flavor-id')))
def setUp(self): super(TestFloatingIP, self).setUp() 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 = self.cloud._normalize_floating_ips( self.mock_floating_ip_list_rep['floatingips'])[0]
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)
def test_get_server_external_ipv4_nova_public( self, mock_is_globally_routable_ipv4, mock_get_server_ip, mock_has_service): # Testing Clouds w/o Neutron and a network named public mock_has_service.return_value = False mock_get_server_ip.return_value = None mock_is_globally_routable_ipv4.return_value = True srv = meta.obj_to_dict( fakes.FakeServer(id='test-id', name='test-name', status='ACTIVE', addresses={'test-net': [{ 'addr': PUBLIC_V4 }]})) ip = meta.get_server_external_ipv4(cloud=shade.openstack_cloud(), server=srv) self.assertEqual(PUBLIC_V4, ip) self.assertTrue(mock_get_server_ip.called) self.assertTrue(mock_is_globally_routable_ipv4.called)
def setUp(self): super(TestFloatingIP, self).setUp() self.fake_server = meta.obj_to_munch( 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.cloud.has_service = get_fake_has_service(self.cloud.has_service)
def test_get_server_private_ip_devstack( self, mock_search_networks, mock_has_service, mock_get_flavor_name, mock_get_image_name, mock_list_server_security_groups): mock_get_image_name.return_value = 'cirros-0.3.4-x86_64-uec' mock_get_flavor_name.return_value = 'm1.tiny' mock_has_service.return_value = True mock_search_networks.return_value = [ { 'id': 'test_pnztt_net', 'name': 'test_pnztt_net' }, { 'id': 'private', 'name': 'private', }, ] cloud = shade.openstack_cloud(validate=False) srv = cloud.get_openstack_vars(meta.obj_to_dict(fakes.FakeServer( id='test-id', name='test-name', status='ACTIVE', flavor={u'id': u'1'}, image={ 'name': u'cirros-0.3.4-x86_64-uec', u'id': u'f93d000b-7c29-4489-b375-3641a1758fe1'}, addresses={u'test_pnztt_net': [{ u'OS-EXT-IPS:type': u'fixed', u'addr': PRIVATE_V4, u'version': 4, u'OS-EXT-IPS-MAC:mac_addr': u'fa:16:3e:ae:7d:42' }]} ))) self.assertEqual(PRIVATE_V4, srv['private_v4']) mock_has_service.assert_called_with('volume') mock_search_networks.assert_called_with( filters={'router:external': False} )
def test_add_bad_security_group_to_server_neutron(self): # fake to get server by name, server-name must match fake_server = fakes.FakeServer('1234', 'server-name', 'ACTIVE') # use neutron for secgroup list and return an existing fake self.cloud.secgroup_source = 'neutron' self.register_uris([ dict(method='GET', uri=self.get_mock_url('compute', 'public', append=['servers', 'detail']), json={'servers': [meta.obj_to_munch(fake_server)]}), dict(method='GET', uri=self.get_mock_url('network', 'public', append=['v2.0', 'security-groups.json']), json={'security_groups': [neutron_grp_dict]}) ]) self.assertFalse( self.cloud.add_server_security_groups('server-name', 'unknown-sec-group')) self.assert_calls()
def test_add_bad_security_group_to_server_nova(self): # fake to get server by name, server-name must match fake_server = meta.obj_to_munch( fakes.FakeServer('1234', 'server-name', 'ACTIVE')) # use nova for secgroup list and return an existing fake self.has_neutron = False self.cloud.secgroup_source = 'nova' self.register_uris([ dict(method='GET', uri='{endpoint}/servers/detail'.format( endpoint=fakes.COMPUTE_ENDPOINT), json={'servers': [fake_server]}), dict(method='GET', uri='{endpoint}/os-security-groups'.format( endpoint=fakes.COMPUTE_ENDPOINT), json={'security_groups': [nova_grp_dict]}), ]) ret = self.cloud.add_server_security_groups('server-name', 'unknown-sec-group') self.assertFalse(ret) self.assert_calls()
def test_create_server_no_wait(self, mock_nova): """ Test that create_server with no wait and no exception in the novaclient create call returns the server instance. """ fake_server = fakes.FakeServer('1234', '', 'BUILD') fake_floating_ip = fakes.FakeFloatingIP('1234', 'ippool', '1.1.1.1', '2.2.2.2', '5678') mock_nova.servers.create.return_value = fake_server mock_nova.servers.get.return_value = fake_server self.register_uris([ dict(method='GET', uri=self.get_mock_url('network', 'public', append=['v2.0', 'networks.json']), json={'networks': []}), dict(method='GET', uri=self.get_mock_url('network', 'public', append=['v2.0', 'ports.json'], qs_elements=['device_id=1234']), json={'ports': []}), dict(method='GET', uri=self.get_mock_url('network', 'public', append=['v2.0', 'floatingips.json']), json={'floatingips': [fake_floating_ip]}) ]) self.assertEqual( self.cloud._normalize_server(meta.obj_to_dict(fake_server)), self.cloud.create_server(name='server-name', image=dict(id='image=id'), flavor=dict(id='flavor-id'))) # TODO(slaweq): change do_count to True when all nova mocks will be # replaced with request_mocks also self.assert_calls(do_count=False)
def test_create_server_with_timeout(self, mock_nova): """ Test that a timeout while waiting for the server to spawn raises an exception in create_server. """ fake_server = fakes.FakeServer('1234', '', 'BUILD') self.register_uris([ dict(method='GET', uri=self.get_mock_url('network', 'public', append=['v2.0', 'networks.json']), json={'networks': []}) ]) mock_nova.servers.create.return_value = fake_server mock_nova.servers.get.return_value = fake_server mock_nova.servers.list.return_value = [fake_server] self.assertRaises(exc.OpenStackCloudTimeout, self.cloud.create_server, 'server-name', dict(id='image-id'), dict(id='flavor-id'), wait=True, timeout=0.01) self.assert_calls()
def test_get_server_external_ipv4_neutron(self, mock_get_server_ip, mock_search_networks, mock_search_ports, mock_has_service): # Testing Clouds with Neutron mock_has_service.return_value = True mock_search_ports.return_value = [{ 'network_id': 'test-net-id', 'fixed_ips': [{ 'ip_address': PUBLIC_V4 }], 'device_id': 'test-id' }] mock_search_networks.return_value = [{'id': 'test-net-id'}] srv = meta.obj_to_dict( fakes.FakeServer(id='test-id', name='test-name', status='ACTIVE')) ip = meta.get_server_external_ipv4(cloud=shade.openstack_cloud(), server=srv) self.assertEqual(PUBLIC_V4, ip) self.assertFalse(mock_get_server_ip.called)
def test_get_server_private_ip( self, mock_search_networks, mock_has_service): mock_has_service.return_value = True mock_search_networks.return_value = [{ 'id': 'test-net-id', 'name': 'test-net-name' }] srv = meta.obj_to_dict(fakes.FakeServer( id='test-id', name='test-name', status='ACTIVE', addresses={'private': [{'OS-EXT-IPS:type': 'fixed', 'addr': PRIVATE_V4, 'version': 4}], 'public': [{'OS-EXT-IPS:type': 'floating', 'addr': PUBLIC_V4, 'version': 4}]} )) cloud = shade.openstack_cloud(validate=False) self.assertEqual(PRIVATE_V4, meta.get_server_private_ip(srv, cloud)) mock_has_service.assert_called_with('network') mock_search_networks.assert_called_with( filters={'router:external': False} )
def get_default_network(self): return None standard_fake_server = fakes.FakeServer( id='test-id-0', name='test-id-0', status='ACTIVE', metadata={'group': 'test-group'}, addresses={ 'private': [{ 'OS-EXT-IPS:type': 'fixed', 'addr': PRIVATE_V4, 'version': 4 }], 'public': [{ 'OS-EXT-IPS:type': 'floating', 'addr': PUBLIC_V4, 'version': 4 }] }, flavor={'id': '101'}, image={'id': '471c2475-da2f-47ac-aba5-cb4aa3d546f5'}, accessIPv4='', accessIPv6='', ) SUBNETS_WITH_NAT = [ { u'name': u'', u'enable_dhcp': True,
def test_get_server_cloud_missing_fips(self, mock_get_flavor_name, mock_get_image_name, mock_get_volumes, mock_has_service): mock_get_image_name.return_value = 'cirros-0.3.4-x86_64-uec' mock_get_flavor_name.return_value = 'm1.tiny' mock_get_volumes.return_value = [] mock_has_service.return_value = True self.register_uris([ dict(method='GET', uri=('https://network.example.com/v2.0/ports.json?' 'device_id=test-id'), json={ 'ports': [{ 'id': 'test_port_id', 'mac_address': 'fa:16:3e:ae:7d:42', 'device_id': 'test-id' }] }), dict(method='GET', uri=('https://network.example.com/v2.0/floatingips.json' '?port_id=test_port_id'), json={ 'floatingips': [{ 'id': 'floating-ip-id', 'port_id': 'test_port_id', 'fixed_ip_address': PRIVATE_V4, 'floating_ip_address': PUBLIC_V4, }] }), dict(method='GET', uri='https://network.example.com/v2.0/networks.json', json={ 'networks': [{ 'id': 'test_pnztt_net', 'name': 'test_pnztt_net', 'router:external': False, }, { 'id': 'private', 'name': 'private', }] }), dict(method='GET', uri='https://network.example.com/v2.0/subnets.json', json={'subnets': SUBNETS_WITH_NAT}), dict(method='GET', uri='{endpoint}/servers/test-id/os-security-groups'.format( endpoint=fakes.COMPUTE_ENDPOINT), json={'security_groups': []}) ]) srv = self.cloud.get_openstack_vars( meta.obj_to_dict( fakes.FakeServer(id='test-id', name='test-name', status='ACTIVE', flavor={u'id': u'1'}, image={ 'name': u'cirros-0.3.4-x86_64-uec', u'id': u'f93d000b-7c29-4489-b375-3641a1758fe1' }, addresses={ u'test_pnztt_net': [{ u'addr': PRIVATE_V4, u'version': 4, 'OS-EXT-IPS-MAC:mac_addr': 'fa:16:3e:ae:7d:42', }] }))) self.assertEqual(PUBLIC_V4, srv['public_v4']) self.assert_calls()