def setUp(self): super().setUp() self.extras = dict(foo='bar', tao='ching') self.concept = ConceptFactory(extras=self.extras) self.user = UserProfileFactory( organizations=[self.concept.parent.organization]) self.token = self.user.get_token()
def setUp(self): super().setUp() self.user = UserProfileFactory(username='******') self.token = self.user.get_token() self.collection = UserCollectionFactory(mnemonic='coll', user=self.user) self.collection_v1 = UserCollectionFactory(version='v1', mnemonic='coll', user=self.user) self.v1_updated_at = self.collection_v1.updated_at.strftime('%Y%m%d%H%M%S')
class UserLogoViewTest(OCLAPITestCase): def setUp(self): super().setUp() self.user = UserProfileFactory(username='******') self.token = self.user.get_token() @patch('core.common.services.S3.upload_base64') def test_post_200(self, upload_base64_mock): upload_base64_mock.return_value = 'users/username1/logo.png' self.assertIsNone(self.user.logo_url) self.assertIsNone(self.user.logo_path) response = self.client.post(self.user.uri + 'logo/', dict(base64='base64-data'), HTTP_AUTHORIZATION='Token ' + self.token, format='json') self.assertEqual(response.status_code, 200) expected_logo_url = 'http://oclapi2-dev.s3.amazonaws.com/users/username1/logo.png' self.assertEqual( response.data['logo_url'].replace('https://', 'http://'), expected_logo_url) self.user.refresh_from_db() self.assertEqual(self.user.logo_url.replace('https://', 'http://'), expected_logo_url) self.assertEqual(self.user.logo_path, 'users/username1/logo.png') upload_base64_mock.assert_called_once_with('base64-data', 'users/username1/logo.png', False, True)
class UserExtrasViewTest(OCLAPITestCase): def setUp(self): self.user = UserProfileFactory(extras=dict()) self.token = self.user.get_token() def test_get(self): response = self.client.get('/users/{}/extras/'.format( self.user.username), HTTP_AUTHORIZATION='Token ' + self.token, format='json') self.assertEqual(response.status_code, 200) self.assertEqual(response.data, {}) extras = dict(foo='bar') self.user.extras = extras self.user.save() response = self.client.get('/users/{}/extras/'.format( self.user.username), HTTP_AUTHORIZATION='Token ' + self.token, format='json') self.assertEqual(response.status_code, 200) self.assertEqual(response.data, extras) response = self.client.get('/user/extras/', HTTP_AUTHORIZATION='Token ' + self.token, format='json') self.assertEqual(response.status_code, 200) self.assertEqual(response.data, extras)
def test_get_200_auth_user(self): response = self.client.get('/orgs/', HTTP_AUTHORIZATION='Token ' + self.token, format='json') self.assertEqual(response.status_code, 200) self.assertEqual(len(response.data), 5) self.assertEqual([org['id'] for org in response.data], [ 'user-private-org', 'user-public-view-org', 'public-edit-org', 'public-view-org', 'OCL' ]) random_user = UserProfileFactory() response = self.client.get('/orgs/?verbose=true', HTTP_AUTHORIZATION='Token ' + random_user.get_token(), format='json') self.assertEqual(response.status_code, 200) self.assertEqual(len(response.data), 4) self.assertEqual([org['id'] for org in response.data], [ 'user-public-view-org', 'public-edit-org', 'public-view-org', 'OCL' ]) response = self.client.get('/user/orgs/?verbose=true', HTTP_AUTHORIZATION='Token ' + random_user.get_token(), format='json') self.assertEqual(response.status_code, 200) self.assertEqual(len(response.data), 0)
def test_get_task_pending(self, async_result_klass_mock, task_exists_mock): task_exists_mock.return_value = False task_id = "{}-{}~{}".format(str(uuid.uuid4()), 'foobar', 'normal') foobar_user = UserProfileFactory(username='******') async_result_instance_mock = Mock( successful=Mock(return_value=False), failed=Mock(return_value=False), state='PENDING', id=task_id ) async_result_klass_mock.return_value = async_result_instance_mock response = self.client.get( '/importers/bulk-import/?task={}'.format(task_id), HTTP_AUTHORIZATION='Token ' + foobar_user.get_token(), format='json' ) self.assertEqual(response.status_code, 404) self.assertEqual(response.data, dict(exception="task {} not found".format(task_id))) async_result_instance_mock.successful.assert_called_once() async_result_instance_mock.failed.assert_called_once() task_exists_mock.assert_called_once() task_exists_mock.return_value = True response = self.client.get( '/importers/bulk-import/?task={}'.format(task_id), HTTP_AUTHORIZATION='Token ' + foobar_user.get_token(), format='json' ) self.assertEqual(response.status_code, 202) self.assertEqual(response.data, dict(task=task_id, state='PENDING', username='******', queue='normal'))
def setUp(self): self.user = UserProfileFactory() self.org = OrganizationFactory() self.token = self.user.get_token() self.source = OrganizationSourceFactory() self.user_pin = self.user.pins.create(resource=self.source) self.org_pin = self.org.pins.create(resource=self.source)
def test_delete(self): coll = OrganizationCollectionFactory(mnemonic='coll1') OrganizationCollectionFactory(version='v1', is_latest_version=True, mnemonic='coll1', organization=coll.organization) user = UserProfileFactory(organizations=[coll.organization]) self.assertEqual(coll.versions.count(), 2) response = self.client.delete('/collections/coll1/v1/', HTTP_AUTHORIZATION='Token ' + user.get_token(), format='json') self.assertEqual(response.status_code, 204) self.assertEqual(coll.versions.count(), 1) response = self.client.delete('/collections/coll1/', HTTP_AUTHORIZATION='Token ' + user.get_token(), format='json') self.assertEqual(response.status_code, 204) self.assertEqual(coll.versions.count(), 0) self.assertFalse(Collection.objects.filter(mnemonic='coll1').exists())
def test_set_token(self): user = UserProfileFactory() self.assertFalse(Token.objects.filter(user=user).exists()) user.set_token('token') self.assertEqual(user.auth_token.key, 'token')
def test_post_201(self): source = OrganizationSourceFactory() user = UserProfileFactory() org = OrganizationFactory() token = user.get_token() response = self.client.post(user.uri + 'pins/', dict(resource_type='Source', resource_id=source.id), HTTP_AUTHORIZATION='Token ' + token, format='json') self.assertEqual(response.status_code, 201) self.assertEqual(response.data['resource_uri'], source.uri) self.assertEqual(response.data['user_id'], user.id) self.assertIsNone(response.data['organization_id']) self.assertIsNotNone(response.data['resource']) self.assertIsNotNone(response.data['uri']) response = self.client.post(org.uri + 'pins/', dict(resource_type='Source', resource_id=source.id), HTTP_AUTHORIZATION='Token ' + token, format='json') self.assertEqual(response.status_code, 201) self.assertEqual(response.data['resource_uri'], source.uri) self.assertEqual(response.data['organization_id'], org.id) self.assertIsNone(response.data['user_id']) self.assertIsNotNone(response.data['resource']) self.assertIsNotNone(response.data['uri'])
def test_delete_403(self): stranger = UserProfileFactory() response = self.client.delete('/orgs/{}/'.format(self.org.mnemonic), HTTP_AUTHORIZATION='Token ' + stranger.get_token(), format='json') self.assertEqual(response.status_code, 403)
def test_delete_403(self): random_user = UserProfileFactory() response = self.client.delete('/users/{}/'.format(self.user.username), HTTP_AUTHORIZATION='Token ' + random_user.get_token(), format='json') self.assertEqual(response.status_code, 403)
def setUp(self): super().setUp() self.user = UserProfileFactory() self.token = self.user.get_token() self.extras = dict(foo='bar', tao='ching') self.collection = UserCollectionFactory(mnemonic='coll', user=self.user, extras=self.extras)
def setUp(self): super().setUp() self.user = UserProfileFactory(username='******') self.token = self.user.get_token() self.source = UserSourceFactory(mnemonic='source1', user=self.user) self.source_v1 = UserSourceFactory(version='v1', mnemonic='source1', user=self.user)
def setUp(self): super().setUp() self.user = UserProfileFactory() self.token = self.user.get_token() self.collection = UserCollectionFactory(mnemonic='coll', user=self.user) self.collection_v1 = UserCollectionFactory(version='v1', mnemonic='coll', user=self.user)
def test_get_403(self): random_user = UserProfileFactory() response = self.client.get( '/orgs/{}/members/{}/'.format(self.org.mnemonic, random_user.username), HTTP_AUTHORIZATION='Token ' + random_user.get_token(), format='json') self.assertEqual(response.status_code, 403)
def test_put_204(self): inactive_user = UserProfileFactory(is_active=False) response = self.client.put( '/users/{}/reactivate/'.format(inactive_user.username), HTTP_AUTHORIZATION='Token ' + self.superuser.get_token(), format='json') self.assertEqual(response.status_code, 204) inactive_user.refresh_from_db() self.assertTrue(inactive_user.is_active)
def test_get_token(self): user = UserProfileFactory() self.assertFalse(Token.objects.filter(user=user).exists()) token = user.get_token() self.assertIsNotNone(token) self.assertEqual(user.auth_token.key, token) self.assertEqual(user.get_token(), token)
def setUp(self): super().setUp() self.superuser = UserProfile.objects.get(is_superuser=True) self.user = UserProfileFactory(username='******') self.org_private = OrganizationFactory(mnemonic='private-org', public_access=ACCESS_TYPE_NONE) self.org_public_view = OrganizationFactory(mnemonic='public-view-org', public_access=ACCESS_TYPE_VIEW) self.org_public_edit = OrganizationFactory(mnemonic='public-edit-org', public_access=ACCESS_TYPE_EDIT) self.user_org_public = OrganizationFactory(mnemonic='user-public-view-org', public_access=ACCESS_TYPE_VIEW) self.user_org_private = OrganizationFactory(mnemonic='user-private-org', public_access=ACCESS_TYPE_NONE) self.user.organizations.set([self.user_org_private, self.user_org_public]) self.token = self.user.get_token()
def test_post_403(self): random_user = UserProfileFactory() response = self.client.post('/users/', dict(username='******', name='John Doe', password='******', email='*****@*****.**'), HTTP_AUTHORIZATION='Token ' + random_user.get_token(), format='json') self.assertEqual(response.status_code, 403)
def test_get_200_staff_user(self): staff_user = UserProfileFactory(is_staff=True) response = self.client.get('/orgs/', HTTP_AUTHORIZATION='Token ' + staff_user.get_token(), format='json') self.assertEqual(response.status_code, 200) self.assertEqual(len(response.data), 6) self.assertEqual([org['id'] for org in response.data], [ 'user-private-org', 'user-public-view-org', 'public-edit-org', 'public-view-org', 'private-org', 'OCL' ])
def test_put_405(self): coll = OrganizationCollectionFactory(mnemonic='coll1', name='Collection') user = UserProfileFactory(organizations=[coll.organization]) self.assertEqual(coll.versions.count(), 1) response = self.client.put('/collections/coll1/', dict(name='Collection1'), HTTP_AUTHORIZATION='Token ' + user.get_token(), format='json') self.assertEqual(response.status_code, 405)
def setUp(self): super().setUp() self.user = UserProfileFactory() self.token = self.user.get_token() self.collection = UserCollectionFactory(mnemonic='coll', user=self.user) self.concept = ConceptFactory() self.reference = CollectionReference(expression=self.concept.uri) self.reference.full_clean() self.reference.save() self.collection.references.add(self.reference) self.collection.concepts.set(self.reference.concepts) self.assertEqual(self.collection.references.count(), 1) self.assertEqual(self.collection.concepts.count(), 1)
def test_post_unauthorised(self): response = self.client.post( '/indexes/resources/foobar/' ) self.assertEqual(response.status_code, 401) random_user = UserProfileFactory() response = self.client.post( '/indexes/resources/foobar/', {}, HTTP_AUTHORIZATION='Token ' + random_user.get_token(), ) self.assertEqual(response.status_code, 403)
def test_login(self): response = self.client.post('/users/login/', {}) self.assertEqual(response.status_code, 400) self.assertEqual( response.data, dict(username=['This field is required.'], password=['This field is required.'])) response = self.client.post('/users/login/', dict(username='******', password='******')) self.assertEqual(response.status_code, 400) self.assertEqual( response.data, dict(non_field_errors=[ "Unable to log in with provided credentials." ])) user = UserProfileFactory() user.set_password('password') user.save() self.assertIsNone(user.last_login) response = self.client.post( '/users/login/', dict(username=user.username, password='******')) self.assertEqual(response.status_code, 200) self.assertEqual(response.data, dict(token=ANY)) user.refresh_from_db() self.assertIsNotNone(user.last_login)
def test_put_400(self): coll = OrganizationCollectionFactory(mnemonic='coll1', name='Collection') user = UserProfileFactory(organizations=[coll.organization]) self.assertEqual(coll.versions.count(), 1) response = self.client.put( coll.uri, dict(name=''), HTTP_AUTHORIZATION='Token ' + user.get_token(), format='json' ) self.assertEqual(response.status_code, 400) self.assertEqual(response.data, dict(name=[ErrorDetail(string='This field may not be blank.', code='blank')]))
def test_request_and_reset(self, send_mail_mock): user = UserProfileFactory(username='******', email='*****@*****.**') self.assertIsNone(user.verification_token) response = self.client.post('/users/password/reset/', dict(), format='json') self.assertEqual(response.status_code, 400) response = self.client.post('/users/password/reset/', dict(email='*****@*****.**'), format='json') self.assertEqual(response.status_code, 404) response = self.client.post('/users/password/reset/', dict(email='*****@*****.**'), format='json') self.assertEqual(response.status_code, 200) user.refresh_from_db() self.assertIsNotNone(user.verification_token) send_mail_mock.assert_called_once() response = self.client.put('/users/password/reset/', dict(), format='json') self.assertEqual(response.status_code, 400) response = self.client.put('/users/password/reset/', dict(token='bad-token'), format='json') self.assertEqual(response.status_code, 400) response = self.client.put('/users/password/reset/', dict(new_password='******'), format='json') self.assertEqual(response.status_code, 400) response = self.client.put('/users/password/reset/', dict(token='bad-token', new_password='******'), format='json') self.assertEqual(response.status_code, 404) response = self.client.put('/users/password/reset/', dict(token=user.verification_token, new_password='******'), format='json') self.assertEqual(response.status_code, 200) user.refresh_from_db() self.assertIsNone(user.verification_token) self.assertTrue(user.check_password('new-password123')) response = self.client.post('/users/login/', dict(username='******', password='******'), format='json') self.assertEqual(response.status_code, 200) self.assertEqual(response.data, dict(token=user.get_token()))
def test_post_400(self): user = UserProfileFactory() token = user.get_token() response = self.client.post(user.uri + 'pins/', dict(resource_type='Source', resource_id=1209), HTTP_AUTHORIZATION='Token ' + token, format='json') self.assertEqual(response.status_code, 400) self.assertEqual( response.data, dict( resource='Resource type Source with id 1209 does not exists.'))
class CollectionVersionListViewTest(OCLAPITestCase): def setUp(self): super().setUp() self.user = UserProfileFactory() self.token = self.user.get_token() self.collection = UserCollectionFactory(mnemonic='coll', user=self.user) self.concept = ConceptFactory() self.reference = CollectionReference(expression=self.concept.uri) self.reference.full_clean() self.reference.save() self.collection.references.add(self.reference) self.collection.concepts.set(self.reference.concepts) self.assertEqual(self.collection.references.count(), 1) self.assertEqual(self.collection.concepts.count(), 1) def test_get_200(self): response = self.client.get('/collections/coll/versions/?verbose=true', HTTP_AUTHORIZATION='Token ' + self.token, format='json') self.assertEqual(response.status_code, 200) self.assertEqual(len(response.data), 1) self.assertEqual(response.data[0]['version'], 'HEAD') UserCollectionFactory(mnemonic=self.collection.mnemonic, user=self.user, version='v1', released=True) response = self.client.get('/collections/coll/versions/?released=true', HTTP_AUTHORIZATION='Token ' + self.token, format='json') self.assertEqual(response.status_code, 200) self.assertEqual(len(response.data), 1) self.assertEqual(response.data[0]['version'], 'v1') @patch('core.collections.views.export_collection') def test_post_201(self, export_collection_mock): export_collection_mock.delay = Mock() response = self.client.post('/collections/coll/versions/', dict(id='v1', description='version1'), HTTP_AUTHORIZATION='Token ' + self.token, format='json') self.assertEqual(response.status_code, 201) self.assertEqual(response.data['version'], 'v1') self.assertEqual(self.collection.versions.count(), 2) last_created_version = self.collection.versions.order_by( 'created_at').last() self.assertEqual(last_created_version.version, 'v1') self.assertEqual(last_created_version.description, 'version1') self.assertEqual(last_created_version.concepts.count(), 1) self.assertEqual(last_created_version.references.count(), 1) self.assertEqual(last_created_version, self.collection.get_latest_version()) export_collection_mock.delay.assert_called_once_with( str(last_created_version.id))
def test_post_202(self, bulk_import_mock): task_mock = Mock(id='task-id', state='pending') bulk_import_mock.apply_async = Mock(return_value=task_mock) response = self.client.post( "/importers/bulk-import/?update_if_exists=true", 'some-data', HTTP_AUTHORIZATION='Token ' + self.token, format='json' ) self.assertEqual(response.status_code, 202) self.assertEqual(response.data, dict(task='task-id', state='pending', queue='default', username='******')) self.assertEqual(bulk_import_mock.apply_async.call_count, 1) self.assertEqual(bulk_import_mock.apply_async.call_args[0], (('"some-data"', 'ocladmin', True),)) self.assertEqual(bulk_import_mock.apply_async.call_args[1]['task_id'][37:], 'ocladmin~priority') self.assertEqual(bulk_import_mock.apply_async.call_args[1]['queue'], 'bulk_import_root') random_user = UserProfileFactory(username='******') response = self.client.post( "/importers/bulk-import/?update_if_exists=true", 'some-data', HTTP_AUTHORIZATION='Token ' + random_user.get_token(), format='json' ) self.assertEqual(response.status_code, 202) self.assertEqual(response.data, dict(task='task-id', state='pending', queue='default', username='******')) self.assertEqual(bulk_import_mock.apply_async.call_count, 2) self.assertEqual(bulk_import_mock.apply_async.call_args[0], (('"some-data"', 'oswell', True),)) self.assertEqual(bulk_import_mock.apply_async.call_args[1]['task_id'][37:], 'oswell~default') self.assertTrue(bulk_import_mock.apply_async.call_args[1]['queue'].startswith('bulk_import_')) response = self.client.post( "/importers/bulk-import/foobar-queue/?update_if_exists=true", 'some-data', HTTP_AUTHORIZATION='Token ' + random_user.get_token(), format='json' ) self.assertEqual(response.status_code, 202) self.assertEqual(response.data, dict(task='task-id', state='pending', queue='default', username='******')) self.assertEqual(bulk_import_mock.apply_async.call_count, 3) self.assertEqual(bulk_import_mock.apply_async.call_args[0], (('"some-data"', 'oswell', True),)) self.assertEqual(bulk_import_mock.apply_async.call_args[1]['task_id'][37:], 'oswell~foobar-queue') self.assertTrue(bulk_import_mock.apply_async.call_args[1]['queue'].startswith('bulk_import_'))