def test_unregistered_contributor_added_has_contributor_info_in_params(
self):
project = ProjectFactory(creator=self.user)
project.add_unregistered_contributor('Robert Jackson',
'*****@*****.**',
auth=Auth(self.user),
save=True)
unregistered_contributor = project.contributors[1]
relevant_log = project.logs[-1]
url = '/{}logs/{}/'.format(API_BASE, relevant_log._id)
res = self.app.get(url, auth=self.user.auth)
assert_equal(res.status_code, 200)
params = res.json['data']['attributes']['params']
params_node = params['params_node']
contributors = params['contributors'][0]
assert_equal(params_node['id'], project._id)
assert_equal(params_node['title'], project.title)
assert_equal(contributors['family_name'], 'Jackson')
assert_equal(contributors['full_name'], 'Robert Jackson')
assert_equal(contributors['given_name'], 'Robert')
assert_equal(contributors['unregistered_name'], 'Robert Jackson')
def test_unregistered_contributor_detail_show_up_as_name_associated_with_project(
self):
project = ProjectFactory(creator=self.user, public=True)
project.add_unregistered_contributor('Robert Jackson',
'*****@*****.**',
auth=Auth(self.user),
save=True)
unregistered_contributor = project.contributors[1]
url = '/{}nodes/{}/contributors/{}/'.format(
API_BASE, project._id, unregistered_contributor._id)
res = self.app.get(url, auth=self.user.auth, expect_errors=True)
assert_equal(res.status_code, 200)
assert_equal(
res.json['data']['embeds']['users']['data']['attributes']
['full_name'], 'Robert Jackson')
assert_equal(
res.json['data']['attributes'].get('unregistered_contributor'),
'Robert Jackson')
project_two = ProjectFactory(creator=self.user, public=True)
project_two.add_unregistered_contributor('Bob Jackson',
'*****@*****.**',
auth=Auth(self.user),
save=True)
url = '/{}nodes/{}/contributors/{}/'.format(
API_BASE, project_two._id, unregistered_contributor._id)
res = self.app.get(url, auth=self.user.auth, expect_errors=True)
assert_equal(res.status_code, 200)
assert_equal(
res.json['data']['embeds']['users']['data']['attributes']
['full_name'], 'Robert Jackson')
assert_equal(
res.json['data']['attributes'].get('unregistered_contributor'),
'Bob Jackson')
class TestUserGet(AdminTestCase):
def setUp(self):
super(TestUserGet, self).setUp()
User.remove()
self.user_1 = AuthUserFactory()
self.auth = Auth(user=self.user_1)
self.project = ProjectFactory(creator=self.user_1)
self.project.add_unregistered_contributor(
email='*****@*****.**',
fullname='Weezy F. Baby',
auth=self.auth
)
self.user_3 = AuthUserFactory()
self.user_3.date_confirmed = None
self.user_3.save()
self.user_4 = AuthUserFactory()
def test_get_all_user_count(self):
time_now = datetime.utcnow()
count = get_all_user_count(time_now)
nt.assert_equal(count, 4)
def test_get_unregistered_users(self):
count = get_unregistered_users()
nt.assert_equal(count, 1)
def test_get_recently_added_contributors(self):
project = ProjectFactory(creator=self.user)
project.add_contributor(AuthUserFactory(), auth=self.auth)
project.add_contributor(AuthUserFactory(), auth=self.auth)
# has one unregistered contributor
project.add_unregistered_contributor(fullname=fake.name(), email=fake.email(), auth=self.auth)
project.save()
url = self.project.api_url_for("get_recently_added_contributors")
res = self.app.get(url, auth=self.user.auth)
project.reload()
recent = [c for c in self.user.recently_added if c.is_active]
assert_equal(len(res.json["contributors"]), len(recent))
def test_unregistered_users_names_are_project_specific(self):
name1, name2, email = fake.name(), fake.name(), fake.email()
project2 = ProjectFactory(creator=self.referrer)
# different projects use different names for the same unreg contributor
self.project.add_unregistered_contributor(email=email, fullname=name1, auth=Auth(self.referrer))
self.project.save()
project2.add_unregistered_contributor(email=email, fullname=name2, auth=Auth(self.referrer))
project2.save()
self.app.authenticate(*self.referrer.auth)
# Each project displays a different name in the contributor list
res = self.app.get(self.project.url)
assert_in_html(name1, res)
res2 = self.app.get(project2.url)
assert_in_html(name2, res2)
def test_migrate_project_contributed(self):
user1 = UserFactory()
fullname1 = 'hello world'
email1 = '*****@*****.**'
project1 = ProjectFactory(creator=user1)
user2 = project1.add_unregistered_contributor(
fullname=fullname1, email=email1, auth=Auth(user=user1)
)
project1.save()
assert project1.is_contributor(user2) is True
assert len(project1.contributors) is 2
migrate_project_contributed(user2)
assert project1.is_contributor(user2) is False
assert len(project1.contributors) is 1
user3 = UserFactory()
project2 = ProjectFactory(creator=user1)
project2.add_contributor(user3)
project2.save()
assert project2.is_contributor(user3) is True
assert len(project2.contributors) is 2
migrate_project_contributed(user3)
assert project2.is_contributor(user3) is False
assert len(project2.contributors) is 1
def test_migrate_project_contributed(self):
user1 = UserFactory()
fullname1 = 'hello world'
email1 = '*****@*****.**'
project1 = ProjectFactory(creator=user1)
user2 = project1.add_unregistered_contributor(fullname=fullname1,
email=email1,
auth=Auth(user=user1))
project1.save()
assert project1.is_contributor(user2) is True
assert len(project1.contributors) is 2
migrate_project_contributed(user2)
assert project1.is_contributor(user2) is False
assert len(project1.contributors) is 1
user3 = UserFactory()
project2 = ProjectFactory(creator=user1)
project2.add_contributor(user3)
project2.save()
assert project2.is_contributor(user3) is True
assert len(project2.contributors) is 2
migrate_project_contributed(user3)
assert project2.is_contributor(user3) is False
assert len(project2.contributors) is 1
def test_do_migration(self):
user1 = UserFactory()
fullname1 = 'Presentation Service'
email1 = '*****@*****.**'
project1 = ProjectFactory(creator=user1)
user2 = project1.add_unregistered_contributor(fullname=fullname1,
email=email1,
auth=Auth(user=user1))
project1.save()
user3 = UserFactory.build(username='******',
fullname=fullname1)
user3.save()
project2 = ProjectFactory(creator=user1)
project2.add_contributor(user3)
project2.save()
assert project1.is_contributor(user2) is True
assert len(project1.contributors) is 2
assert project2.is_contributor(user3) is True
assert len(project2.contributors) is 2
user_list = get_targets()
do_migration(user_list)
assert project2.is_contributor(user3) is False
assert len(project2.contributors) is 1
assert project1.is_contributor(user2) is False
assert len(project1.contributors) is 1
assert user2.is_disabled is True
assert user3.is_disabled is True
class TestClaimingAsARegisteredUser(OsfTestCase):
def setUp(self):
super(TestClaimingAsARegisteredUser, self).setUp()
self.referrer = AuthUserFactory()
self.project = ProjectFactory(creator=self.referrer, is_public=True)
name, email = fake.name(), fake.email()
self.user = self.project.add_unregistered_contributor(fullname=name, email=email, auth=Auth(user=self.referrer))
self.project.save()
def test_claim_user_registered_with_correct_password(self):
reg_user = AuthUserFactory() # NOTE: AuthUserFactory sets password as 'password'
url = self.user.get_claim_url(self.project._primary_key)
# Follow to password re-enter page
res = self.app.get(url, auth=reg_user.auth).follow(auth=reg_user.auth)
# verify that the "Claim Account" form is returned
assert_in("Claim Contributor", res.body)
form = res.forms["claimContributorForm"]
form["password"] = "******"
res = form.submit(auth=reg_user.auth).follow(auth=reg_user.auth)
self.project.reload()
self.user.reload()
# user is now a contributor to the project
assert_in(reg_user._primary_key, self.project.contributors)
# the unregistered user (self.user) is removed as a contributor, and their
assert_not_in(self.user._primary_key, self.project.contributors)
# unclaimed record for the project has been deleted
assert_not_in(self.project._primary_key, self.user.unclaimed_records)
def test_do_migration(self):
user1 = UserFactory()
fullname1 = 'Presentation Service'
email1 = '*****@*****.**'
project1 = ProjectFactory(creator=user1)
user2 = project1.add_unregistered_contributor(
fullname=fullname1, email=email1, auth=Auth(user=user1)
)
project1.save()
user3 = UserFactory.build(username='******', fullname=fullname1)
user3.save()
project2 = ProjectFactory(creator=user1)
project2.add_contributor(user3)
project2.save()
assert project1.is_contributor(user2) is True
assert len(project1.contributors) is 2
assert project2.is_contributor(user3) is True
assert len(project2.contributors) is 2
user_list = get_targets()
do_migration(user_list)
assert project2.is_contributor(user3) is False
assert len(project2.contributors) is 1
assert project1.is_contributor(user2) is False
assert len(project1.contributors) is 1
assert user2.is_disabled is True
assert user3.is_disabled is True
class TestClaimingAsARegisteredUser(OsfTestCase):
def setUp(self):
super(TestClaimingAsARegisteredUser, self).setUp()
self.referrer = AuthUserFactory()
self.project = ProjectFactory(creator=self.referrer, is_public=True)
name, email = fake.name(), fake.email()
self.user = self.project.add_unregistered_contributor(
fullname=name, email=email, auth=Auth(user=self.referrer))
self.project.save()
def test_claim_user_registered_with_correct_password(self):
reg_user = AuthUserFactory()
reg_user.set_password('killerqueen')
reg_user.save()
url = self.user.get_claim_url(self.project._primary_key)
# Follow to password re-enter page
res = self.app.get(url, auth=reg_user.auth).follow(auth=reg_user.auth)
# verify that the "Claim Account" form is returned
assert_in('Claim Contributor', res.body)
form = res.forms['claimContributorForm']
form['password'] = '******'
res = form.submit(auth=reg_user.auth).follow(auth=reg_user.auth)
self.project.reload()
self.user.reload()
# user is now a contributor to the project
assert_in(reg_user._primary_key, self.project.contributors)
# the unregistered user (self.user) is removed as a contributor, and their
assert_not_in(self.user._primary_key, self.project.contributors)
# unclaimed record for the project has been deleted
assert_not_in(self.project._primary_key, self.user.unclaimed_records)
def test_get_recently_added_contributors(self):
project = ProjectFactory(creator=self.user)
project.add_contributor(AuthUserFactory(), auth=self.auth)
project.add_contributor(AuthUserFactory(), auth=self.auth)
# has one unregistered contributor
project.add_unregistered_contributor(
fullname=fake.name(),
email=fake.email(),
auth=self.auth,
)
project.save()
url = self.project.api_url_for('get_recently_added_contributors')
res = self.app.get(url, auth=self.user.auth)
project.reload()
recent = [c for c in self.user.recently_added if c.is_active()]
assert_equal(len(res.json['contributors']), len(recent))
def test_unregistered_contributor_detail_show_up_as_name_associated_with_project(self):
project = ProjectFactory(creator=self.user, public=True)
project.add_unregistered_contributor('Robert Jackson', '*****@*****.**', auth=Auth(self.user), save=True)
unregistered_contributor = project.contributors[1]
url = '/{}nodes/{}/contributors/{}/'.format(API_BASE, project._id, unregistered_contributor._id)
res = self.app.get(url, auth=self.user.auth, expect_errors=True)
assert_equal(res.status_code, 200)
assert_equal(res.json['data']['embeds']['users']['data']['attributes']['full_name'], 'Robert Jackson')
assert_equal(res.json['data']['attributes'].get('unregistered_contributor'), 'Robert Jackson')
project_two = ProjectFactory(creator=self.user, public=True)
project_two.add_unregistered_contributor('Bob Jackson', '*****@*****.**', auth=Auth(self.user), save=True)
url = '/{}nodes/{}/contributors/{}/'.format(API_BASE, project_two._id, unregistered_contributor._id)
res = self.app.get(url, auth=self.user.auth, expect_errors=True)
assert_equal(res.status_code, 200)
assert_equal(res.json['data']['embeds']['users']['data']['attributes']['full_name'], 'Robert Jackson')
assert_equal(res.json['data']['attributes'].get('unregistered_contributor'), 'Bob Jackson')
def test_unregistered_users_names_are_project_specific(self):
name1, name2, email = fake.name(), fake.name(), fake.email()
project2 = ProjectFactory(creator=self.referrer)
# different projects use different names for the same unreg contributor
self.project.add_unregistered_contributor(email=email,
fullname=name1,
auth=Auth(self.referrer))
self.project.save()
project2.add_unregistered_contributor(email=email,
fullname=name2,
auth=Auth(self.referrer))
project2.save()
self.app.authenticate(*self.referrer.auth)
# Each project displays a different name in the contributor list
res = self.app.get(self.project.url)
assert_in(name1, res)
res2 = self.app.get(project2.url)
assert_in(name2, res2)
def test_unregistered_contributor_added_has_contributor_info_in_params(self):
project = ProjectFactory(creator=self.user)
project.add_unregistered_contributor('Robert Jackson', '*****@*****.**', auth=Auth(self.user), save=True)
unregistered_contributor = project.contributors[1]
relevant_log = project.logs[-1]
url = '/{}logs/{}/'.format(API_BASE, relevant_log._id)
res = self.app.get(url, auth=self.user.auth)
assert_equal(res.status_code, 200)
params = res.json['data']['attributes']['params']
params_node = params['params_node']
contributors = params['contributors'][0]
assert_equal(params_node['id'], project._id)
assert_equal(params_node['title'], project.title)
assert_equal(contributors['family_name'], 'Jackson')
assert_equal(contributors['full_name'], 'Robert Jackson')
assert_equal(contributors['given_name'], 'Robert')
assert_equal(contributors['unregistered_name'], 'Robert Jackson')
class TestClaiming(OsfTestCase):
def setUp(self):
super(TestClaiming, self).setUp()
self.referrer = AuthUserFactory()
self.project = ProjectFactory(creator=self.referrer, is_public=True)
def test_correct_name_shows_in_contributor_list(self):
name1, email = fake.name(), fake.email()
UnregUserFactory(fullname=name1, email=email)
name2, email = fake.name(), fake.email()
# Added with different name
self.project.add_unregistered_contributor(fullname=name2,
email=email,
auth=Auth(self.referrer))
self.project.save()
res = self.app.get(self.project.url, auth=self.referrer.auth)
# Correct name is shown
assert_in(name2, res)
assert_not_in(name1, res)
def test_user_can_set_password_on_claim_page(self):
name, email = fake.name(), fake.email()
new_user = self.project.add_unregistered_contributor(
email=email, fullname=name, auth=Auth(self.referrer))
self.project.save()
claim_url = new_user.get_claim_url(self.project._primary_key)
res = self.app.get(claim_url)
self.project.reload()
assert_in('Set Password', res)
form = res.forms['setPasswordForm']
#form['username'] = new_user.username #Removed as long as E-mail can't be updated.
form['password'] = '******'
form['password2'] = 'killerqueen'
res = form.submit().follow()
new_user.reload()
assert_true(new_user.check_password('killerqueen'))
def test_sees_is_redirected_if_user_already_logged_in(self):
name, email = fake.name(), fake.email()
new_user = self.project.add_unregistered_contributor(
email=email, fullname=name, auth=Auth(self.referrer))
self.project.save()
existing = AuthUserFactory()
claim_url = new_user.get_claim_url(self.project._primary_key)
# a user is already logged in
res = self.app.get(claim_url, auth=existing.auth, expect_errors=True)
assert_equal(res.status_code, 302)
def test_unregistered_users_names_are_project_specific(self):
name1, name2, email = fake.name(), fake.name(), fake.email()
project2 = ProjectFactory(creator=self.referrer)
# different projects use different names for the same unreg contributor
self.project.add_unregistered_contributor(email=email,
fullname=name1,
auth=Auth(self.referrer))
self.project.save()
project2.add_unregistered_contributor(email=email,
fullname=name2,
auth=Auth(self.referrer))
project2.save()
self.app.authenticate(*self.referrer.auth)
# Each project displays a different name in the contributor list
res = self.app.get(self.project.url)
assert_in(name1, res)
res2 = self.app.get(project2.url)
assert_in(name2, res2)
@unittest.skip("as long as E-mails cannot be changed")
def test_cannot_set_email_to_a_user_that_already_exists(self):
reg_user = UserFactory()
name, email = fake.name(), fake.email()
new_user = self.project.add_unregistered_contributor(
email=email, fullname=name, auth=Auth(self.referrer))
self.project.save()
# Goes to claim url and successfully claims account
claim_url = new_user.get_claim_url(self.project._primary_key)
res = self.app.get(claim_url)
self.project.reload()
assert_in('Set Password', res)
form = res.forms['setPasswordForm']
# Fills out an email that is the username of another user
form['username'] = reg_user.username
form['password'] = '******'
form['password2'] = 'killerqueen'
res = form.submit().maybe_follow(expect_errors=True)
assert_in(language.ALREADY_REGISTERED.format(email=reg_user.username),
res)
def test_correct_display_name_is_shown_at_claim_page(self):
original_name = fake.name()
unreg = UnregUserFactory(fullname=original_name)
different_name = fake.name()
new_user = self.project.add_unregistered_contributor(
email=unreg.username,
fullname=different_name,
auth=Auth(self.referrer),
)
self.project.save()
claim_url = new_user.get_claim_url(self.project._primary_key)
res = self.app.get(claim_url)
# Correct name (different_name) should be on page
assert_in(different_name, res)
class TestContributorViews(OsfTestCase):
def setUp(self):
super(TestContributorViews, self).setUp()
self.user = AuthUserFactory()
self.auth = Auth(user=self.user)
self.project = ProjectFactory(creator=self.user)
def test_get_contributors_no_limit(self):
self.project.add_contributor(
AuthUserFactory(),
auth=self.auth,
visible=True,
)
self.project.add_contributor(
AuthUserFactory(),
auth=self.auth,
visible=False,
)
self.project.save()
url = self.project.api_url_for('get_contributors')
res = self.app.get(url, auth=self.user.auth)
# Should be two visible contributors on the project
assert_equal(
len(res.json['contributors']),
2,
)
def test_get_contributors_with_limit(self):
# Add five contributors
self.project.add_contributor(
AuthUserFactory(),
auth=self.auth,
visible=True,
)
self.project.add_contributor(
AuthUserFactory(),
auth=self.auth,
visible=True,
)
self.project.add_contributor(
AuthUserFactory(),
auth=self.auth,
visible=True,
)
self.project.add_contributor(
AuthUserFactory(),
auth=self.auth,
visible=True,
)
self.project.add_contributor(
AuthUserFactory(),
auth=self.auth,
visible=False,
)
self.project.save()
# Set limit to three contributors
url = self.project.api_url_for('get_contributors', limit=3)
res = self.app.get(url, auth=self.user.auth)
# Should be three visible contributors on the project
assert_equal(
len(res.json['contributors']),
3,
)
# There should be two 'more' contributors not shown
assert_equal(
(res.json['more']),
2,
)
def test_get_contributors_from_parent(self):
self.project.add_contributor(
AuthUserFactory(),
auth=self.auth,
visible=True,
)
self.project.add_contributor(
AuthUserFactory(),
auth=self.auth,
visible=False,
)
self.project.save()
component = NodeFactory(parent=self.project, creator=self.user)
url = component.api_url_for('get_contributors_from_parent')
res = self.app.get(url, auth=self.user.auth)
# Should be one contributor to the parent who is both visible and
# not a contributor on the component
assert_equal(
len(res.json['contributors']),
1,
)
def test_get_most_in_common_contributors(self):
# project 1 (contrib 1, contrib 2, unreg_contrib 3)
# - component 1 (contrib 1)
# project 2 - add should show contrib 1 first (2 links), contrib 2 second (1 link)
contributor_1 = AuthUserFactory()
contributor_2 = AuthUserFactory()
self.project.add_contributor(contributor_1, auth=self.auth)
self.project.add_contributor(contributor_2, auth=self.auth)
# has one unregistered contributor
self.project.add_unregistered_contributor(
fullname=fake.name(),
email=fake.email(),
auth=self.auth,
)
self.project.save()
component = NodeFactory(parent=self.project, creator=self.user)
component.add_contributor(contributor_1, auth=self.auth)
component.save()
project_2 = ProjectFactory(creator=self.user)
project_2.add_contributor(contributor_1, auth=self.auth)
url = project_2.api_url_for('get_most_in_common_contributors')
res = self.app.get(url, auth=self.user.auth)
project_2.reload()
res_contribs = res.json['contributors']
assert_equal(len(res.json['contributors']), 2)
assert_equal(contributor_1._id, res_contribs[0]['id'])
assert_equal(res_contribs[0]['n_projects_in_common'], 2)
assert_equal(contributor_2._id, res_contribs[1]['id'])
assert_equal(res_contribs[1]['n_projects_in_common'], 1)
def test_get_recently_added_contributors(self):
project = ProjectFactory(creator=self.user)
project.add_contributor(AuthUserFactory(), auth=self.auth)
project.add_contributor(AuthUserFactory(), auth=self.auth)
# has one unregistered contributor
project.add_unregistered_contributor(
fullname=fake.name(),
email=fake.email(),
auth=self.auth,
)
project.save()
url = self.project.api_url_for('get_recently_added_contributors')
res = self.app.get(url, auth=self.user.auth)
project.reload()
recent = [c for c in self.user.recently_added if c.is_active]
assert_equal(len(res.json['contributors']), len(recent))
def test_get_recently_added_contributors_with_limit(self):
project = ProjectFactory(creator=self.user)
for _ in range(5):
project.add_contributor(AuthUserFactory(), auth=self.auth)
project.save()
url = self.project.api_url_for('get_recently_added_contributors', max=4)
res = self.app.get(url, auth=self.user.auth)
project.reload()
assert_equal(len(res.json['contributors']), 4)
class TestContributorViews(OsfTestCase):
def setUp(self):
super(TestContributorViews, self).setUp()
self.user = AuthUserFactory()
self.auth = Auth(user=self.user)
self.project = ProjectFactory(creator=self.user)
def test_get_contributors_no_limit(self):
self.project.add_contributor(
AuthUserFactory(),
auth=self.auth,
visible=True,
)
self.project.add_contributor(
AuthUserFactory(),
auth=self.auth,
visible=False,
)
self.project.save()
url = self.project.api_url_for('get_contributors')
res = self.app.get(url, auth=self.user.auth)
# Should be two visible contributors on the project
assert_equal(
len(res.json['contributors']),
2,
)
def test_get_contributors_with_limit(self):
# Add five contributors
self.project.add_contributor(
AuthUserFactory(),
auth=self.auth,
visible=True,
)
self.project.add_contributor(
AuthUserFactory(),
auth=self.auth,
visible=True,
)
self.project.add_contributor(
AuthUserFactory(),
auth=self.auth,
visible=True,
)
self.project.add_contributor(
AuthUserFactory(),
auth=self.auth,
visible=True,
)
self.project.add_contributor(
AuthUserFactory(),
auth=self.auth,
visible=False,
)
self.project.save()
# Set limit to three contributors
url = self.project.api_url_for('get_contributors', limit=3)
res = self.app.get(url, auth=self.user.auth)
# Should be three visible contributors on the project
assert_equal(
len(res.json['contributors']),
3,
)
# There should be two 'more' contributors not shown
assert_equal(
(res.json['more']),
2,
)
def test_get_contributors_from_parent(self):
self.project.add_contributor(
AuthUserFactory(),
auth=self.auth,
visible=True,
)
self.project.add_contributor(
AuthUserFactory(),
auth=self.auth,
visible=False,
)
self.project.save()
component = NodeFactory(parent=self.project, creator=self.user)
url = component.api_url_for('get_contributors_from_parent')
res = self.app.get(url, auth=self.user.auth)
# Should be one contributor to the parent who is both visible and
# not a contributor on the component
assert_equal(
len(res.json['contributors']),
1,
)
def test_get_most_in_common_contributors(self):
# project 1 (contrib 1, contrib 2, unreg_contrib 3)
# - component 1 (contrib 1)
# project 2 - add should show contrib 1 first (2 links), contrib 2 second (1 link)
contributor_1 = AuthUserFactory()
contributor_2 = AuthUserFactory()
self.project.add_contributor(contributor_1, auth=self.auth)
self.project.add_contributor(contributor_2, auth=self.auth)
# has one unregistered contributor
self.project.add_unregistered_contributor(
fullname=fake.name(),
email=fake.email(),
auth=self.auth,
)
self.project.save()
component = NodeFactory(parent=self.project, creator=self.user)
component.add_contributor(contributor_1, auth=self.auth)
component.save()
project_2 = ProjectFactory(creator=self.user)
project_2.add_contributor(contributor_1, auth=self.auth)
url = project_2.api_url_for('get_most_in_common_contributors')
res = self.app.get(url, auth=self.user.auth)
project_2.reload()
res_contribs = res.json['contributors']
assert_equal(len(res.json['contributors']), 2)
assert_equal(contributor_1._id, res_contribs[0]['id'])
assert_equal(res_contribs[0]['n_projects_in_common'], 2)
assert_equal(contributor_2._id, res_contribs[1]['id'])
assert_equal(res_contribs[1]['n_projects_in_common'], 1)
def test_get_recently_added_contributors(self):
project = ProjectFactory(creator=self.user)
project.add_contributor(AuthUserFactory(), auth=self.auth)
project.add_contributor(AuthUserFactory(), auth=self.auth)
# has one unregistered contributor
project.add_unregistered_contributor(
fullname=fake.name(),
email=fake.email(),
auth=self.auth,
)
project.save()
url = self.project.api_url_for('get_recently_added_contributors')
res = self.app.get(url, auth=self.user.auth)
project.reload()
recent = [c for c in self.user.recently_added if c.is_active()]
assert_equal(len(res.json['contributors']), len(recent))
def test_get_recently_added_contributors_with_limit(self):
project = ProjectFactory(creator=self.user)
for _ in range(5):
project.add_contributor(AuthUserFactory(), auth=self.auth)
project.save()
url = self.project.api_url_for('get_recently_added_contributors',
max=4)
res = self.app.get(url, auth=self.user.auth)
project.reload()
assert_equal(len(res.json['contributors']), 4)
class TestClaiming(OsfTestCase):
def setUp(self):
super(TestClaiming, self).setUp()
self.referrer = AuthUserFactory()
self.project = ProjectFactory(creator=self.referrer, is_public=True)
def test_correct_name_shows_in_contributor_list(self):
name1, email = fake.name(), fake.email()
UnregUserFactory(fullname=name1, email=email)
name2, email = fake.name(), fake.email()
# Added with different name
self.project.add_unregistered_contributor(fullname=name2,
email=email, auth=Auth(self.referrer))
self.project.save()
res = self.app.get(self.project.url, auth=self.referrer.auth)
# Correct name is shown
assert_in(name2, res)
assert_not_in(name1, res)
def test_user_can_set_password_on_claim_page(self):
name, email = fake.name(), fake.email()
new_user = self.project.add_unregistered_contributor(
email=email,
fullname=name,
auth=Auth(self.referrer)
)
self.project.save()
claim_url = new_user.get_claim_url(self.project._primary_key)
res = self.app.get(claim_url)
self.project.reload()
assert_in('Set Password', res)
form = res.forms['setPasswordForm']
form['username'] = new_user.username
form['password'] = '******'
form['password2'] = 'killerqueen'
res = form.submit().maybe_follow()
new_user.reload()
# at settings page
assert_equal(res.request.path, '/settings/')
assert_in('Welcome to the OSF', res)
def test_sees_is_redirected_if_user_already_logged_in(self):
name, email = fake.name(), fake.email()
new_user = self.project.add_unregistered_contributor(
email=email,
fullname=name,
auth=Auth(self.referrer)
)
self.project.save()
existing = AuthUserFactory()
claim_url = new_user.get_claim_url(self.project._primary_key)
# a user is already logged in
res = self.app.get(claim_url, auth=existing.auth, expect_errors=True)
assert_equal(res.status_code, 302)
def test_unregistered_users_names_are_project_specific(self):
name1, name2, email = fake.name(), fake.name(), fake.email()
project2 = ProjectFactory(creator=self.referrer)
# different projects use different names for the same unreg contributor
self.project.add_unregistered_contributor(
email=email,
fullname=name1,
auth=Auth(self.referrer)
)
self.project.save()
project2.add_unregistered_contributor(
email=email,
fullname=name2,
auth=Auth(self.referrer)
)
project2.save()
self.app.authenticate(*self.referrer.auth)
# Each project displays a different name in the contributor list
res = self.app.get(self.project.url)
assert_in(name1, res)
res2 = self.app.get(project2.url)
assert_in(name2, res2)
def test_unregistered_user_can_create_an_account(self):
# User is added as an unregistered contributor to a project
email, name = fake.email(), fake.name()
self.project.add_unregistered_contributor(
email=email,
fullname=name,
auth=Auth(self.referrer)
)
self.project.save()
# Goes to registration page (instead of claiming their email)
res = self.app.get('/account/').maybe_follow()
form = res.forms['registerForm']
form['register-fullname'] = name
form['register-username'] = email
form['register-username2'] = email
form['register-password'] = '******'
form['register-password2'] = 'example'
res = form.submit()
# registered successfully
assert_in(language.REGISTRATION_SUCCESS.format(email=email), res)
def test_cannot_go_to_claim_url_after_setting_password(self):
name, email = fake.name(), fake.email()
new_user = self.project.add_unregistered_contributor(
email=email,
fullname=name,
auth=Auth(self.referrer)
)
self.project.save()
# Goes to claim url and successfully claims account
claim_url = new_user.get_claim_url(self.project._primary_key)
res = self.app.get(claim_url)
self.project.reload()
assert_in('Set Password', res)
form = res.forms['setPasswordForm']
form['username'] = new_user.username
form['password'] = '******'
form['password2'] = 'killerqueen'
res = form.submit().maybe_follow()
# logs out
res = self.app.get('/logout/').maybe_follow()
# tries to go to claim url again
res = self.app.get(claim_url, expect_errors=True)
assert_equal(res.status_code, 400)
assert_in('already been claimed', res)
def test_cannot_set_email_to_a_user_that_already_exists(self):
reg_user = UserFactory()
name, email = fake.name(), fake.email()
new_user = self.project.add_unregistered_contributor(
email=email,
fullname=name,
auth=Auth(self.referrer)
)
self.project.save()
# Goes to claim url and successfully claims account
claim_url = new_user.get_claim_url(self.project._primary_key)
res = self.app.get(claim_url)
self.project.reload()
assert_in('Set Password', res)
form = res.forms['setPasswordForm']
# Fills out an email that is the username of another user
form['username'] = reg_user.username
form['password'] = '******'
form['password2'] = 'killerqueen'
res = form.submit().maybe_follow(expect_errors=True)
assert_in(
language.ALREADY_REGISTERED.format(email=reg_user.username),
res
)
def test_correct_display_name_is_shown_at_claim_page(self):
original_name = fake.name()
unreg = UnregUserFactory(fullname=original_name)
different_name = fake.name()
new_user = self.project.add_unregistered_contributor(
email=unreg.username,
fullname=different_name,
auth=Auth(self.referrer),
)
self.project.save()
claim_url = new_user.get_claim_url(self.project._primary_key)
res = self.app.get(claim_url)
# Correct name (different_name) should be on page
assert_in(different_name, res)
class TestClaimingAsARegisteredUser(OsfTestCase):
def setUp(self):
super(TestClaimingAsARegisteredUser, self).setUp()
self.referrer = AuthUserFactory()
self.project = ProjectFactory(creator=self.referrer, is_public=True)
name, email = fake.name(), fake.email()
self.user = self.project.add_unregistered_contributor(
fullname=name, email=email, auth=Auth(user=self.referrer))
self.project.save()
@mock.patch('website.project.views.contributor.session')
def test_user_with_claim_url_registers_new_account(self, mock_session):
# Assume that the unregistered user data is already stored in the session
mock_session.data = {
'unreg_user': {
'uid':
self.user._primary_key,
'pid':
self.project._primary_key,
'token':
self.user.get_unclaimed_record(
self.project._primary_key)['token']
}
}
res2 = self.app.get('/account/')
# Fills in Register form
form = res2.forms['registerForm']
form['register-fullname'] = 'tester'
form['register-username'] = '******'
form['register-username2'] = '*****@*****.**'
form['register-password'] = '******'
form['register-password2'] = 'testing'
res3 = form.submit()
assert_in('Registration successful.', res3.body)
assert_in('Successfully claimed contributor', res3.body)
u = User.find(Q('username', 'eq', '*****@*****.**'))[0]
key = ApiKeyFactory()
u.api_keys.append(key)
u.save()
u.auth = ('test', key._primary_key)
self.app.get(
u.get_confirmation_url('*****@*****.**')).follow(auth=u.auth)
# Confirms their email address
self.project.reload()
self.user.reload()
u.reload()
assert_not_in(self.user._primary_key, self.project.contributors)
assert_equal(2, len(self.project.contributors))
# user is now a contributor to self.project
assert_in(u._primary_key, self.project.contributors)
@mock.patch('website.project.views.contributor.session')
def test_user_can_log_in_with_a_different_account(self, mock_session):
# Assume that the unregistered user data is already stored in the session
mock_session.data = {
'unreg_user': {
'uid':
self.user._primary_key,
'pid':
self.project._primary_key,
'token':
self.user.get_unclaimed_record(
self.project._primary_key)['token']
}
}
right_user = AuthUserFactory.build(fullname="Right User")
right_user.set_password('science')
right_user.save()
# User goes to the claim page, but a different user (lab_user) is logged in
lab_user = AuthUserFactory(fullname="Lab Comp")
url = self.user.get_claim_url(self.project._primary_key)
res = self.app.get(url, auth=lab_user.auth).follow(auth=lab_user.auth)
# verify that the "Claim Account" form is returned
assert_in('Claim Contributor', res.body)
# Clicks "I am not Lab Comp"
# Taken to login/register page
res2 = res.click(linkid='signOutLink', auth=lab_user.auth)
# Fills in log in form
form = res2.forms['signinForm']
form['username'] = right_user.username
form['password'] = '******'
# submits
res3 = form.submit().follow()
# Back at claim contributor page
assert_in('Claim Contributor', res3)
# Verifies their password
form = res3.forms['claimContributorForm']
form['password'] = '******'
form.submit()
self.project.reload()
right_user.reload()
self.user.reload()
# user is now a contributor to self.project
assert_in(right_user._primary_key, self.project.contributors)
# lab user is not a contributor
assert_not_in(lab_user._primary_key, self.project.contributors)
def test_claim_user_registered_with_correct_password(self):
reg_user = AuthUserFactory()
reg_user.set_password('killerqueen')
reg_user.save()
url = self.user.get_claim_url(self.project._primary_key)
# Follow to password re-enter page
res = self.app.get(url, auth=reg_user.auth).follow(auth=reg_user.auth)
# verify that the "Claim Account" form is returned
assert_in('Claim Contributor', res.body)
form = res.forms['claimContributorForm']
form['password'] = '******'
res = form.submit(auth=reg_user.auth).follow(auth=reg_user.auth)
self.project.reload()
self.user.reload()
# user is now a contributor to the project
assert_in(reg_user._primary_key, self.project.contributors)
# the unregistered user (self.user) is removed as a contributor, and their
assert_not_in(self.user._primary_key, self.project.contributors)
# unclaimed record for the project has been deleted
assert_not_in(self.project._primary_key, self.user.unclaimed_records)
class TestClaimingAsARegisteredUser(OsfTestCase):
def setUp(self):
super(TestClaimingAsARegisteredUser, self).setUp()
self.referrer = AuthUserFactory()
self.project = ProjectFactory(creator=self.referrer, is_public=True)
name, email = fake.name(), fake.email()
self.user = self.project.add_unregistered_contributor(
fullname=name,
email=email,
auth=Auth(user=self.referrer)
)
self.project.save()
@mock.patch('website.project.views.contributor.session')
def test_user_with_claim_url_registers_new_account(self, mock_session):
# Assume that the unregistered user data is already stored in the session
mock_session.data = {
'unreg_user': {
'uid': self.user._primary_key,
'pid': self.project._primary_key,
'token': self.user.get_unclaimed_record(
self.project._primary_key)['token']
}
}
res2 = self.app.get('/account/')
# Fills in Register form
form = res2.forms['registerForm']
form['register-fullname'] = 'tester'
form['register-username'] = '******'
form['register-username2'] = '*****@*****.**'
form['register-password'] = '******'
form['register-password2'] = 'testing'
res3 = form.submit()
assert_in('Registration successful.', res3.body)
assert_in('Successfully claimed contributor', res3.body)
u = User.find(Q('username', 'eq', '*****@*****.**'))[0]
key = ApiKeyFactory()
u.api_keys.append(key)
u.save()
u.auth = ('test', key._primary_key)
self.app.get(u.get_confirmation_url('*****@*****.**')).follow(auth=u.auth)
# Confirms their email address
self.project.reload()
self.user.reload()
u.reload()
assert_not_in(self.user._primary_key, self.project.contributors)
assert_equal(2, len(self.project.contributors))
# user is now a contributor to self.project
assert_in(u._primary_key, self.project.contributors)
@mock.patch('website.project.views.contributor.session')
def test_user_can_log_in_with_a_different_account(self, mock_session):
# Assume that the unregistered user data is already stored in the session
mock_session.data = {
'unreg_user': {
'uid': self.user._primary_key,
'pid': self.project._primary_key,
'token': self.user.get_unclaimed_record(
self.project._primary_key)['token']
}
}
right_user = AuthUserFactory.build(fullname="Right User")
right_user.set_password('science')
right_user.save()
# User goes to the claim page, but a different user (lab_user) is logged in
lab_user = AuthUserFactory(fullname="Lab Comp")
url = self.user.get_claim_url(self.project._primary_key)
res = self.app.get(url, auth=lab_user.auth).follow(auth=lab_user.auth)
# verify that the "Claim Account" form is returned
assert_in('Claim Contributor', res.body)
# Clicks "I am not Lab Comp"
# Taken to login/register page
res2 = res.click(linkid='signOutLink', auth=lab_user.auth)
# Fills in log in form
form = res2.forms['signinForm']
form['username'] = right_user.username
form['password'] = '******'
# submits
res3 = form.submit().follow()
# Back at claim contributor page
assert_in('Claim Contributor', res3)
# Verifies their password
form = res3.forms['claimContributorForm']
form['password'] = '******'
form.submit()
self.project.reload()
right_user.reload()
self.user.reload()
# user is now a contributor to self.project
assert_in(right_user._primary_key, self.project.contributors)
# lab user is not a contributor
assert_not_in(lab_user._primary_key, self.project.contributors)
def test_claim_user_registered_with_correct_password(self):
reg_user = AuthUserFactory()
reg_user.set_password('killerqueen')
reg_user.save()
url = self.user.get_claim_url(self.project._primary_key)
# Follow to password re-enter page
res = self.app.get(url, auth=reg_user.auth).follow(auth=reg_user.auth)
# verify that the "Claim Account" form is returned
assert_in('Claim Contributor', res.body)
form = res.forms['claimContributorForm']
form['password'] = '******'
res = form.submit(auth=reg_user.auth).follow(auth=reg_user.auth)
self.project.reload()
self.user.reload()
# user is now a contributor to the project
assert_in(reg_user._primary_key, self.project.contributors)
# the unregistered user (self.user) is removed as a contributor, and their
assert_not_in(self.user._primary_key, self.project.contributors)
# unclaimed record for the project has been deleted
assert_not_in(self.project._primary_key, self.user.unclaimed_records)
class TestClaiming(OsfTestCase):
def setUp(self):
super(TestClaiming, self).setUp()
self.referrer = AuthUserFactory()
self.project = ProjectFactory(creator=self.referrer, is_public=True)
def test_correct_name_shows_in_contributor_list(self):
name1, email = fake.name(), fake.email()
UnregUserFactory(fullname=name1, email=email)
name2, email = fake.name(), fake.email()
# Added with different name
self.project.add_unregistered_contributor(fullname=name2,
email=email, auth=Auth(self.referrer))
self.project.save()
res = self.app.get(self.project.url, auth=self.referrer.auth)
# Correct name is shown
assert_in_html(name2, res)
assert_not_in(name1, res)
def test_user_can_set_password_on_claim_page(self):
name, email = fake.name(), fake.email()
new_user = self.project.add_unregistered_contributor(
email=email,
fullname=name,
auth=Auth(self.referrer)
)
self.project.save()
claim_url = new_user.get_claim_url(self.project._primary_key)
res = self.app.get(claim_url)
self.project.reload()
assert_in('Set Password', res)
form = res.forms['setPasswordForm']
#form['username'] = new_user.username #Removed as long as E-mail can't be updated.
form['password'] = '******'
form['password2'] = 'killerqueen'
res = form.submit().follow()
new_user.reload()
assert_true(new_user.check_password('killerqueen'))
def test_sees_is_redirected_if_user_already_logged_in(self):
name, email = fake.name(), fake.email()
new_user = self.project.add_unregistered_contributor(
email=email,
fullname=name,
auth=Auth(self.referrer)
)
self.project.save()
existing = AuthUserFactory()
claim_url = new_user.get_claim_url(self.project._primary_key)
# a user is already logged in
res = self.app.get(claim_url, auth=existing.auth, expect_errors=True)
assert_equal(res.status_code, 302)
def test_unregistered_users_names_are_project_specific(self):
name1, name2, email = fake.name(), fake.name(), fake.email()
project2 = ProjectFactory(creator=self.referrer)
# different projects use different names for the same unreg contributor
self.project.add_unregistered_contributor(
email=email,
fullname=name1,
auth=Auth(self.referrer)
)
self.project.save()
project2.add_unregistered_contributor(
email=email,
fullname=name2,
auth=Auth(self.referrer)
)
project2.save()
self.app.authenticate(*self.referrer.auth)
# Each project displays a different name in the contributor list
res = self.app.get(self.project.url)
assert_in_html(name1, res)
res2 = self.app.get(project2.url)
assert_in_html(name2, res2)
@unittest.skip("as long as E-mails cannot be changed")
def test_cannot_set_email_to_a_user_that_already_exists(self):
reg_user = UserFactory()
name, email = fake.name(), fake.email()
new_user = self.project.add_unregistered_contributor(
email=email,
fullname=name,
auth=Auth(self.referrer)
)
self.project.save()
# Goes to claim url and successfully claims account
claim_url = new_user.get_claim_url(self.project._primary_key)
res = self.app.get(claim_url)
self.project.reload()
assert_in('Set Password', res)
form = res.forms['setPasswordForm']
# Fills out an email that is the username of another user
form['username'] = reg_user.username
form['password'] = '******'
form['password2'] = 'killerqueen'
res = form.submit().maybe_follow(expect_errors=True)
assert_in(
language.ALREADY_REGISTERED.format(email=reg_user.username),
res
)
def test_correct_display_name_is_shown_at_claim_page(self):
original_name = fake.name()
unreg = UnregUserFactory(fullname=original_name)
different_name = fake.name()
new_user = self.project.add_unregistered_contributor(
email=unreg.username,
fullname=different_name,
auth=Auth(self.referrer),
)
self.project.save()
claim_url = new_user.get_claim_url(self.project._primary_key)
res = self.app.get(claim_url)
# Correct name (different_name) should be on page
assert_in_html(different_name, res)
class TestClaiming(OsfTestCase):
def setUp(self):
super(TestClaiming, self).setUp()
self.referrer = AuthUserFactory()
self.project = ProjectFactory(creator=self.referrer, is_public=True)
def test_correct_name_shows_in_contributor_list(self):
name1, email = fake.name(), fake.email()
UnregUserFactory(fullname=name1, email=email)
name2, email = fake.name(), fake.email()
# Added with different name
self.project.add_unregistered_contributor(fullname=name2,
email=email,
auth=Auth(self.referrer))
self.project.save()
res = self.app.get(self.project.url, auth=self.referrer.auth)
# Correct name is shown
assert_in(name2, res)
assert_not_in(name1, res)
def test_user_can_set_password_on_claim_page(self):
name, email = fake.name(), fake.email()
new_user = self.project.add_unregistered_contributor(
email=email, fullname=name, auth=Auth(self.referrer))
self.project.save()
claim_url = new_user.get_claim_url(self.project._primary_key)
res = self.app.get(claim_url)
self.project.reload()
assert_in('Set Password', res)
form = res.forms['setPasswordForm']
form['username'] = new_user.username
form['password'] = '******'
form['password2'] = 'killerqueen'
res = form.submit().maybe_follow()
new_user.reload()
# at settings page
assert_equal(res.request.path, '/settings/')
assert_in('Welcome to the OSF', res)
def test_sees_is_redirected_if_user_already_logged_in(self):
name, email = fake.name(), fake.email()
new_user = self.project.add_unregistered_contributor(
email=email, fullname=name, auth=Auth(self.referrer))
self.project.save()
existing = AuthUserFactory()
claim_url = new_user.get_claim_url(self.project._primary_key)
# a user is already logged in
res = self.app.get(claim_url, auth=existing.auth, expect_errors=True)
assert_equal(res.status_code, 302)
def test_unregistered_users_names_are_project_specific(self):
name1, name2, email = fake.name(), fake.name(), fake.email()
project2 = ProjectFactory(creator=self.referrer)
# different projects use different names for the same unreg contributor
self.project.add_unregistered_contributor(email=email,
fullname=name1,
auth=Auth(self.referrer))
self.project.save()
project2.add_unregistered_contributor(email=email,
fullname=name2,
auth=Auth(self.referrer))
project2.save()
self.app.authenticate(*self.referrer.auth)
# Each project displays a different name in the contributor list
res = self.app.get(self.project.url)
assert_in(name1, res)
res2 = self.app.get(project2.url)
assert_in(name2, res2)
def test_unregistered_user_can_create_an_account(self):
# User is added as an unregistered contributor to a project
email, name = fake.email(), fake.name()
self.project.add_unregistered_contributor(email=email,
fullname=name,
auth=Auth(self.referrer))
self.project.save()
# Goes to registration page (instead of claiming their email)
res = self.app.get('/account/').maybe_follow()
form = res.forms['registerForm']
form['register-fullname'] = name
form['register-username'] = email
form['register-username2'] = email
form['register-password'] = '******'
form['register-password2'] = 'example'
res = form.submit()
# registered successfully
assert_in(language.REGISTRATION_SUCCESS.format(email=email), res)
def test_cannot_go_to_claim_url_after_setting_password(self):
name, email = fake.name(), fake.email()
new_user = self.project.add_unregistered_contributor(
email=email, fullname=name, auth=Auth(self.referrer))
self.project.save()
# Goes to claim url and successfully claims account
claim_url = new_user.get_claim_url(self.project._primary_key)
res = self.app.get(claim_url)
self.project.reload()
assert_in('Set Password', res)
form = res.forms['setPasswordForm']
form['username'] = new_user.username
form['password'] = '******'
form['password2'] = 'killerqueen'
res = form.submit().maybe_follow()
# logs out
res = self.app.get('/logout/').maybe_follow()
# tries to go to claim url again
res = self.app.get(claim_url, expect_errors=True)
assert_equal(res.status_code, 400)
assert_in('already been claimed', res)
def test_cannot_set_email_to_a_user_that_already_exists(self):
reg_user = UserFactory()
name, email = fake.name(), fake.email()
new_user = self.project.add_unregistered_contributor(
email=email, fullname=name, auth=Auth(self.referrer))
self.project.save()
# Goes to claim url and successfully claims account
claim_url = new_user.get_claim_url(self.project._primary_key)
res = self.app.get(claim_url)
self.project.reload()
assert_in('Set Password', res)
form = res.forms['setPasswordForm']
# Fills out an email that is the username of another user
form['username'] = reg_user.username
form['password'] = '******'
form['password2'] = 'killerqueen'
res = form.submit().maybe_follow(expect_errors=True)
assert_in(language.ALREADY_REGISTERED.format(email=reg_user.username),
res)
def test_correct_display_name_is_shown_at_claim_page(self):
original_name = fake.name()
unreg = UnregUserFactory(fullname=original_name)
different_name = fake.name()
new_user = self.project.add_unregistered_contributor(
email=unreg.username,
fullname=different_name,
auth=Auth(self.referrer),
)
self.project.save()
claim_url = new_user.get_claim_url(self.project._primary_key)
res = self.app.get(claim_url)
# Correct name (different_name) should be on page
assert_in(different_name, res)
