def test_head_update_headers(self):
self.useFixture(
mockpatch.PatchObject(self.rest_client, 'response_checker'))
__, return_dict = self.rest_client.head(self.url,
extra_headers=True,
headers=self.headers)
self.assertDictContainsSubset(
{
'X-Configuration-Session': 'session_id',
'Content-Type': 'application/json',
'Accept': 'application/json'
}, return_dict['headers'])
def setUp(self):
super(TestEventEndpoint, self).setUp()
self.CONF = self.useFixture(fixture_config.Config()).conf
self.CONF([])
self.CONF.set_override("connection", "log://", group='database')
self.CONF.set_override("store_events", True, group="notification")
self.setup_messaging(self.CONF)
self.useFixture(mockpatch.PatchObject(publisher, 'get_publisher',
side_effect=self.get_publisher))
self.fake_publisher = mock.Mock()
self.useFixture(mockpatch.Patch(
'ceilometer.publisher.test.TestPublisher',
return_value=self.fake_publisher))
def test_create_secgroup(self):
self.useFixture(mockpatch.PatchObject(javelin, "client_for_user",
return_value=self.fake_client))
self.fake_client.secgroups.list_security_groups.return_value = (
{'security_groups': []})
self.fake_client.secgroups.create_security_group.return_value = \
{'security_group': {'id': self.fake_object['secgroup_id']}}
javelin.create_secgroups([self.fake_object])
mocked_function = self.fake_client.secgroups.create_security_group
mocked_function.assert_called_once_with(
name=self.fake_object['name'],
description=self.fake_object['description'])
def _mock_list_ec2_credentials(self, user_id, tenant_id):
ec2_creds_fix = self.useFixture(
mockpatch.PatchObject(
json_iden_client.IdentityClientJSON,
'list_user_ec2_credentials',
return_value=(service_client.ResponseBodyList(
200, [{
'access': 'fake_access',
'secret': 'fake_secret',
'tenant_id': tenant_id,
'user_id': user_id,
'trust_id': None
}]))))
return ec2_creds_fix
def test_hardware_discover_fail_minimize_logs(self, novalog, baselog):
self.useFixture(
mockpatch.PatchObject(novaclient.HTTPClient,
'authenticate',
side_effect=requests.ConnectionError))
class PollsterHardware(agentbase.TestPollster):
discovery = 'tripleo_overcloud_nodes'
class PollsterHardwareAnother(agentbase.TestPollster):
discovery = 'tripleo_overcloud_nodes'
self.mgr.extensions.extend([
extension.Extension(
'testhardware',
None,
None,
PollsterHardware(self.CONF),
),
extension.Extension(
'testhardware2',
None,
None,
PollsterHardwareAnother(self.CONF),
)
])
ext = extension.Extension('tripleo_overcloud_nodes', None, None,
discovery.NodesDiscoveryTripleO(self.CONF))
self.mgr.discoveries = (extension.ExtensionManager.make_test_instance(
[ext]))
self.pipeline_cfg = {
'sources': [{
'name': "test_hardware",
'interval': 10,
'meters': ['testhardware', 'testhardware2'],
'sinks': ['test_sink']
}],
'sinks': [{
'name': 'test_sink',
'transformers': [],
'publishers': ["test"]
}]
}
self.mgr.polling_manager = pipeline.PollingManager(
self.CONF, self.pipeline_cfg)
polling_tasks = self.mgr.setup_polling_tasks()
self.mgr.interval_task(list(polling_tasks.values())[0])
self.assertEqual(1, novalog.exception.call_count)
self.assertFalse(baselog.exception.called)
def test_attach_volumes(self):
self.useFixture(
mockpatch.PatchObject(javelin,
"client_for_user",
return_value=self.fake_client))
self.useFixture(
mockpatch.PatchObject(javelin,
"_get_volume_by_name",
return_value=self.fake_object.volume))
self.useFixture(
mockpatch.PatchObject(javelin,
"_get_server_by_name",
return_value=self.fake_object.server))
javelin.attach_volumes([self.fake_object])
mocked_function = self.fake_client.volumes.attach_volume
mocked_function.assert_called_once_with(
self.fake_object.volume['id'],
instance_uuid=self.fake_object.server['id'],
mountpoint=self.fake_object['device'])
def test_create_user_missing_tenant(self):
self.useFixture(
mockpatch.Patch(
'tempest.common.identity.get_tenant_by_name',
side_effect=lib_exc.NotFound("tenant is not found")))
self.useFixture(
mockpatch.PatchObject(javelin,
"keystone_admin",
return_value=self.fake_client))
javelin.create_users([self.fake_object])
mocked_function = self.fake_client.users.create_user
self.assertFalse(mocked_function.called)
def setUp(self):
super(TestEventEndpoint, self).setUp()
self.CONF = service.prepare_service([], [])
self.CONF.set_override("connection", "log://", group='database')
self.setup_messaging(self.CONF)
self.useFixture(
mockpatch.PatchObject(publisher,
'get_publisher',
side_effect=self.get_publisher))
self.fake_publisher = mock.Mock()
self.useFixture(
mockpatch.Patch('ceilometer.publisher.test.TestPublisher',
return_value=self.fake_publisher))
def setUp(self):
super(FloatingIpTestCase, self).setUp()
self.event_created = floatingip.EVENT_FLOATINGIP_CREATE_END
self.event_resized = floatingip.EVENT_FLOATINGIP_RESIZE_END
self.event_deleted = floatingip.EVENT_FLOATINGIP_DELETE_END
self.floating_ip_address = '2.4.6.8'
self.price_data = self.build_segmented_price_data(
'5.0000', [[10, '0.1'], [4, '0.2'], [0, '0.3']])
self.useFixture(mockpatch.PatchObject(
floatingip.FloatingIpNotificationBase,
'_send_email_notification'))
def setUp(self):
super(TestCase, self).setUp()
self.addCleanup(CONF.reset)
self.config_fixture = self.useFixture(config_fixture.Config(CONF))
self.addCleanup(delattr, self, 'config_fixture')
self.config(self.config_files())
# NOTE(morganfainberg): mock the auth plugin setup to use the config
# fixture which automatically unregisters options when performing
# cleanup.
def mocked_register_auth_plugin_opt(conf, opt):
self.config_fixture.register_opt(opt, group='auth')
self.useFixture(
mockpatch.PatchObject(common_cfg,
'_register_auth_plugin_opt',
new=mocked_register_auth_plugin_opt))
self.config_overrides()
self.useFixture(fixtures.FakeLogger(level=logging.DEBUG))
# NOTE(morganfainberg): This code is a copy from the oslo-incubator
# log module. This is not in a function or otherwise available to use
# without having a CONF object to setup logging. This should help to
# reduce the log size by limiting what we log (similar to how Keystone
# would run under mod_wsgi or eventlet).
for pair in CONF.default_log_levels:
mod, _sep, level_name = pair.partition('=')
logger = logging.getLogger(mod)
logger.setLevel(level_name)
self.useFixture(ksfixtures.Cache())
# Clear the registry of providers so that providers from previous
# tests aren't used.
self.addCleanup(dependency.reset)
self.addCleanup(kvs.INMEMDB.clear)
# Ensure Notification subscriptions and resource types are empty
self.addCleanup(notifications.clear_subscribers)
self.addCleanup(notifications.reset_notifier)
# Reset the auth-plugin registry
self.addCleanup(self.clear_auth_plugin_registry)
self.addCleanup(setattr, controllers, '_VERSIONS', [])
def test_create_images(self):
self.fake_client.images.create_image.return_value = \
self.fake_object['body']
self.useFixture(mockpatch.PatchObject(javelin, "client_for_user",
return_value=self.fake_client))
self.useFixture(mockpatch.PatchObject(javelin, "_get_image_by_name",
return_value=[]))
self.useFixture(mockpatch.PatchObject(javelin, "_resolve_image",
return_value=(None, None)))
with mock.patch('six.moves.builtins.open', mock.mock_open(),
create=True) as open_mock:
javelin.create_images([self.fake_object])
mocked_function = self.fake_client.images.create_image
mocked_function.assert_called_once_with(self.fake_object['name'],
self.fake_object['format'],
self.fake_object['format'])
mocked_function = self.fake_client.images.store_image
fake_image_id = self.fake_object['body'].get('id')
mocked_function.assert_called_once_with(fake_image_id, open_mock())
def test_iter_accounts_cached(self):
# Verify that if a method has already been called, _iter_accounts
# uses the cached version and doesn't call rgw_clinet.
mock_method = mock.Mock()
mock_method.side_effect = AssertionError('should not be called', )
api_method = 'get_%s' % self.pollster.METHOD
with mockpatch.PatchObject(rgw_client, api_method, new=mock_method):
cache = {self.pollster.CACHE_KEY_METHOD: [self.ACCOUNTS[0]]}
data = list(
self.pollster._iter_accounts(mock.Mock(), cache,
ASSIGNED_TENANTS))
self.assertEqual([self.ACCOUNTS[0]], data)
def test_put(self):
put_mock = self.useFixture(mockpatch.PatchObject(
self.client, 'put', autospec=True, return_value=(None, self.body))
).mock
rsrc = self.mgr._put(self.url, self.body, "hello")
put_mock.assert_called_once_with(self.url, body=self.body)
self.assertEqual(rsrc.hi, 1)
put_mock.reset_mock()
rsrc = self.mgr._put(self.url, self.body)
put_mock.assert_called_once_with(self.url, body=self.body)
self.assertEqual(rsrc.hello["hi"], 1)
def _mock_list_roles(self, id, name):
roles_fix = self.useFixture(
mockpatch.PatchObject(
json_iden_client.IdentityClientJSON,
'list_roles',
return_value=(service_client.ResponseBodyList(
200, [{
'id': id,
'name': name
}, {
'id': '1',
'name': 'FakeRole'
}]))))
return roles_fix
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.Patch('tempest.lib.common.http.ClosingHttp.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_cinder_api_versions_no_v1(self, mock_request):
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)
mock_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_cinder_api_versions(fake_os, True)
print_mock.assert_called_once_with('api_v1', 'volume-feature-enabled',
False, True)
def test_destroy_tenants(self):
fake_tenant = self.fake_object['tenant']
fake_auth = self.fake_client
self.useFixture(
mockpatch.Patch('tempest.common.identity.get_tenant_by_name',
return_value=fake_tenant))
self.useFixture(
mockpatch.PatchObject(javelin,
"keystone_admin",
return_value=fake_auth))
javelin.destroy_tenants([fake_tenant])
mocked_function = fake_auth.tenants.delete_tenant
mocked_function.assert_called_once_with(fake_tenant['id'])
def setUp(self):
self.config_fixture = self.useFixture(config_fixture.Config(CONF))
self.config_fixture.register_cli_opt(cli.command_opt)
super(CliNoConfigTestCase, self).setUp()
# NOTE(crinkle): the command call doesn't have to actually work,
# that's what the other unit tests are for. So just mock it out.
class FakeConfCommand(object):
def __init__(self):
self.cmd_class = mock.Mock()
self.useFixture(
mockpatch.PatchObject(CONF, 'command', FakeConfCommand()))
self.logging = self.useFixture(fixtures.FakeLogger(level=logging.WARN))
def _mock_list_role(self):
roles_fix = self.useFixture(
mockpatch.PatchObject(self.roles_client.RolesClient,
'list_roles',
return_value=(rest_client.ResponseBody(
200, {
'roles': [{
'id': '1',
'name': 'FakeRole'
}, {
'id': '2',
'name': 'Member'
}]
}))))
return roles_fix
def test_create_duplicate_tenant(self):
self.fake_client.identity.list_tenants.return_value = {
'tenants': [{
'name': self.fake_object['name']
}]
}
self.useFixture(
mockpatch.PatchObject(javelin,
"keystone_admin",
return_value=self.fake_client))
javelin.create_tenants([self.fake_object['name']])
mocked_function = self.fake_client.identity.create_tenant
self.assertFalse(mocked_function.called)
def _mock_list_ec2_credentials(self, user_id, tenant_id):
ec2_creds_fix = self.useFixture(
mockpatch.PatchObject(json_users_client.UsersClient,
'list_user_ec2_credentials',
return_value=(rest_client.ResponseBody(
200, {
'credentials': [{
'access': 'fake_access',
'secret': 'fake_secret',
'tenant_id': tenant_id,
'user_id': user_id,
'trust_id': None
}]
}))))
return ec2_creds_fix
def setUp(self):
super(TestCase, self).setUp()
self.addCleanup(
self.cleanup_instance('_paths', '_memo', '_overrides',
'_group_overrides', 'maxDiff', 'exit_patch',
'config_fixture', 'logger'))
self._paths = []
def _cleanup_paths():
for path in self._paths:
if path in sys.path:
sys.path.remove(path)
self.addCleanup(_cleanup_paths)
self._memo = {}
self._overrides = []
self._group_overrides = {}
# show complete diffs on failure
self.maxDiff = None
self.addCleanup(CONF.reset)
self.exit_patch = self.useFixture(mockpatch.PatchObject(sys, 'exit'))
self.exit_patch.mock.side_effect = UnexpectedExit
self.config_fixture = self.useFixture(config_fixture.Config(CONF))
self.config(self.config_files())
self.config_overrides()
self.logger = self.useFixture(fixtures.FakeLogger(level=logging.DEBUG))
warnings.filterwarnings('ignore', category=DeprecationWarning)
self.useFixture(ksfixtures.Cache())
# Clear the registry of providers so that providers from previous
# tests aren't used.
self.addCleanup(dependency.reset)
self.addCleanup(kvs.INMEMDB.clear)
# Ensure Notification subscriotions and resource types are empty
self.addCleanup(notifications.clear_subscribers)
self.addCleanup(notifications.reset_notifier)
# Reset the auth-plugin registry
self.addCleanup(self.clear_auth_plugin_registry)
def test__get_creds_by_roles_one_role(self):
test_accounts_class = preprov_creds.PreProvisionedCredentialProvider(
**self.fixed_params)
hashes = test_accounts_class.hash_dict['roles']['role4']
temp_hash = hashes[0]
get_free_hash_mock = self.useFixture(
mockpatch.PatchObject(test_accounts_class,
'_get_free_hash',
return_value=temp_hash))
# Test a single role returns all matching roles
test_accounts_class._get_creds(roles=['role4'])
calls = get_free_hash_mock.mock.mock_calls
self.assertEqual(len(calls), 1)
args = calls[0][1][0]
for i in hashes:
self.assertIn(i, args)
def test_destroy_users(self):
fake_user = self.fake_object['user']
fake_tenant = self.fake_object['tenant']
fake_auth = self.fake_client
fake_auth.identity.get_tenant_by_name.return_value = fake_tenant
fake_auth.identity.get_user_by_username.return_value = fake_user
self.useFixture(mockpatch.PatchObject(javelin, "keystone_admin",
return_value=fake_auth))
javelin.destroy_users([fake_user])
mocked_function = fake_auth.identity.delete_user
mocked_function.assert_called_once_with(fake_user['id'])
def test__get_creds_by_roles_one_role(self):
self.useFixture(mockpatch.Patch(
'tempest.common.accounts.read_accounts_yaml',
return_value=self.test_accounts))
test_accounts_class = accounts.Accounts('v2', 'test_name')
hashes = test_accounts_class.hash_dict['roles']['role4']
temp_hash = hashes[0]
get_free_hash_mock = self.useFixture(mockpatch.PatchObject(
test_accounts_class, '_get_free_hash', return_value=temp_hash))
# Test a single role returns all matching roles
test_accounts_class._get_creds(roles=['role4'])
calls = get_free_hash_mock.mock.mock_calls
self.assertEqual(len(calls), 1)
args = calls[0][1][0]
for i in hashes:
self.assertIn(i, args)
def test_resource_lazy_getattr(self):
# Creating a Client not using session is deprecated.
with self.deprecations.expect_deprecations_here():
self.client = client.Client(token=self.TEST_TOKEN,
auth_url='http://127.0.0.1:5000',
endpoint='http://127.0.0.1:5000')
self.useFixture(mockpatch.PatchObject(
self.client._adapter, 'get', side_effect=AttributeError,
autospec=True))
f = roles.Role(self.client.roles, {'id': 1, 'name': 'Member'})
self.assertEqual(f.name, 'Member')
# Missing stuff still fails after a second get
self.assertRaises(AttributeError, getattr, f, 'blahblah')
def test_verify_extensions_nova_all(self):
def fake_list_extensions():
return ({'extensions': [{'alias': 'fake1'},
{'alias': 'fake2'},
{'alias': 'not_fake'}]})
fake_os = mock.MagicMock()
fake_os.extensions_client.list_extensions = fake_list_extensions
self.useFixture(mockpatch.PatchObject(
verify_tempest_config, 'get_enabled_extensions',
return_value=(['all'])))
results = verify_tempest_config.verify_extensions(fake_os,
'nova', {})
self.assertIn('nova', results)
self.assertIn('extensions', results['nova'])
self.assertEqual(sorted(['fake1', 'fake2', 'not_fake']),
sorted(results['nova']['extensions']))
def test__get_creds_by_roles_list_role(self):
test_accounts_class = preprov_creds.PreProvisionedCredentialProvider(
**self.fixed_params)
hashes = test_accounts_class.hash_dict['roles']['role4']
hashes2 = test_accounts_class.hash_dict['roles']['role2']
hashes = list(set(hashes) & set(hashes2))
temp_hash = hashes[0]
get_free_hash_mock = self.useFixture(mockpatch.PatchObject(
test_accounts_class, '_get_free_hash', return_value=temp_hash))
# Test an intersection of multiple roles
test_accounts_class._get_creds(roles=['role2', 'role4'])
calls = get_free_hash_mock.mock.mock_calls
self.assertEqual(len(calls), 1)
args = calls[0][1][0]
for i in hashes:
self.assertIn(i, args)
def test_resource_lazy_getattr(self):
self.client = client.Client(username=self.TEST_USER,
token=self.TEST_TOKEN,
tenant_name=self.TEST_TENANT_NAME,
auth_url='http://127.0.0.1:5000',
endpoint='http://127.0.0.1:5000')
self.useFixture(mockpatch.PatchObject(
self.client._adapter, 'get', side_effect=AttributeError,
autospec=True))
f = roles.Role(self.client.roles, {'id': 1, 'name': 'Member'})
self.assertEqual(f.name, 'Member')
# Missing stuff still fails after a second get
self.assertRaises(AttributeError, getattr, f, 'blahblah')
def setUp(self):
super(CadfNotificationsWrapperTestCase, self).setUp()
self._notifications = []
def fake_notify(action, initiator, outcome):
note = {
'action': action,
'initiator': initiator,
# NOTE(stevemar): outcome has 2 stages, pending and success
# so we are ignoring it for now.
# 'outcome': outcome,
'send_notification_called': True}
self._notifications.append(note)
self.useFixture(mockpatch.PatchObject(
notifications, '_send_audit_notification', fake_notify))