def test_delete(self):
random_user1 = UserProfileFactory()
random_user2 = UserProfileFactory()
response = self.client.delete(self.config.uri,
HTTP_AUTHORIZATION='Token ' +
random_user1.get_token(),
format='json')
self.assertEqual(response.status_code, 403)
self.assertEqual(ClientConfig.objects.count(), 1)
template = ClientConfig(is_template=True,
config=self.dummy_config,
name='foobar',
resource=self.org,
created_by=random_user1)
template.save()
response = self.client.delete(template.uri,
HTTP_AUTHORIZATION='Token ' +
random_user2.get_token(),
format='json')
self.assertEqual(response.status_code, 403)
self.assertEqual(ClientConfig.objects.count(), 2)
response = self.client.delete(template.uri,
HTTP_AUTHORIZATION='Token ' +
random_user1.get_token(),
format='json')
self.assertEqual(response.status_code, 204)
self.assertEqual(ClientConfig.objects.count(), 1)
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 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_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_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 test_put_bad_request(self):
inactive_user = UserProfileFactory(is_active=False)
response = self.client.put(
'/users/{}/reactivate/'.format(inactive_user.username),
HTTP_AUTHORIZATION='Token ' + inactive_user.get_token(),
format='json')
self.assertEqual(response.status_code, 401)
random_user = UserProfileFactory()
response = self.client.put(
'/users/{}/reactivate/'.format(inactive_user.username),
HTTP_AUTHORIZATION='Token ' + random_user.get_token(),
format='json')
self.assertEqual(response.status_code, 403)
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_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()))
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))
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)
class SourceLogoViewTest(OCLAPITestCase):
def setUp(self):
super().setUp()
self.user = UserProfileFactory(username='******')
self.token = self.user.get_token()
self.source = UserSourceFactory(mnemonic='source1', user=self.user)
@patch('core.common.services.S3.upload_base64')
def test_post_200(self, upload_base64_mock):
upload_base64_mock.return_value = 'users/username/sources/source1/logo.png'
self.assertIsNone(self.source.logo_url)
self.assertIsNone(self.source.logo_path)
response = self.client.post(self.source.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/username/sources/source1/logo.png'
self.assertEqual(
response.data['logo_url'].replace('https://', 'http://'),
expected_logo_url)
self.source.refresh_from_db()
self.assertEqual(self.source.logo_url.replace('https://', 'http://'),
expected_logo_url)
self.assertEqual(self.source.logo_path,
'users/username/sources/source1/logo.png')
upload_base64_mock.assert_called_once_with(
'base64-data', 'users/username/sources/source1/logo.png', False,
True)
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_'))
def test_post_201(self):
org = OrganizationFactory(mnemonic='org')
user = UserProfileFactory(organizations=[org], username='******')
response = self.client.post('/orgs/org/collections/',
dict(default_locale='en',
supported_locales='en,fr',
id='coll',
name='Collection',
mnemonic='coll',
extras=dict(foo='bar')),
HTTP_AUTHORIZATION='Token ' +
user.get_token(),
format='json')
self.assertEqual(response.status_code, 201)
self.assertIsNotNone(response.data['uuid'])
self.assertEqual(response.data['id'], 'coll')
self.assertEqual(response.data['name'], 'Collection')
self.assertEqual(response.data['default_locale'], 'en')
self.assertEqual(response['Location'], '/orgs/org/collections/coll/')
self.assertEqual(org.collection_set.count(), 1)
response = self.client.post('/users/user/collections/',
dict(default_locale='en',
supported_locales='en,fr',
id='coll',
name='Collection',
mnemonic='coll',
extras=dict(foo='bar')),
HTTP_AUTHORIZATION='Token ' +
user.get_token(),
format='json')
self.assertEqual(response.status_code, 201)
self.assertIsNotNone(response.data['uuid'])
self.assertEqual(response.data['id'], 'coll')
self.assertEqual(response.data['name'], 'Collection')
self.assertEqual(response.data['default_locale'], 'en')
self.assertEqual(response['Location'], '/users/user/collections/coll/')
self.assertEqual(user.collection_set.count(), 1)
org_collection = org.collection_set.first()
user_collection = user.collection_set.first()
self.assertNotEqual(org_collection.id, user_collection.id)
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 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_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)
class UserOrganizationListViewTest(OCLAPITestCase):
def setUp(self):
super().setUp()
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_get_200(self):
response = self.client.get('/users/{}/orgs/'.format(
self.user.username),
HTTP_AUTHORIZATION='Token ' + self.token,
format='json')
self.assertEqual(response.status_code, 200)
self.assertEqual(len(response.data), 2)
self.assertEqual([org['id'] for org in response.data],
['user-private-org', 'user-public-view-org'])
random_user = UserProfileFactory()
response = self.client.get(
'/users/{}/orgs/'.format(random_user.username),
HTTP_AUTHORIZATION='Token ' + random_user.get_token(),
format='json')
self.assertEqual(response.status_code, 200)
self.assertEqual(len(response.data), 0)
def test_head_200(self):
response = self.client.head('/users/{}/orgs/'.format(
self.user.username),
HTTP_AUTHORIZATION='Token ' + self.token,
format='json')
self.assertEqual(response.status_code, 200)
self.assertEqual(response['num_found'], '2')
def test_post_405(self):
response = self.client.post('/users/{}/orgs/'.format(
self.user.username),
dict(id='test-org-1', name='Test Org 1'),
HTTP_AUTHORIZATION='Token ' + self.token,
format='json')
self.assertEqual(response.status_code, 405)
self.assertIsNone(response.data)
class CollectionExtraRetrieveUpdateDestroyViewTest(OCLAPITestCase):
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 test_get_200(self):
response = self.client.get('/collections/coll/extras/foo/',
HTTP_AUTHORIZATION='Token ' + self.token,
format='json')
self.assertEqual(response.status_code, 200)
self.assertEqual(response.data, dict(foo='bar'))
def test_get_404(self):
response = self.client.get('/collections/coll/extras/bar/',
HTTP_AUTHORIZATION='Token ' + self.token,
format='json')
self.assertEqual(response.status_code, 404)
def test_put_200(self):
response = self.client.put('/collections/coll/extras/foo/',
dict(foo='barbar'),
HTTP_AUTHORIZATION='Token ' + self.token,
format='json')
self.assertEqual(response.status_code, 200)
self.assertEqual(response.data, dict(foo='barbar'))
self.collection.refresh_from_db()
self.assertEqual(self.collection.extras['foo'], 'barbar')
def test_put_400(self):
response = self.client.put('/collections/coll/extras/foo/',
dict(foo=None),
HTTP_AUTHORIZATION='Token ' + self.token,
format='json')
self.assertEqual(response.status_code, 400)
self.assertEqual(response.data, ['Must specify foo param in body.'])
self.collection.refresh_from_db()
self.assertEqual(self.collection.extras, self.extras)
def test_delete_204(self):
response = self.client.delete('/collections/coll/extras/foo/',
HTTP_AUTHORIZATION='Token ' + self.token,
format='json')
self.assertEqual(response.status_code, 204)
self.collection.refresh_from_db()
self.assertEqual(self.collection.extras, dict(tao='ching'))
def test_delete_404(self):
response = self.client.delete('/collections/coll/extras/bar/',
HTTP_AUTHORIZATION='Token ' + self.token,
format='json')
self.assertEqual(response.status_code, 404)
class ConceptVersionsViewTest(OCLAPITestCase):
def setUp(self):
super().setUp()
self.concept = ConceptFactory(names=[LocalizedTextFactory()])
self.user = UserProfileFactory(organizations=[self.concept.parent.organization])
self.token = self.user.get_token()
def test_get_200(self):
self.assertEqual(self.concept.versions.count(), 1)
response = self.client.get(self.concept.versions_url)
self.assertEqual(response.status_code, 200)
versions = response.data
self.assertEqual(len(versions), 1)
version = versions[0]
latest_version = self.concept.get_latest_version()
self.assertEqual(version['uuid'], str(latest_version.id))
self.assertEqual(version['id'], self.concept.mnemonic)
self.assertEqual(version['url'], self.concept.uri)
self.assertEqual(version['version_url'], latest_version.uri)
self.assertTrue(version['is_latest_version'])
self.assertIsNone(version['previous_version_url'])
response = self.client.put(
self.concept.uri,
{'names': [{
'locale': 'ab', 'locale_preferred': True, 'name': 'c1 name', 'name_type': 'Fully Specified'
}], 'datatype': 'foobar', 'update_comment': 'Updated datatype'},
HTTP_AUTHORIZATION='Token ' + self.token,
format='json'
)
self.assertEqual(response.status_code, 200)
self.assertEqual(self.concept.versions.count(), 2)
response = self.client.get(self.concept.versions_url)
self.assertEqual(response.status_code, 200)
versions = response.data
self.assertEqual(len(versions), 2)
prev_latest_version = [v for v in versions if v['uuid'] == version['uuid']][0]
new_latest_version = [v for v in versions if v['uuid'] != version['uuid']][0]
latest_version = self.concept.get_latest_version()
self.assertEqual(new_latest_version['version_url'], latest_version.uri)
self.assertEqual(str(latest_version.id), str(new_latest_version['uuid']))
self.assertEqual(prev_latest_version['uuid'], version['uuid'])
self.assertEqual(new_latest_version['previous_version_url'], prev_latest_version['version_url'])
self.assertEqual(new_latest_version['previous_version_url'], version['version_url'])
self.assertIsNone(prev_latest_version['previous_version_url'])
self.assertFalse(prev_latest_version['is_latest_version'])
self.assertTrue(new_latest_version['is_latest_version'])
self.assertEqual(new_latest_version['datatype'], 'foobar')
self.assertEqual(prev_latest_version['datatype'], 'None')
class CollectionConceptsViewTest(OCLAPITestCase):
def setUp(self):
super().setUp()
self.user = UserProfileFactory()
self.collection = UserCollectionFactory(user=self.user)
self.token = self.user.get_token()
def test_get_200(self):
response = self.client.get(
self.collection.concepts_url,
HTTP_AUTHORIZATION='Token ' + self.token,
format='json'
)
self.assertEqual(response.status_code, 200)
self.assertEqual(len(response.data), 0)
source1 = OrganizationSourceFactory()
source2 = OrganizationSourceFactory()
concept1 = ConceptFactory(parent=source1, mnemonic='concept')
concept2 = ConceptFactory(parent=source2, mnemonic='concept')
self.collection.add_references([concept1.uri, concept2.uri])
response = self.client.get(
self.collection.concepts_url,
HTTP_AUTHORIZATION='Token ' + self.token,
format='json'
)
self.assertEqual(response.status_code, 200)
self.assertEqual(len(response.data), 2)
def test_get_duplicate_concept_name_from_multiple_sources_200(self):
source1 = OrganizationSourceFactory()
source2 = OrganizationSourceFactory()
concept1 = ConceptFactory(parent=source1, mnemonic='concept')
concept2 = ConceptFactory(parent=source2, mnemonic='concept')
self.collection.add_references([concept1.uri, concept2.uri])
response = self.client.get(
self.collection.concepts_url + 'concept/',
HTTP_AUTHORIZATION='Token ' + self.token,
format='json'
)
self.assertEqual(response.status_code, 409)
response = self.client.get(
self.collection.concepts_url + 'concept/?uri=' + concept2.uri,
HTTP_AUTHORIZATION='Token ' + self.token,
format='json'
)
self.assertEqual(response.status_code, 200)
self.assertEqual(response.data['uuid'], str(concept2.get_latest_version().id))
def test_get_with_task_id_success(self, async_result_klass_mock):
task_id1 = "{}-{}~{}".format(str(uuid.uuid4()), 'ocladmin', 'priority')
task_id2 = "{}-{}~{}".format(str(uuid.uuid4()), 'foobar', 'normal')
foobar_user = UserProfileFactory(username='******')
response = self.client.get(
'/importers/bulk-import/?task={}'.format(task_id1),
HTTP_AUTHORIZATION='Token ' + foobar_user.get_token(),
format='json'
)
self.assertEqual(response.status_code, 403)
async_result_mock = Mock(json='json-format', report='report-format', detailed_summary='summary')
async_result_instance_mock = Mock(successful=Mock(return_value=True), get=Mock(return_value=async_result_mock))
async_result_klass_mock.return_value = async_result_instance_mock
response = self.client.get(
'/importers/bulk-import/?task={}'.format(task_id2),
HTTP_AUTHORIZATION='Token ' + foobar_user.get_token(),
format='json'
)
self.assertEqual(response.status_code, 200)
self.assertEqual(response.data, 'summary')
response = self.client.get(
'/importers/bulk-import/?task={}&result=json'.format(task_id2),
HTTP_AUTHORIZATION='Token ' + foobar_user.get_token(),
format='json'
)
self.assertEqual(response.status_code, 200)
self.assertEqual(response.data, 'json-format')
response = self.client.get(
'/importers/bulk-import/?task={}&result=report'.format(task_id2),
HTTP_AUTHORIZATION='Token ' + foobar_user.get_token(),
format='json'
)
self.assertEqual(response.status_code, 200)
self.assertEqual(response.data, 'report-format')
async_result_instance_mock.successful.assert_called()
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'
])
class MappingExtrasViewTest(OCLAPITestCase):
def setUp(self):
super().setUp()
self.extras = dict(foo='bar', tao='ching')
self.concept = MappingFactory(extras=self.extras)
self.user = UserProfileFactory(organizations=[self.concept.parent.organization])
self.token = self.user.get_token()
def test_get_200(self):
response = self.client.get(self.concept.uri + 'extras/', format='json')
self.assertEqual(response.status_code, 200)
self.assertEqual(response.data, self.extras)
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_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 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_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.'))
def test_put_200(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='Collection1'),
HTTP_AUTHORIZATION='Token ' +
user.get_token(),
format='json')
self.assertEqual(response.status_code, 200)
self.assertEqual(response.data['name'], 'Collection1')
coll.refresh_from_db()
self.assertEqual(coll.name, 'Collection1')
self.assertEqual(coll.versions.count(), 1)
def test_get_with_task_id_failed(self, async_result_klass_mock):
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=True),
result='task-failure-result')
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, 400)
self.assertEqual(response.data, dict(exception='task-failure-result'))
async_result_instance_mock.successful.assert_called()
async_result_instance_mock.failed.assert_called()
