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_'))
