def test_index_with_keystone_can_edit_group_false(self):
api.keystone.group_list(IgnoreArg()).AndReturn(self.groups.list())
api.keystone.keystone_can_edit_group() \
.MultipleTimes().AndReturn(False)
self.mox.ReplayAll()
res = self.client.get(GROUPS_INDEX_URL)
self.assertTemplateUsed(res, GROUPS_INDEX_VIEW_TEMPLATE)
self.assertItemsEqual(res.context['table'].data, self.groups.list())
self.assertNotContains(res, 'Create Group')
self.assertNotContains(res, 'Edit')
self.assertNotContains(res, 'Delete Group')
def test_create_volume_from_snapshot(self):
"""Tests volume creation from snapshot"""
drv = self._driver
mox = self.mox
volume = FakeVolume(1)
snapshot = FakeSnapshot(2)
self.assertRaises(exception.NovaException,
drv.create_volume_from_snapshot, volume, snapshot)
snapshot = FakeSnapshot(1)
location = '127.0.0.1:/nfs'
expected_result = {'provider_location': location}
mox.StubOutWithMock(drv, '_clone_volume')
mox.StubOutWithMock(drv, '_get_volume_location')
drv._clone_volume(IgnoreArg(), IgnoreArg(), IgnoreArg())
drv._get_volume_location(IgnoreArg()).AndReturn(location)
mox.ReplayAll()
loc = drv.create_volume_from_snapshot(volume, snapshot)
self.assertEquals(loc, expected_result)
def test_create_table_no_range(self):
self.storage_mocker.StubOutWithMock(storage, 'create_table')
storage.create_table(IgnoreArg(), IgnoreArg(), IgnoreArg()).AndReturn(
models.TableMeta(
'00000000-0000-0000-0000-000000000000',
models.TableSchema(
{
'hash': models.AttributeType('N'),
'indexed_field': models.AttributeType('S')
}, ['hash'], {
"index_name":
models.IndexDefinition('hash', 'indexed_field')
}), models.TableMeta.TABLE_STATUS_ACTIVE, None))
self.storage_mocker.ReplayAll()
Table.create("test",
schema=[
fields.HashKey('hash', data_type=schema_types.NUMBER),
],
throughput={
'read': 20,
'write': 10,
},
indexes=[
fields.KeysOnlyIndex(
'index_name',
parts=[
fields.HashKey('hash',
data_type=schema_types.NUMBER),
fields.RangeKey('indexed_field',
data_type=schema_types.STRING)
])
],
connection=self.DYNAMODB_CON)
self.storage_mocker.VerifyAll()
def test_delete_table(self):
self.storage_mocker.StubOutWithMock(storage, 'delete_table')
self.storage_mocker.StubOutWithMock(storage, 'describe_table')
storage.delete_table(IgnoreArg(), 'test_table')
storage.describe_table(IgnoreArg(), 'test_table').AndReturn(
models.TableMeta(
'00000000-0000-0000-0000-000000000000',
models.TableSchema(
{
'city1': models.AttributeType('S'),
'id': models.AttributeType('S'),
'name': models.AttributeType('S')
}, ['id', 'name'],
{'index_name': models.IndexDefinition('id', 'city1')}),
models.TableMeta.TABLE_STATUS_ACTIVE, None))
self.storage_mocker.ReplayAll()
table = Table('test_table', connection=self.DYNAMODB_CON)
self.assertTrue(table.delete())
self.storage_mocker.VerifyAll()
def test_enable_disable_user_exception(self):
OTHER_USER_ID = '5'
formData = {'action': 'users__enable__%s' % OTHER_USER_ID}
self.mox.StubOutWithMock(api.keystone, 'user_update_enabled')
api_exception = api_exceptions.ApiException('apiException',
message='apiException')
api.keystone.user_update_enabled(IgnoreArg(), OTHER_USER_ID, True) \
.AndRaise(api_exception)
self.mox.ReplayAll()
res = self.client.post(USERS_INDEX_URL, formData)
self.assertRedirects(res, USERS_INDEX_URL)
def test_add_user(self):
group = self.groups.get(id="1")
user = self.users.get(id="2")
api.keystone.group_get(IsA(http.HttpRequest), group.id).\
AndReturn(group)
api.keystone.user_list(IgnoreArg(),
domain=group.domain_id).\
AndReturn(self.users.list())
api.keystone.user_list(IgnoreArg(),
group=group.id).\
AndReturn(self.users.list()[2:])
api.keystone.add_group_user(IgnoreArg(),
group_id=group.id,
user_id=user.id)
self.mox.ReplayAll()
formData = {'action': 'group_non_members__addMember__%s' % user.id}
res = self.client.post(GROUP_ADD_MEMBER_URL, formData)
self.assertRedirectsNoFollow(res, GROUP_MANAGE_URL)
self.assertMessageCount(success=1)
def test_post_with_user(self):
moxer = Mox()
request, response = new_mock_request_response(moxer)
moxer.StubOutWithMock(users, "get_current_user", use_mock_anything=True)
# moxer.StubOutWithMock(ArtifactInfo, "delete_oldest_by_source", use_mock_anything=True)
moxer.StubOutWithMock(ArtifactContent, "delete_oldest_by_source")
moxer.StubOutWithMock(Counters, "source_counter")
moxer.StubOutWithMock(Feed, "get_by_source_name", use_mock_anything=True)
moxer.StubOutWithMock(model, "ingest_feed_entries")
source_name = "hi"
username = Services.API_USER
user = MockEntity(key_name=username, email=lambda: username)
users.get_current_user().AndReturn(user)
handler = IngestHandler()
users.get_current_user().AndReturn(user)
handler.initialize(request, response)
request.get("keep").AndReturn(None)
counter = moxer.CreateMock(Counter)
Counters.source_counter(source_name).AndReturn(counter)
counter.decrement(IgnoreArg())
source = MockEntity(key_name=source_name, name=source_name)
feed = MockEntity(key_name=source_name, url="no", artifact_source=source)
# ArtifactInfo.delete_oldest_by_source(source, IgnoreArg()).AndReturn([])
ArtifactContent.delete_oldest_by_source(source, IgnoreArg(), pre_call=IgnoreArg()).AndReturn([])
Feed.get_by_source_name(source_name, return_none=True).AndReturn(feed)
model.ingest_feed_entries(feed, user, error_call=IgnoreArg()).AndReturn(())
moxer.ReplayAll()
handler.post(source_name)
moxer.VerifyAll()
def _prepare_clone_mock(self, status):
drv = self._driver
mox = self.mox
volume = FakeVolume()
setattr(volume, 'provider_location', '127.0.0.1:/nfs')
drv._client = MockObject(suds.client.Client)
drv._client.factory = MockObject(suds.client.Factory)
drv._client.service = MockObject(suds.client.ServiceSelector)
# ApiProxy() method is generated by ServiceSelector at runtime from the
# XML, so mocking is impossible.
setattr(
drv._client.service, 'ApiProxy',
types.MethodType(lambda *args, **kwargs: FakeResponce(status),
suds.client.ServiceSelector))
mox.StubOutWithMock(drv, '_get_host_id')
mox.StubOutWithMock(drv, '_get_full_export_path')
drv._get_host_id(IgnoreArg()).AndReturn('10')
drv._get_full_export_path(IgnoreArg(), IgnoreArg()).AndReturn('/nfs')
return mox
def test_create_with_password_mismatch(self):
user = self.users.get(id="1")
api.keystone.tenant_list(IgnoreArg(), user=None) \
.AndReturn([self.tenants.list(), False])
api.keystone.role_list(IgnoreArg()).AndReturn(self.roles.list())
api.keystone.get_default_role(IgnoreArg()) \
.AndReturn(self.roles.first())
self.mox.ReplayAll()
formData = {
'method': 'CreateUserForm',
'name': user.name,
'email': user.email,
'password': user.password,
'project': self.tenant.id,
'role_id': self.roles.first().id,
'confirm_password': "******"
}
res = self.client.post(USER_CREATE_URL, formData)
self.assertFormError(res, "form", None, ['Passwords do not match.'])
def test_manage(self):
group = self.groups.get(id="1")
group_members = self.users.list()
api.keystone.group_get(IsA(http.HttpRequest), group.id).\
AndReturn(group)
api.keystone.user_list(IgnoreArg(),
group=group.id).\
AndReturn(group_members)
self.mox.ReplayAll()
res = self.client.get(GROUP_MANAGE_URL)
self.assertTemplateUsed(res, constants.GROUPS_MANAGE_VIEW_TEMPLATE)
self.assertItemsEqual(res.context['table'].data, group_members)
def test_delete_user_with_improper_permissions(self):
domain_id = self._get_domain_id()
users = self._get_users(domain_id)
for i in range(0, 2):
api.keystone.user_list(IgnoreArg(), domain=domain_id) \
.AndReturn(users)
self.mox.ReplayAll()
formData = {'action': 'users__delete__%s' % self.request.user.id}
res = self.client.post(USERS_INDEX_URL, formData, follow=True)
self.assertEqual(list(res.context['messages'])[0].message,
u'You do not have permission to delete user: %s'
% self.request.user.username)
def test_modify_users(self):
self.mox.StubOutWithMock(api.keystone, 'tenant_get')
self.mox.StubOutWithMock(api.keystone, 'user_list')
api.keystone.tenant_get(IgnoreArg(), self.tenant.id, admin=True) \
.AndReturn(self.tenant)
api.keystone.user_list(IsA(http.HttpRequest)) \
.AndReturn(self.users.list())
api.keystone.user_list(IsA(http.HttpRequest), self.tenant.id) \
.AndReturn([self.user])
self.mox.ReplayAll()
url = reverse('horizon:syspanel:projects:users',
args=(self.tenant.id,))
res = self.client.get(url)
self.assertEqual(res.status_code, 200)
self.assertTemplateUsed(res, 'syspanel/projects/users.html')
def test_index(self):
domain = self._get_default_domain()
domain_id = domain.id
users = self._get_users(domain_id)
api.keystone.user_list(IgnoreArg(),
domain=domain_id).AndReturn(users)
self.mox.ReplayAll()
res = self.client.get(USERS_INDEX_URL)
self.assertTemplateUsed(res, 'identity/users/index.html')
self.assertItemsEqual(res.context['table'].data, users)
if domain_id:
for user in res.context['table'].data:
self.assertItemsEqual(user.domain_id, domain_id)
def _prepare_clone_mock(self, status):
drv = self._driver
mox = self.mox
volume = FakeVolume()
setattr(volume, 'provider_location', '127.0.0.1:/nfs')
mox.StubOutWithMock(drv, '_get_export_path')
mox.StubOutWithMock(drv, '_get_actual_path_for_export')
mox.StubOutWithMock(drv, '_start_clone')
mox.StubOutWithMock(drv, '_wait_for_clone_finish')
if status == 'fail':
mox.StubOutWithMock(drv, '_clear_clone')
drv._get_export_path(IgnoreArg()).AndReturn('/nfs')
drv._get_actual_path_for_export(IgnoreArg()).AndReturn('/vol/vol1/nfs')
drv._start_clone(IgnoreArg(), IgnoreArg()).AndReturn(('1', '2'))
if status == 'fail':
drv._wait_for_clone_finish('1', '2').AndRaise(
api.NaApiError('error', 'error'))
drv._clear_clone('1')
else:
drv._wait_for_clone_finish('1', '2')
return mox
def test_attempt_delivery_permanentrelayerror(self):
task = self.mox.CreateMockAnything()
subtask = self.mox.CreateMockAnything()
result = self.mox.CreateMockAnything()
result.id = '12345'
self.relay.attempt(self.env, 0).AndRaise(PermanentRelayError('permanent', Reply('550', 'permanent error')))
self.celery.task(IgnoreArg()).AndReturn(task)
task.s(self.bounce, 0).AndReturn(subtask)
subtask.apply_async().AndReturn(result)
self.mox.ReplayAll()
def return_bounce(envelope, reply):
self.assertEqual(self.env, envelope)
return self.bounce
queue = CeleryQueue(self.celery, self.relay, bounce_factory=return_bounce)
queue.attempt_delivery(self.env, 0)
def test_disabling_current_user(self):
domain_id = self._get_domain_id()
users = self._get_users(domain_id)
for i in range(0, 2):
api.keystone.user_list(IgnoreArg(), domain=domain_id) \
.AndReturn(users)
self.mox.ReplayAll()
formData = {'action': 'users__toggle__%s' % self.request.user.id}
res = self.client.post(USERS_INDEX_URL, formData, follow=True)
self.assertEqual(list(res.context['messages'])[0].message,
u'You cannot disable the user you are currently '
u'logged in as.')
def test_terminate_instance(self):
self.mox.StubOutWithMock(api, 'server_list')
self.mox.StubOutWithMock(api, 'flavor_list')
self.mox.StubOutWithMock(api, 'server_delete')
api.server_list(IsA(http.HttpRequest)).AndReturn(self.servers)
api.flavor_list(IgnoreArg()).AndReturn(self.flavors)
api.server_delete(IsA(http.HttpRequest), self.servers[0].id)
self.mox.ReplayAll()
formData = {'action': 'instances__terminate__%s' % self.servers[0].id}
res = self.client.post(INDEX_URL, formData)
self.assertRedirectsNoFollow(res, INDEX_URL)
def test_index_with_keystone_can_edit_role_false(self):
role = self.roles.first()
api.keystone.role_list(IgnoreArg()).AndReturn(self.roles.list())
api.keystone.keystone_can_edit_role() \
.MultipleTimes().AndReturn(False)
self.mox.ReplayAll()
res = self.client.get(ROLES_INDEX_URL)
self.assertNotContains(res, 'Create Role')
self.assertNotContains(res, 'Edit')
self.assertNotContains(res, 'Delete Role')
self.assertTemplateUsed(res, 'admin/roles/index.html')
self.assertItemsEqual(res.context['table'].data, self.roles.list())
def test_create_container_post(self):
formData = {'name': 'containerName', 'method': 'CreateContainer'}
self.mox.StubOutWithMock(api, 'swift_create_container')
api.swift_create_container(IsA(http.HttpRequest), 'CreateContainer')
self.mox.StubOutWithMock(messages, 'success')
messages.success(IgnoreArg(), IsA(str))
res = self.client.post(
reverse('dash_containers_create',
args=[self.request.user.tenant_id]), formData)
self.assertRedirectsNoFollow(
res, reverse('dash_containers',
args=[self.request.user.tenant_id]))
def test_port_detach(self):
self.mox.StubOutWithMock(api, "quantum_detach_port")
api.quantum_detach_port(IsA(http.HttpRequest),
'n1', 'p1').AndReturn(True)
formData = {'port': 'p1',
'network': 'n1',
'method': 'DetachPort'}
self.mox.StubOutWithMock(messages, 'success')
messages.success(IgnoreArg(), IsA(basestring))
self.mox.ReplayAll()
res = self.client.post(reverse('horizon:nova:networks:detail',
args=["n1"]),
formData)
def test_attempt_delivery_transientrelayerror(self):
task = self.mox.CreateMockAnything()
subtask = self.mox.CreateMockAnything()
result = self.mox.CreateMockAnything()
result.id = '12345'
self.relay.attempt(self.env, 0).AndRaise(TransientRelayError('transient', Reply('450', 'transient error')))
self.celery.task(IgnoreArg()).AndReturn(task)
task.s(self.env, 1).AndReturn(subtask)
subtask.set(countdown=60)
subtask.apply_async().AndReturn(result)
self.mox.ReplayAll()
def backoff(envelope, attempts):
self.assertEqual(self.env, envelope)
self.assertEqual(1, attempts)
return 60
queue = CeleryQueue(self.celery, self.relay, backoff=backoff)
queue.attempt_delivery(self.env, 0)
def test_delete_container_invalid(self):
formData = {'method': 'DeleteContainer'}
self.mox.StubOutWithMock(messages, 'error')
messages.error(IgnoreArg(), IsA(str))
self.mox.ReplayAll()
res = self.client.post(reverse('dash_containers', args=['tenant']),
formData)
#self.assertRedirectsNoFollow(res, reverse('dash_containers',
# args=['tenant']))
self.mox.VerifyAll()
self.mox.UnsetStubs()
def test_disable_user(self):
OTHER_USER = '******'
formData = {
'method': 'UserEnableDisableForm',
'id': OTHER_USER,
'enabled': 'disable'
}
self.mox.StubOutWithMock(api, 'user_update_enabled')
api.user_update_enabled(IgnoreArg(), OTHER_USER,
False).AndReturn(self.mox.CreateMock(api.User))
self.mox.ReplayAll()
res = self.client.post(USERS_INDEX_URL, formData)
self.assertRedirectsNoFollow(res, USERS_INDEX_URL)
def test_instance_vnc(self):
server = self.servers.first()
CONSOLE_OUTPUT = '/vncserver'
console_mock = self.mox.CreateMock(api.VNCConsole)
console_mock.url = CONSOLE_OUTPUT
self.mox.StubOutWithMock(api, 'server_vnc_console')
self.mox.StubOutWithMock(api, 'server_get')
api.server_get(IsA(http.HttpRequest), server.id).AndReturn(server)
api.server_vnc_console(IgnoreArg(), server.id).AndReturn(console_mock)
self.mox.ReplayAll()
url = reverse('horizon:project:instances:vnc', args=[server.id])
res = self.client.get(url)
redirect = CONSOLE_OUTPUT + '&title=%s(1)' % server.name
self.assertRedirectsNoFollow(res, redirect)
def test_container_meta_remove_invalid(self):
formData = {
'container_name': 'containerName',
'method': 'ContainerMetaRemove',
'header_name': 'x-invalid-meta-test'
}
self.mox.StubOutWithMock(messages, 'error')
self.mox.StubOutWithMock(api, 'swift_set_container_info')
messages.error(IsA(http.HttpRequest), IgnoreArg())
self.mox.ReplayAll()
res = self.client.post(
reverse('dash_containers_meta',
args=[self.request.user.tenant_id, self.container.name]),
formData)
self.mox.VerifyAll()
self.mox.UnsetStubs()
def test_http_request_error_code_cases(mox, response, exception_caught,
prefix):
"""Test the cases in which http_request throws an exception as a result of receiving an error status."""
creds = Credentials({'url': 'https://example.com', 'token': 'ABCDEFGH'})
conn = Connection(creds)
mox.StubOutWithMock(conn.session, 'request')
conn.session.request('GET',
'https://example.com/path',
headers=IgnoreArg(),
verify=True,
proxies=conn.proxies,
timeout=conn._timeout).AndReturn(response)
mox.ReplayAll()
with pytest.raises(exception_caught) as excinfo:
conn.http_request('get', '/path')
assert excinfo.value.message.startswith(prefix)
mox.VerifyAll()
def test_port_create(self):
self.mox.StubOutWithMock(api, "quantum_create_port")
api.quantum_create_port(IsA(http.HttpRequest), 'n1').AndReturn(True)
formData = {'ports_num': 1, 'network': 'n1', 'method': 'CreatePort'}
self.mox.StubOutWithMock(messages, 'success')
messages.success(IgnoreArg(), IsA(str))
res = self.client.post(
reverse('dash_ports_create', args=[self.request.user.tenant,
"n1"]), formData)
self.assertRedirectsNoFollow(
res,
reverse('dash_networks_detail',
args=[self.request.user.tenant, "n1"]))
def test_do_setup(self):
mox = self._mox
drv = self._driver
mox.StubOutWithMock(drv, 'check_for_setup_error')
mox.StubOutWithMock(drv, '_get_client')
mox.StubOutWithMock(drv, '_do_custom_setup')
drv.check_for_setup_error()
drv._get_client()
drv._do_custom_setup(IgnoreArg())
mox.ReplayAll()
drv.do_setup(IsA(context.RequestContext))
mox.VerifyAll()
def test_http_request_exception_cases(mox, exception_raised, exception_caught,
prefix):
"""Test the cases in which the underlying session object throws an exception as a result of a request."""
creds = Credentials({'url': 'https://example.com', 'token': 'ABCDEFGH'})
conn = Connection(creds)
mox.StubOutWithMock(conn.session, 'request')
conn.session.request('GET',
'https://example.com/path',
headers=IgnoreArg(),
verify=True,
proxies=conn.proxies,
timeout=conn._timeout).AndRaise(exception_raised)
mox.ReplayAll()
with pytest.raises(exception_caught) as excinfo:
conn.http_request('get', '/path')
if prefix:
assert excinfo.value.message.startswith(prefix)
mox.VerifyAll()
def test_update_user_with_passwords_not_matching(self):
api.user_get(IsA(http.HttpRequest), '1',
admin=True).AndReturn(self.user)
api.tenant_list(IgnoreArg(), admin=True).AndReturn(self.tenants.list())
self.mox.ReplayAll()
self.selenium.get("%s%s" % (self.live_server_url, USER_UPDATE_URL))
body = self.selenium.find_element_by_tag_name("body")
self.assertFalse(
"Passwords do not match" in body.text,
"Error message should not be visible at loading time")
self.selenium.find_element_by_id("id_password").send_keys("test")
self.selenium.find_element_by_id("id_confirm_password").send_keys("te")
self.selenium.find_element_by_id("id_email").clear()
body = self.selenium.find_element_by_tag_name("body")
self.assertTrue("Passwords do not match" in body.text,
"Error message not found in body")
