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")