def test_log_ovs_db_debug_enabled(self):
self.useFixture(mockpatch.PatchObject(test.CONF.debug,
'enable', True))
self.useFixture(mockpatch.PatchObject(test.CONF.service_available,
'neutron', True))
debug.log_ovs_db()
self.ovs_db_dump_mock.assert_called_with()
def setUp(self):
super(BaseRestClientTestClass, self).setUp()
self.stubs.Set(config, 'TempestConfigPrivate', fake_config.FakeConfig)
self.rest_client = rest_client.RestClient(
fake_auth_provider.FakeAuthProvider())
self.stubs.Set(httplib2.Http, 'request', self.fake_http.request)
self.useFixture(mockpatch.PatchObject(self.rest_client, '_get_region',
side_effect=self._get_region()))
self.useFixture(mockpatch.PatchObject(self.rest_client,
'_log_response'))
def test_raw_request_chunked(self):
self.useFixture(mockpatch.PatchObject(glance_http, 'CHUNKSIZE', 1))
self.useFixture(
mockpatch.PatchObject(httplib.HTTPConnection, 'endheaders'))
self.useFixture(mockpatch.PatchObject(httplib.HTTPConnection, 'send'))
self._set_response_fixture({}, 200, 'fake_response_body')
req_body = six.StringIO('fake_request_body')
resp, body = self.client.raw_request('PUT', '/images', body=req_body)
self.assertEqual(200, resp.status)
self.assertEqual('fake_response_body', body.read())
httplib.HTTPConnection.send.assert_call_count(req_body.len)
def test_get_nova_versions(self):
self.useFixture(mockpatch.PatchObject(
verify_tempest_config, '_get_unversioned_endpoint',
return_value='http://fake_endpoint:5000'))
fake_resp = {'versions': [{'id': 'v2.0'}, {'id': 'v3.0'}]}
fake_resp = json.dumps(fake_resp)
self.useFixture(mockpatch.PatchObject(
verify_tempest_config.RAW_HTTP, 'request',
return_value=(None, fake_resp)))
fake_os = mock.MagicMock()
versions = verify_tempest_config._get_api_versions(fake_os, 'nova')
self.assertIn('v2.0', versions)
self.assertIn('v3.0', versions)
def test_verify_nova_versions(self):
self.useFixture(mockpatch.PatchObject(
verify_tempest_config, '_get_unversioned_endpoint',
return_value='http://fake_endpoint:5000'))
fake_resp = {'versions': [{'id': 'v2.0'}]}
fake_resp = json.dumps(fake_resp)
self.useFixture(mockpatch.PatchObject(
verify_tempest_config.RAW_HTTP, 'request',
return_value=(None, fake_resp)))
fake_os = mock.MagicMock()
with mock.patch.object(verify_tempest_config,
'print_and_or_update') as print_mock:
verify_tempest_config.verify_nova_api_versions(fake_os, True)
print_mock.assert_called_once_with('api_v3', 'compute_feature_enabled',
False, True)
def _mock_list_role(self):
roles_fix = self.useFixture(mockpatch.PatchObject(
json_iden_client.IdentityClientJSON,
'list_roles',
return_value=(service_client.ResponseBodyList
(200, [{'id': '1', 'name': 'FakeRole'}]))))
return roles_fix
def _mock_assign_user_role(self):
tenant_fix = self.useFixture(
mockpatch.PatchObject(json_iden_client.IdentityClientJSON,
'assign_user_role',
return_value=(service_client.ResponseBody(
200, {}))))
return tenant_fix
def test_auth_data_property_when_cache_exists(self):
self.auth_provider.cache = 'foo'
self.useFixture(
mockpatch.PatchObject(self.auth_provider,
'is_expired',
return_value=False))
self.assertEqual('foo', getattr(self.auth_provider, 'auth_data'))
def _mock_tenant_create(self, id, name):
tenant_fix = self.useFixture(mockpatch.PatchObject(
json_iden_client.IdentityClientJSON,
'create_tenant',
return_value=({'status': 200},
{'id': id, 'name': name})))
return tenant_fix
def _mock_router_create(self, id, name):
router_fix = self.useFixture(mockpatch.PatchObject(
json_network_client.NetworkClientJSON,
'create_router',
return_value=({'status': 200},
{'router': {'id': id, 'name': name}})))
return router_fix
def _mock_subnet_create(self, iso_creds, id, name):
subnet_fix = self.useFixture(mockpatch.PatchObject(
iso_creds.network_admin_client,
'create_subnet',
return_value=({'status': 200},
{'subnet': {'id': id, 'name': name}})))
return subnet_fix
def _mock_list_role(self):
roles_fix = self.useFixture(mockpatch.PatchObject(
json_iden_client.IdentityClientJSON,
'list_roles',
return_value=({'status': 200},
[{'id': '1', 'name': 'FakeRole'}])))
return roles_fix
def _mock_assign_user_role(self):
tenant_fix = self.useFixture(mockpatch.PatchObject(
json_iden_client.IdentityClientJSON,
'assign_user_role',
return_value=({'status': 200},
{})))
return tenant_fix
def test_head(self):
self.useFixture(
mockpatch.PatchObject(self.negative_rest_client,
'response_checker'))
__, return_dict = self.negative_rest_client.send_request(
'HEAD', self.url, [])
self.assertEqual('HEAD', return_dict['method'])
def setUp(self):
self.fake_http = fake_http.fake_httplib2()
super(TestNegativeRestClient, self).setUp()
self.negative_rest_client = rest_client.NegativeRestClient(
fake_auth_provider.FakeAuthProvider())
self.useFixture(
mockpatch.PatchObject(self.negative_rest_client, '_log_request'))
def test_verify_extensions_swift(self):
def fake_list_extensions():
return (None, {
'fake1': 'metadata',
'fake2': 'metadata',
'not_fake': 'metadata',
'swift': 'metadata'
})
fake_os = mock.MagicMock()
fake_os.account_client.list_extensions = fake_list_extensions
self.useFixture(
mockpatch.PatchObject(verify_tempest_config,
'get_enabled_extensions',
return_value=(['fake1', 'fake2', 'fake3'])))
results = verify_tempest_config.verify_extensions(fake_os, 'swift', {})
self.assertIn('swift', results)
self.assertIn('fake1', results['swift'])
self.assertTrue(results['swift']['fake1'])
self.assertIn('fake2', results['swift'])
self.assertTrue(results['swift']['fake2'])
self.assertIn('fake3', results['swift'])
self.assertFalse(results['swift']['fake3'])
self.assertIn('not_fake', results['swift'])
self.assertFalse(results['swift']['not_fake'])
def _mock_tenant_create(self, id, name):
tenant_fix = self.useFixture(mockpatch.PatchObject(
json_iden_client.IdentityClientJSON,
'create_tenant',
return_value=(service_client.ResponseBody
(200, {'id': id, 'name': name}))))
return tenant_fix
def test_verify_extensions_nova_v3(self):
def fake_list_extensions():
return (None, {
'extensions': [{
'alias': 'fake1'
}, {
'alias': 'fake2'
}, {
'alias': 'not_fake'
}]
})
fake_os = mock.MagicMock()
fake_os.extensions_v3_client.list_extensions = fake_list_extensions
self.useFixture(
mockpatch.PatchObject(verify_tempest_config,
'get_enabled_extensions',
return_value=(['fake1', 'fake2', 'fake3'])))
results = verify_tempest_config.verify_extensions(
fake_os, 'nova_v3', {})
self.assertIn('nova_v3', results)
self.assertIn('fake1', results['nova_v3'])
self.assertTrue(results['nova_v3']['fake1'])
self.assertIn('fake2', results['nova_v3'])
self.assertTrue(results['nova_v3']['fake2'])
self.assertIn('fake3', results['nova_v3'])
self.assertFalse(results['nova_v3']['fake3'])
self.assertIn('not_fake', results['nova_v3'])
self.assertFalse(results['nova_v3']['not_fake'])
def test_json_request_socket_timeout(self):
self.useFixture(
mockpatch.PatchObject(httplib.HTTPConnection,
'request',
side_effect=socket.timeout()))
self.assertRaises(exceptions.TimeoutException,
self.client.json_request, 'GET', '/images')
def test_json_request_endpoint_not_found(self):
self.useFixture(
mockpatch.PatchObject(httplib.HTTPConnection,
'request',
side_effect=socket.gaierror()))
self.assertRaises(exceptions.EndpointNotFound,
self.client.json_request, 'GET', '/images')
def test_network_admin_creation(self, MockRestClient):
iso_creds = isolated_creds.IsolatedCreds('test class',
password='******')
self._mock_user_create('1234', 'fake_admin_user')
self._mock_tenant_create('1234', 'fake_admin_tenant')
self._mock_network_create(iso_creds, '1234', 'fake_admin_net')
self._mock_subnet_create(iso_creds, '1234', 'fake_admin_subnet')
self._mock_router_create('1234', 'fake_admin_router')
router_interface_mock = self.patch(
'tempest.services.network.json.network_client.NetworkClientJSON.'
'add_router_interface_with_subnet_id')
self.useFixture(
mockpatch.PatchObject(json_iden_client.IdentityClientJSON,
'list_roles',
return_value=({
'status': 200
}, [{
'id': '123456',
'name': 'admin'
}])))
with mock.patch.object(json_iden_client.IdentityClientJSON,
'assign_user_role'):
iso_creds.get_admin_creds()
router_interface_mock.called_once_with('1234', '1234')
network = iso_creds.get_admin_network()
subnet = iso_creds.get_admin_subnet()
router = iso_creds.get_admin_router()
self.assertEqual(network['id'], '1234')
self.assertEqual(network['name'], 'fake_admin_net')
self.assertEqual(subnet['id'], '1234')
self.assertEqual(subnet['name'], 'fake_admin_subnet')
self.assertEqual(router['id'], '1234')
self.assertEqual(router['name'], 'fake_admin_router')
def test_get_connection_url_not_fount(self):
self.useFixture(
mockpatch.PatchObject(self.client,
'connection_class',
side_effect=httplib.InvalidURL()))
self.assertRaises(exceptions.EndpointNotFound,
self.client.get_connection)
def test_admin_creds(self, MockRestClient):
cfg.CONF.set_default('neutron', False, 'service_available')
iso_creds = isolated_creds.IsolatedCreds('test class',
password='******')
self._mock_user_create('1234', 'fake_admin_user')
self._mock_tenant_create('1234', 'fake_admin_tenant')
self.useFixture(
mockpatch.PatchObject(json_iden_client.IdentityClientJSON,
'list_roles',
return_value=({
'status': 200
}, [{
'id': '1234',
'name': 'admin'
}])))
user_mock = mock.patch.object(json_iden_client.IdentityClientJSON,
'assign_user_role')
user_mock.start()
self.addCleanup(user_mock.stop)
with mock.patch.object(json_iden_client.IdentityClientJSON,
'assign_user_role') as user_mock:
admin_creds = iso_creds.get_admin_creds()
user_mock.assert_called_once_with('1234', '1234', '1234')
self.assertEqual(admin_creds.username, 'fake_admin_user')
self.assertEqual(admin_creds.tenant_name, 'fake_admin_tenant')
# Verify IDs
self.assertEqual(admin_creds.tenant_id, '1234')
self.assertEqual(admin_creds.user_id, '1234')
def test_log_ip_ns_debug_enabled(self):
self.useFixture(mockpatch.PatchObject(test.CONF.debug,
'enable', True))
self.ip_ns_list_mock.return_value = [1, 2]
debug.log_ip_ns()
self.ip_addr_raw_mock.assert_called_with()
self.assertTrue(self.log_mock.info.called)
self.ip_route_raw_mock.assert_called_with()
self.assertEqual(len(debug.TABLES), self.iptables_raw_mock.call_count)
for table in debug.TABLES:
self.assertIn(mock.call(table),
self.iptables_raw_mock.call_args_list)
self.ip_ns_list_mock.assert_called_with()
self.assertEqual(len(self.ip_ns_list_mock.return_value),
self.ip_ns_addr_mock.call_count)
self.assertEqual(len(self.ip_ns_list_mock.return_value),
self.ip_ns_route_mock.call_count)
for ns in self.ip_ns_list_mock.return_value:
self.assertIn(mock.call(ns),
self.ip_ns_addr_mock.call_args_list)
self.assertIn(mock.call(ns),
self.ip_ns_route_mock.call_args_list)
self.assertEqual(len(debug.TABLES) *
len(self.ip_ns_list_mock.return_value),
self.iptables_ns_mock.call_count)
for ns in self.ip_ns_list_mock.return_value:
for table in debug.TABLES:
self.assertIn(mock.call(ns, table),
self.iptables_ns_mock.call_args_list)
def test_json_request_fails_to_json_loads(self):
self._set_response_fixture({'content-type': 'application/json'}, 200,
'fake_response_body')
self.useFixture(
mockpatch.PatchObject(json, 'loads', side_effect=ValueError()))
resp, body = self.client.json_request('GET', '/images')
self.assertEqual(200, resp.status)
self.assertEqual(body, 'fake_response_body')
def test_official_client(self):
self.useFixture(mockpatch.PatchObject(keystoneclient.Client,
'authenticate'))
self.useFixture(mockpatch.PatchObject(clients.OfficialClientManager,
'_get_image_client'))
self.useFixture(mockpatch.PatchObject(clients.OfficialClientManager,
'_get_object_storage_client'))
self.useFixture(mockpatch.PatchObject(clients.OfficialClientManager,
'_get_orchestration_client'))
self.useFixture(mockpatch.PatchObject(clients.OfficialClientManager,
'_get_ceilometer_client'))
iso_creds = isolated_creds.IsolatedCreds('test class',
tempest_client=False)
self.assertTrue(isinstance(iso_creds.identity_admin_client,
keystoneclient.Client))
self.assertTrue(isinstance(iso_creds.network_admin_client,
neutronclient.Client))
def _set_response_fixture(self, header, status, resp_body):
resp = fake_http.fake_httplib(header,
status=status,
body=six.StringIO(resp_body))
self.useFixture(
mockpatch.PatchObject(httplib.HTTPConnection,
'getresponse',
return_value=resp))
return resp
def test_official_client(self):
self.useFixture(
mockpatch.PatchObject(keystoneclient.Client, 'authenticate'))
iso_creds = isolated_creds.IsolatedCreds('test class',
tempest_client=False)
self.assertTrue(
isinstance(iso_creds.identity_admin_client, keystoneclient.Client))
self.assertTrue(
isinstance(iso_creds.network_admin_client, neutronclient.Client))
def test_get_boot_time(self):
booted_at = 10000
uptime_sec = 5000.02
self.ssh_mock.mock.exec_command.return_value = uptime_sec
self.useFixture(
mockpatch.PatchObject(time,
'time',
return_value=booted_at + uptime_sec))
self.assertEqual(self.conn.get_boot_time(), time.localtime(booted_at))
self._assert_exec_called_with('cut -f1 -d. /proc/uptime')
def _mock_network_create(self, iso_creds, id, name):
net_fix = self.useFixture(
mockpatch.PatchObject(
iso_creds.network_admin_client,
'create_network',
return_value={'network': {
'id': id,
'name': name
}}))
return net_fix
