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