def setUp(self):
super(TestODMTitleSearch, self).setUp()
self.user = factories.AuthUserFactory()
self.user_two = factories.AuthUserFactory()
self.project = factories.ProjectFactory(creator=self.user, title='foo')
self.project_two = factories.ProjectFactory(creator=self.user_two, title='bar')
self.public_project = factories.ProjectFactory(creator=self.user_two, is_public=True, title='baz')
self.registration_project = factories.RegistrationFactory(creator=self.user, title='qux')
self.folder = factories.CollectionFactory(creator=self.user, title='quux')
self.dashboard = find_bookmark_collection(self.user)
self.url = api_url_for('search_projects_by_title')
def setUp(self):
super(TestFileUpdated, self).setUp()
self.user_1 = factories.AuthUserFactory()
self.auth = Auth(user=self.user_1)
self.user_2 = factories.AuthUserFactory()
self.project = factories.ProjectFactory(creator=self.user_1)
# subscription
self.sub = factories.NotificationSubscriptionFactory(
_id=self.project._id + 'file_updated',
owner=self.project,
event_name='file_updated',
)
self.sub.save()
self.event = event_registry['file_updated'](self.user_2, self.project, 'file_updated', payload=file_payload)
def test_deprecation_warning_for_snake_case(self):
user_auth = factories.AuthUserFactory()
node = factories.NodeFactory(creator=user_auth)
url = '/{}nodes/{}/draft_registrations/?version={}'.format(
API_BASE, node._id, KEBAB_CASE_VERSION)
schema = RegistrationSchema.objects.get(
name='OSF-Standard Pre-Data Collection Registration',
schema_version=2)
payload = {
'data': {
'type': 'draft_registrations',
'relationships': {
'registration_schema': {
'data': {
'id': schema._id,
'type': 'registration_schemas'
}
}
}
}
}
res = self.app.post_json_api(url, payload, auth=user_auth.auth)
assert res.json['data']['type'] == 'draft-registrations'
assert res.json['meta'][
'warning'] == 'As of API Version {0}, all types are now Kebab-case. {0} will accept snake_case, but this will be deprecated in future versions.'.format(
KEBAB_CASE_VERSION)
def test_no_login_presend_for_inactive_user(self, mock_mail):
user = factories.AuthUserFactory()
mail = self.queue_mail(mail=mails.NO_LOGIN, user=user)
user.date_last_login = timezone.now() - timedelta(weeks=10)
user.save()
assert_true(timezone.now() - timedelta(days=1) > user.date_last_login)
assert_true(mail.send_mail())
def populate_collection_providers(add_data):
for data in COLLECTION_PROVIDERS:
_id = data.pop('_id')
default_license = data.pop('default_license', False)
licenses = [
get_license(name) for name in data.pop('licenses_acceptable', [])
]
custom_taxonomy = data.pop('custom_taxonomy', False)
primary_collection = data.pop('primary_collection', False)
provider, created = CollectionProvider.objects.update_or_create(
_id=_id, defaults=data)
if licenses:
provider.licenses_acceptable.set(licenses)
if default_license:
provider.default_license = get_license(default_license)
if custom_taxonomy and not provider.subjects.exists():
logger.info('Adding custom taxonomy for: {}'.format(_id))
call_command('populate_custom_taxonomies', '--provider', _id,
'--type', 'osf.collectionprovider', '--data',
json.dumps(custom_taxonomy))
provider_subjects = provider.subjects.all()
subjects = provider_subjects if len(
provider_subjects) else PreprintProvider.load(
'osf').subjects.all()
if primary_collection and not provider.primary_collection:
primary_collection['provider'] = provider
provider.primary_collection = factories.CollectionFactory(
**primary_collection)
provider.primary_collection.save()
provider.save()
if add_data and provider.primary_collection:
user = factories.AuthUserFactory()
user.save()
for _ in range(5):
node = factories.NodeFactory()
node.is_public = True
node.save()
status = random.choice(
provider.primary_collection.status_choices)
collected_type = random.choice(
provider.primary_collection.collected_type_choices)
cgm = provider.primary_collection.collect_object(
node, user, collected_type=collected_type, status=status)
rando_subjects = random.sample(subjects, min(len(subjects), 5))
cgm.subjects.add(*rando_subjects)
cgm.save()
logger.info('{} collection provider: {}'.format(
'Added' if created else 'Updated', _id))
def test_disabled_user_gets_error(self):
user = factories.AuthUserFactory()
res = self.app.get('/{}nodes/'.format(API_BASE),
auth=user.auth,
expect_errors=True)
assert_equal(res.status_code, http.BAD_REQUEST)
def setUp(self):
super(TestSearchViews, self).setUp()
import website.search.search as search
search.delete_all()
robbie = factories.UserFactory(fullname='Robbie Williams')
self.project = factories.ProjectFactory(creator=robbie)
self.contrib = factories.UserFactory(fullname='Brian May')
for i in range(0, 12):
factories.UserFactory(fullname='Freddie Mercury{}'.format(i))
self.user_one = factories.AuthUserFactory()
self.user_two = factories.AuthUserFactory()
self.project_private_user_one = factories.ProjectFactory(title='aaa', creator=self.user_one, is_public=False)
self.project_private_user_two = factories.ProjectFactory(title='aaa', creator=self.user_two, is_public=False)
self.project_public_user_one = factories.ProjectFactory(title='aaa', creator=self.user_one, is_public=True)
self.project_public_user_two = factories.ProjectFactory(title='aaa', creator=self.user_two, is_public=True)
def setUp(self):
super(TestJSONAPIBaseView, self).setUp()
self.user = factories.AuthUserFactory()
self.node = factories.ProjectFactory(creator=self.user)
self.url = '/{0}nodes/{1}/'.format(API_BASE, self.node._id)
for i in range(5):
factories.ProjectFactory(parent=self.node, creator=self.user)
for i in range(5):
factories.ProjectFactory(parent=self.node)
def setUp(self):
super(TestJSONAPIPagination, self).setUp()
self.url_version_2_0 = '/{}nodes/'.format(settings.API_BASE)
self.url_version_2_1 = '/{}nodes/?version=2.1'.format(
settings.API_BASE)
self.user = factories.AuthUserFactory()
for i in range(0, 11):
factories.ProjectFactory(creator=self.user)
def setUp(self):
super(TestCategorizeUsers, self).setUp()
self.user_1 = factories.AuthUserFactory()
self.auth = Auth(user=self.user_1)
self.user_2 = factories.AuthUserFactory()
self.user_3 = factories.AuthUserFactory()
self.user_4 = factories.AuthUserFactory()
self.project = factories.ProjectFactory(creator=self.user_1)
self.private_node = factories.NodeFactory(
parent=self.project, is_public=False, creator=self.user_1
)
# Payload
file_moved_payload = file_move_payload(self.private_node, self.project)
self.event = event_registry['addon_file_moved'](
self.user_2, self.private_node, 'addon_file_moved',
payload=file_moved_payload
)
# Subscriptions
# for parent node
self.sub = factories.NotificationSubscriptionFactory(
_id=self.project._id + '_file_updated',
owner=self.project,
event_name='file_updated'
)
self.sub.save()
# for private node
self.private_sub = factories.NotificationSubscriptionFactory(
_id=self.private_node._id + '_file_updated',
owner=self.private_node,
event_name='file_updated'
)
self.private_sub.save()
# for file subscription
self.file_sub = factories.NotificationSubscriptionFactory(
_id='{pid}_{wbid}_file_updated'.format(
pid=self.project._id,
wbid=self.event.waterbutler_id
),
owner=self.project,
event_name='xyz42_file_updated'
)
self.file_sub.save()
def test_approval_requires_only_a_single_authorizer(self):
approval = DraftRegistrationApproval(
meta={
'registration_choice': 'immediate',
})
approval.save()
with mock.patch.object(approval, '_on_complete') as mock_on_complete:
authorizer1 = factories.AuthUserFactory()
authorizer1.add_system_tag(settings.PREREG_ADMIN_TAG)
approval.approve(authorizer1)
assert mock_on_complete.called
assert approval.is_approved
def setUp(self):
super(TestApiBaseSerializers, self).setUp()
self.user = factories.AuthUserFactory()
self.auth = factories.Auth(self.user)
self.node = factories.ProjectFactory(is_public=True)
for i in range(5):
factories.ProjectFactory(is_public=True, parent=self.node)
self.linked_node = factories.NodeFactory(creator=self.user, is_public=True)
self.node.add_pointer(self.linked_node, auth=self.auth)
self.url = '/{}nodes/{}/'.format(API_BASE, self.node._id)
def setUp(self):
super(TestFolderFileRenamed, self).setUp()
self.user_1 = factories.AuthUserFactory()
self.auth = Auth(user=self.user_1)
self.user_2 = factories.AuthUserFactory()
self.project = factories.ProjectFactory(creator=self.user_1)
# subscription
self.sub = factories.NotificationSubscriptionFactory(
_id=self.project._id + 'file_updated',
owner=self.project,
event_name='file_updated',
)
self.sub.save()
# Payload
file_renamed_payload = file_move_payload(self.project, self.project)
self.event = event_registry['addon_file_renamed'](
self.user_1, self.project, 'addon_file_renamed',
payload=file_renamed_payload
)
self.sub.email_digest.add(self.user_2)
self.sub.save()
def test_approval_requires_only_a_single_authorizer(self):
approval = DraftRegistrationApproval(
meta={
'registration_choice': 'immediate',
})
approval.save()
with mock.patch.object(approval, '_on_complete') as mock_on_complete:
authorizer1 = factories.AuthUserFactory()
administer_permission = Permission.objects.get(
codename='administer_prereg')
authorizer1.user_permissions.add(administer_permission)
authorizer1.save()
approval.approve(authorizer1)
assert mock_on_complete.called
assert approval.is_approved
def setUp(self):
super(TestCampaignsAuthViews, self).setUp()
self.campaigns = {
'prereg': {
'title_register': 'Preregistration Challenge',
'title_landing': 'Welcome to the Prereg Challenge!'
},
'erpc': {
'title_register': 'Election Research Preacceptance Competition',
'title_landing': 'The Election Research Preacceptance Competition is Now Closed'
},
}
for key, value in self.campaigns.items():
value.update({'url_login': web_url_for('auth_login', campaign=key)})
value.update({'url_register': web_url_for('auth_register', campaign=key)})
value.update({'url_landing': campaigns.campaign_url_for(key)})
self.user = factories.AuthUserFactory()
def test_search_user(self):
url = '/api/v1/search/user/'
res = self.app.get(url, {'q': 'Umwali'})
assert_equal(res.status_code, 200)
assert_false(res.json['results'])
user_one = factories.AuthUserFactory(fullname='Joe Umwali')
user_two = factories.AuthUserFactory(fullname='Joan Uwase')
res = self.app.get(url, {'q': 'Umwali'})
assert_equal(res.status_code, 200)
assert_equal(len(res.json['results']), 1)
assert_false(res.json['results'][0]['social'])
user_one.social = {
'github': user_one.given_name,
'twitter': user_one.given_name,
'ssrn': user_one.given_name
}
user_one.save()
res = self.app.get(url, {'q': 'Umwali'})
assert_equal(res.status_code, 200)
assert_equal(len(res.json['results']), 1)
assert_not_in('Joan', res.body)
assert_true(res.json['results'][0]['social'])
assert_equal(res.json['results'][0]['names']['fullname'], user_one.fullname)
assert_equal(res.json['results'][0]['social']['github'], 'http://github.com/{}'.format(user_one.given_name))
assert_equal(res.json['results'][0]['social']['twitter'], 'http://twitter.com/{}'.format(user_one.given_name))
assert_equal(res.json['results'][0]['social']['ssrn'], 'http://papers.ssrn.com/sol3/cf_dev/AbsByAuth.cfm?per_id={}'.format(user_one.given_name))
user_two.social = {
'profileWebsites': ['http://me.com/{}'.format(user_two.given_name)],
'orcid': user_two.given_name,
'linkedIn': user_two.given_name,
'scholar': user_two.given_name,
'impactStory': user_two.given_name,
'baiduScholar': user_two.given_name
}
user_two.save()
user_three = factories.AuthUserFactory(fullname='Janet Umwali')
user_three.social = {
'github': user_three.given_name,
'ssrn': user_three.given_name
}
user_three.save()
res = self.app.get(url, {'q': 'Umwali'})
assert_equal(res.status_code, 200)
assert_equal(len(res.json['results']), 2)
assert_true(res.json['results'][0]['social'])
assert_true(res.json['results'][1]['social'])
assert_not_equal(res.json['results'][0]['social']['ssrn'], res.json['results'][1]['social']['ssrn'])
assert_not_equal(res.json['results'][0]['social']['github'], res.json['results'][1]['social']['github'])
res = self.app.get(url, {'q': 'Uwase'})
assert_equal(res.status_code, 200)
assert_equal(len(res.json['results']), 1)
assert_true(res.json['results'][0]['social'])
assert_not_in('ssrn', res.json['results'][0]['social'])
assert_equal(res.json['results'][0]['social']['profileWebsites'][0], 'http://me.com/{}'.format(user_two.given_name))
assert_equal(res.json['results'][0]['social']['impactStory'], 'https://impactstory.org/u/{}'.format(user_two.given_name))
assert_equal(res.json['results'][0]['social']['orcid'], 'http://orcid.org/{}'.format(user_two.given_name))
assert_equal(res.json['results'][0]['social']['baiduScholar'], 'http://xueshu.baidu.com/scholarID/{}'.format(user_two.given_name))
assert_equal(res.json['results'][0]['social']['linkedIn'], 'https://www.linkedin.com/{}'.format(user_two.given_name))
assert_equal(res.json['results'][0]['social']['scholar'], 'http://scholar.google.com/citations?user={}'.format(user_two.given_name))
def contributor(self):
return factories.AuthUserFactory()
def user2(self):
return factories.AuthUserFactory()
def test_search_views(self):
#Test search contributor
url = api_url_for('search_contributor')
res = self.app.get(url, {'query': self.contrib.fullname})
assert_equal(res.status_code, 200)
result = res.json['users']
assert_equal(len(result), 1)
brian = result[0]
assert_equal(brian['fullname'], self.contrib.fullname)
assert_in('profile_image_url', brian)
assert_equal(brian['registered'], self.contrib.is_registered)
assert_equal(brian['active'], self.contrib.is_active)
#Test search pagination
res = self.app.get(url, {'query': 'fr'})
assert_equal(res.status_code, 200)
result = res.json['users']
pages = res.json['pages']
page = res.json['page']
assert_equal(len(result), 5)
assert_equal(pages, 3)
assert_equal(page, 0)
#Test default page 1
res = self.app.get(url, {'query': 'fr', 'page': 1})
assert_equal(res.status_code, 200)
result = res.json['users']
page = res.json['page']
assert_equal(len(result), 5)
assert_equal(page, 1)
#Test default page 2
res = self.app.get(url, {'query': 'fr', 'page': 2})
assert_equal(res.status_code, 200)
result = res.json['users']
page = res.json['page']
assert_equal(len(result), 4)
assert_equal(page, 2)
#Test smaller pages
res = self.app.get(url, {'query': 'fr', 'size': 5})
assert_equal(res.status_code, 200)
result = res.json['users']
pages = res.json['pages']
page = res.json['page']
assert_equal(len(result), 5)
assert_equal(page, 0)
assert_equal(pages, 3)
#Test smaller pages page 2
res = self.app.get(url, {
'query': 'fr',
'page': 2,
'size': 5,
})
assert_equal(res.status_code, 200)
result = res.json['users']
pages = res.json['pages']
page = res.json['page']
assert_equal(len(result), 4)
assert_equal(page, 2)
assert_equal(pages, 3)
#Test search projects
url = '/search/'
res = self.app.get(url, {'q': self.project.title})
assert_equal(res.status_code, 200)
#Test search node
res = self.app.post_json(api_url_for('search_node'),
{'query': self.project.title},
auth=factories.AuthUserFactory().auth)
assert_equal(res.status_code, 200)
#Test search node includePublic true
res = self.app.post_json(api_url_for('search_node'), {
'query': 'a',
'includePublic': True
},
auth=self.user_one.auth)
node_ids = [node['id'] for node in res.json['nodes']]
assert_in(self.project_private_user_one._id, node_ids)
assert_in(self.project_public_user_one._id, node_ids)
assert_in(self.project_public_user_two._id, node_ids)
assert_not_in(self.project_private_user_two._id, node_ids)
#Test search node includePublic false
res = self.app.post_json(api_url_for('search_node'), {
'query': 'a',
'includePublic': False
},
auth=self.user_one.auth)
node_ids = [node['id'] for node in res.json['nodes']]
assert_in(self.project_private_user_one._id, node_ids)
assert_in(self.project_public_user_one._id, node_ids)
assert_not_in(self.project_public_user_two._id, node_ids)
assert_not_in(self.project_private_user_two._id, node_ids)
#Test search user
url = '/api/v1/search/user/'
res = self.app.get(url, {'q': 'Umwali'})
assert_equal(res.status_code, 200)
assert_false(res.json['results'])
user_one = factories.AuthUserFactory(fullname='Joe Umwali')
user_two = factories.AuthUserFactory(fullname='Joan Uwase')
res = self.app.get(url, {'q': 'Umwali'})
assert_equal(res.status_code, 200)
assert_equal(len(res.json['results']), 1)
assert_false(res.json['results'][0]['social'])
user_one.social = {
'github': user_one.given_name,
'twitter': user_one.given_name,
'ssrn': user_one.given_name
}
user_one.save()
res = self.app.get(url, {'q': 'Umwali'})
assert_equal(res.status_code, 200)
assert_equal(len(res.json['results']), 1)
assert_not_in('Joan', res.body)
assert_true(res.json['results'][0]['social'])
assert_equal(res.json['results'][0]['names']['fullname'],
user_one.fullname)
assert_equal(res.json['results'][0]['social']['github'],
'http://github.com/{}'.format(user_one.given_name))
assert_equal(res.json['results'][0]['social']['twitter'],
'http://twitter.com/{}'.format(user_one.given_name))
assert_equal(
res.json['results'][0]['social']['ssrn'],
'http://papers.ssrn.com/sol3/cf_dev/AbsByAuth.cfm?per_id={}'.
format(user_one.given_name))
user_two.social = {
'profileWebsites':
['http://me.com/{}'.format(user_two.given_name)],
'orcid': user_two.given_name,
'linkedIn': user_two.given_name,
'scholar': user_two.given_name,
'impactStory': user_two.given_name,
'baiduScholar': user_two.given_name
}
user_two.save()
user_three = factories.AuthUserFactory(fullname='Janet Umwali')
user_three.social = {
'github': user_three.given_name,
'ssrn': user_three.given_name
}
user_three.save()
res = self.app.get(url, {'q': 'Umwali'})
assert_equal(res.status_code, 200)
assert_equal(len(res.json['results']), 2)
assert_true(res.json['results'][0]['social'])
assert_true(res.json['results'][1]['social'])
assert_not_equal(res.json['results'][0]['social']['ssrn'],
res.json['results'][1]['social']['ssrn'])
assert_not_equal(res.json['results'][0]['social']['github'],
res.json['results'][1]['social']['github'])
res = self.app.get(url, {'q': 'Uwase'})
assert_equal(res.status_code, 200)
assert_equal(len(res.json['results']), 1)
assert_true(res.json['results'][0]['social'])
assert_not_in('ssrn', res.json['results'][0]['social'])
assert_equal(res.json['results'][0]['social']['profileWebsites'][0],
'http://me.com/{}'.format(user_two.given_name))
assert_equal(
res.json['results'][0]['social']['impactStory'],
'https://impactstory.org/u/{}'.format(user_two.given_name))
assert_equal(res.json['results'][0]['social']['orcid'],
'http://orcid.org/{}'.format(user_two.given_name))
assert_equal(
res.json['results'][0]['social']['baiduScholar'],
'http://xueshu.baidu.com/scholarID/{}'.format(user_two.given_name))
assert_equal(res.json['results'][0]['social']['linkedIn'],
'https://www.linkedin.com/{}'.format(user_two.given_name))
assert_equal(
res.json['results'][0]['social']['scholar'],
'http://scholar.google.com/citations?user={}'.format(
user_two.given_name))
def test_no_login_presend_for_active_user(self, mock_mail):
user = factories.AuthUserFactory()
mail = self.queue_mail(mail=mails.NO_LOGIN, user=user)
user.date_last_login = timezone.now() + timedelta(seconds=10)
user.save()
assert_false(mail.send_mail())
def setUp(self):
OsfTestCase.setUp(self)
self.user = factories.AuthUserFactory()
self.user.is_registered = True
self.user.save()
