def test_preprint_contributor_signal_not_sent_one_contributor(self):
with capture_signals() as mock_signals:
private_project_payload = build_preprint_create_payload(self.private_project._id, self.subject._id,
self.file_one_private_project._id)
res = self.app.post_json_api(self.url, private_project_payload, auth=self.user.auth)
assert_equal(res.status_code, 201)
assert_not_equal(mock_signals.signals_sent(), set([project_signals.contributor_added]))
def test_preprint_contributor_signal_not_sent_on_creation(self):
with capture_signals() as mock_signals:
public_project_payload = build_preprint_create_payload(self.public_project._id, self.provider._id,
self.file_one_public_project._id)
res = self.app.post_json_api(self.url, public_project_payload, auth=self.user.auth)
assert_equal(res.status_code, 201)
assert_not_in(project_signals.contributor_added, mock_signals.signals_sent())
def test_edit_sends_mention_added_signal_if_mentions(self):
with capture_signals() as mock_signals:
self.comment.edit(
auth=self.auth,
content="This is a comment with a bad mention [@Mentioned User](http://localhost:5000/"
+ self.comment.user._id
+ "/).",
save=True,
)
assert_equal(mock_signals.signals_sent(), set([mention_added]))
def test_edit_does_not_send_mention_added_signal_if_nonuser_mentioned(self):
with assert_raises(ValidationValueError) as error:
with capture_signals() as mock_signals:
self.comment.edit(
auth=self.auth,
content="This is a comment with a bad mention [@Not a User](http://localhost:5000/qwert/).",
save=True,
)
assert_equal(mock_signals.signals_sent(), set([]))
assert_equal(error.exception.message, "User does not exist or is not active.")
def test_create_sends_mention_added_signal_if_mentions(self, node, user, auth):
with capture_signals() as mock_signals:
Comment.create(
auth=auth,
user=user,
node=node,
target=node.guids.all()[0],
content='This is a comment with a bad mention [@Unconfirmed User](http://localhost:5000/' + user._id + '/).'
)
assert mock_signals.signals_sent() == ({comment_added, mention_added})
def test_edit_sends_mention_added_signal_if_mentions(self):
comment = CommentFactory()
auth = Auth(comment.user)
with capture_signals() as mock_signals:
comment.edit(
auth=auth,
content='This is a comment with a bad mention [@Mentioned User](http://localhost:5000/' + comment.user._id + '/).',
save=True
)
assert mock_signals.signals_sent() == ({mention_added})
def test_create_sends_comment_added_signal(self, node, user, auth):
with capture_signals() as mock_signals:
Comment.create(
auth=auth,
user=user,
node=node,
target=node.guids.all()[0],
content='This is a comment.'
)
assert mock_signals.signals_sent() == ({comment_added})
def test_create_sends_comment_added_signal(self):
with capture_signals() as mock_signals:
comment = Comment.create(
auth=self.auth,
user=self.comment.user,
node=self.comment.node,
target=self.comment.target,
is_public=True,
content='This is a comment.'
)
assert_equal(mock_signals.signals_sent(), set([comment_added]))
def test_edit_does_not_send_mention_added_signal_if_already_mentioned(self):
comment = CommentFactory()
auth = Auth(comment.user)
with capture_signals() as mock_signals:
comment.ever_mentioned.add(comment.user)
comment.edit(
auth=auth,
content='This is a comment with a bad mention [@Already Mentioned User](http://localhost:5000/' + comment.user._id + '/).',
save=True
)
assert mock_signals.signals_sent() == set([])
def test_edit_does_not_send_mention_added_signal_if_already_mentioned(self):
with capture_signals() as mock_signals:
self.comment.ever_mentioned = [self.comment.user._id]
self.comment.edit(
auth=self.auth,
content="This is a comment with a bad mention [@Already Mentioned User](http://localhost:5000/"
+ self.comment.user._id
+ "/).",
save=True,
)
assert_equal(mock_signals.signals_sent(), set([]))
def test_create_does_not_send_mention_added_signal_if_nonuser_mentioned(self, node, user, auth):
with pytest.raises(ValidationError) as error:
with capture_signals() as mock_signals:
Comment.create(
auth=auth,
user=user,
node=node,
target=node.guids.all()[0],
content='This is a comment with a bad mention [@Not a User](http://localhost:5000/qwert/).'
)
assert mock_signals.signals_sent() == set([])
assert error.value.message == 'User does not exist or is not active.'
def test_edit_does_not_send_mention_added_signal_if_nonuser_mentioned(self):
comment = CommentFactory()
auth = Auth(comment.user)
with pytest.raises(ValidationError) as error:
with capture_signals() as mock_signals:
comment.edit(
auth=auth,
content='This is a comment with a bad mention [@Not a User](http://localhost:5000/qwert/).',
save=True
)
assert mock_signals.signals_sent() == set([])
assert error.value.message == 'User does not exist or is not active.'
def test_removed_contrib_files_checked_in(self, app, node, file):
write_contrib = AuthUserFactory()
node.add_contributor(write_contrib, permissions=['read', 'write'])
node.save()
assert node.can_edit(user=write_contrib)
file.checkout = write_contrib
file.save()
assert file.is_checked_out
with capture_signals() as mock_signals:
node.remove_contributor(write_contrib, auth=Auth(write_contrib))
assert mock_signals.signals_sent() == set([contributor_removed])
file.reload()
assert not file.is_checked_out
def test_edit_does_not_send_mention_added_signal_if_noncontributor_mentioned(self):
comment = CommentFactory()
auth = Auth(comment.user)
with pytest.raises(ValidationError) as error:
with capture_signals() as mock_signals:
user = UserFactory()
comment.edit(
auth=auth,
content='This is a comment with a bad mention [@Non-contributor User](http://localhost:5000/' + user._id + '/).',
save=True
)
assert mock_signals.signals_sent() == set([])
assert error.value.message == 'Mentioned user is not a contributor.'
def test_removed_contrib_files_checked_in(self):
user = AuthUserFactory()
self.node.add_contributor(user, permissions=['read', 'write'])
self.node.save()
assert_true(self.node.can_edit(user=user))
self.file.checkout = user
self.file.save()
assert_true(self.file.is_checked_out)
with capture_signals() as mock_signals:
self.node.remove_contributor(user, auth=Auth(user))
assert_equal(mock_signals.signals_sent(), set([contributor_removed]))
self.file.reload()
assert_false(self.file.is_checked_out)
def test_create_does_not_send_mention_added_signal_if_nonuser_mentioned(self):
with assert_raises(ValidationValueError) as error:
with capture_signals() as mock_signals:
comment = Comment.create(
auth=self.auth,
user=self.comment.user,
node=self.comment.node,
target=self.comment.target,
is_public=True,
content="This is a comment with a bad mention [@Not a User](http://localhost:5000/qwert/).",
)
assert_equal(mock_signals.signals_sent(), set([]))
assert_equal(error.exception.message, "User does not exist or is not active.")
def test_removed_contrib_files_checked_in(self, app, node, file):
write_contrib = AuthUserFactory()
node.add_contributor(write_contrib, permissions=['read', 'write'])
node.save()
assert node.can_edit(user=write_contrib)
file.checkout = write_contrib
file.save()
assert file.is_checked_out
with capture_signals() as mock_signals:
node.remove_contributor(write_contrib, auth=Auth(write_contrib))
assert mock_signals.signals_sent() == set([contributor_removed])
file.reload()
assert not file.is_checked_out
def test_preprint_contributor_signal_sent_on_creation(self):
# Signal sent but bails out early without sending email
with capture_signals() as mock_signals:
payload = build_preprint_create_payload(
provider_id=self.provider._id)
res = self.app.post_json_api(
self.url, payload, auth=self.user.auth)
assert_equal(res.status_code, 201)
assert_true(len(mock_signals.signals_sent()) == 1)
assert_in(
project_signals.contributor_added,
mock_signals.signals_sent())
def test_create_sends_mention_added_signal_if_mentions(self):
with capture_signals() as mock_signals:
comment = Comment.create(
auth=self.auth,
user=self.comment.user,
node=self.comment.node,
target=self.comment.target,
is_public=True,
content="This is a comment with a bad mention [@Unconfirmed User](http://localhost:5000/"
+ self.comment.user._id
+ "/).",
)
assert_equal(mock_signals.signals_sent(), set([comment_added, mention_added]))
def test_edit_does_not_send_mention_added_signal_if_noncontributor_mentioned(self):
with assert_raises(ValidationValueError) as error:
with capture_signals() as mock_signals:
user = UserFactory()
self.comment.edit(
auth=self.auth,
content="This is a comment with a bad mention [@Non-contributor User](http://localhost:5000/"
+ user._id
+ "/).",
save=True,
)
assert_equal(mock_signals.signals_sent(), set([]))
assert_equal(error.exception.message, "Mentioned user is not a contributor.")
def test_create_does_not_send_mention_added_signal_if_noncontributor_mentioned(self, node, user, auth):
with pytest.raises(ValidationError) as error:
with capture_signals() as mock_signals:
user = UserFactory()
Comment.create(
auth=auth,
user=user,
node=node,
target=node.guids.all()[0],
content='This is a comment with a bad mention [@Non-contributor User](http://localhost:5000/' + user._id + '/).'
)
assert mock_signals.signals_sent() == set([])
assert error.value.message == 'Mentioned user is not a contributor.'
def test_removed_contrib_files_checked_in(self):
user = AuthUserFactory()
self.node.add_contributor(user, permissions=['read', 'write'])
self.node.save()
assert_true(self.node.can_edit(user=user))
self.file.checkout = user
self.file.save()
assert_true(self.file.is_checked_out)
with capture_signals() as mock_signals:
self.node.remove_contributor(user, auth=Auth(user))
assert_equal(mock_signals.signals_sent(), set([contributor_removed]))
self.file.reload()
assert_false(self.file.is_checked_out)
def test_create_does_not_send_mention_added_signal_if_nonuser_mentioned(self):
with assert_raises(ValidationValueError) as error:
with capture_signals() as mock_signals:
comment = Comment.create(
auth=self.auth,
user=self.comment.user,
node=self.comment.node,
target=self.comment.target,
is_public=True,
content='This is a comment with a bad mention [@Not a User](http://localhost:5000/qwert/).'
)
assert_equal(mock_signals.signals_sent(), set([]))
assert_equal(error.exception.message, 'User does not exist or is not active.')
def test_creates_user(self):
username = '******'
assert_equal(User.find(Q('username', 'eq', username)).count(), 0)
with capture_signals() as mock_signals:
res = self.app.post(self.url, self.build_payload(username))
assert_equal(res.status_code, 204)
assert_equal(mock_signals.signals_sent(), set([signals.user_confirmed]))
user = User.find_one(Q('username', 'eq', username))
assert_true(user)
assert_in(self.institution, user.affiliated_institutions)
def test_create_sends_mention_added_signal_if_group_member_mentions(self, node, user, auth):
manager = AuthUserFactory()
group = OSFGroupFactory(creator=manager)
node.add_osf_group(group)
assert node.is_contributor_or_group_member(manager) is True
with capture_signals() as mock_signals:
Comment.create(
auth=auth,
user=user,
node=node,
target=node.guids.all()[0],
content='This is a comment with a group member mention [@Group Member](http://localhost:5000/' + manager._id + '/).'
)
assert mock_signals.signals_sent() == ({comment_added, mention_added})
def test_creates_user(self, app, url_auth_institution, institution):
username = '******'
assert OSFUser.objects.filter(username=username).count() == 0
with capture_signals() as mock_signals:
res = app.post(url_auth_institution, make_payload(institution, username))
assert res.status_code == 204
assert mock_signals.signals_sent() == set([signals.user_confirmed])
user = OSFUser.objects.filter(username=username).first()
assert user
assert institution in user.affiliated_institutions.all()
def test_adds_institution(self, app, institution, url_auth_institution):
username = '******'
user = make_user(username, 'Mr Moco')
user.save()
with capture_signals() as mock_signals:
res = app.post(url_auth_institution, make_payload(institution, username))
assert res.status_code == 204
assert mock_signals.signals_sent() == set()
user.reload()
assert institution in user.affiliated_institutions.all()
def test_user_external_unconfirmed(self, app, institution,
url_auth_institution):
# Create an unconfirmed user with pending external identity
username, fullname = '*****@*****.**', 'Foo Bar'
external_id_provider, external_id, status = 'ORCID', '1234-1234-1234-1234', 'CREATE'
external_identity = {external_id_provider: {external_id: status}}
accepted_terms_of_service = timezone.now()
user = OSFUser.create_unconfirmed(
username=username,
password=None,
fullname=fullname,
external_identity=external_identity,
campaign=None,
accepted_terms_of_service=accepted_terms_of_service)
user.save()
assert not user.has_usable_password()
assert user.external_identity
# Send confirm email in order to add new email verifications
send_confirm_email(user,
user.username,
external_id_provider=external_id_provider,
external_id=external_id)
user.save()
assert user.email_verifications
email_verifications = user.email_verifications
with capture_signals() as mock_signals:
res = app.post(url_auth_institution,
make_payload(institution,
username,
family_name='User',
given_name='Fake',
fullname='Fake User'),
expect_errors=True)
assert res.status_code == 403
assert not mock_signals.signals_sent()
user = OSFUser.objects.filter(username=username).first()
assert user
# User remains untouched, including affiliation, external identity email verifcaitons
assert user.fullname == fullname
assert user.given_name == 'Foo'
assert user.family_name == 'Bar'
assert institution not in user.affiliated_institutions.all()
assert external_identity == user.external_identity
assert email_verifications == user.email_verifications
assert accepted_terms_of_service == user.accepted_terms_of_service
assert not user.has_usable_password()
def test_create_does_not_send_mention_added_signal_if_noncontributor_mentioned(self):
with assert_raises(ValidationValueError) as error:
with capture_signals() as mock_signals:
user = UserFactory()
comment = Comment.create(
auth=self.auth,
user=self.comment.user,
node=self.comment.node,
target=self.comment.target,
is_public=True,
content='This is a comment with a bad mention [@Non-contributor User](http://localhost:5000/' + user._id + '/).'
)
assert_equal(mock_signals.signals_sent(), set([]))
assert_equal(error.exception.message, 'Mentioned user is not a contributor.')
def test_adds_institution(self):
username = '******'
user = User(username=username, fullname='Mr Moco')
user.save()
with capture_signals() as mock_signals:
res = self.app.post(self.url, self.build_payload(username))
assert_equal(res.status_code, 204)
assert_equal(mock_signals.signals_sent(), set())
user.reload()
assert_in(self.institution, user.affiliated_institutions)
def test_update_published_does_not_send_contributor_added_for_inactive_users(
self):
unpublished = PreprintFactory(creator=self.user, is_published=False)
unpublished.node.add_unregistered_contributor(fullname=fake.name(),
email=fake.email(),
auth=Auth(self.user),
save=True)
url = '/{}preprints/{}/'.format(API_BASE, unpublished._id)
payload = build_preprint_update_payload(
unpublished._id, attributes={'is_published': True})
with capture_signals() as captured:
res = self.app.patch_json_api(url, payload, auth=self.user.auth)
# Signal not sent, because contributor is not registered
assert_false(captured[contributor_added])
def test_existing_user_found_but_not_affiliated(self, app, institution, url_auth_institution):
username = '******'
user = make_user(username, 'Foo Bar')
user.save()
with capture_signals() as mock_signals:
res = app.post(url_auth_institution, make_payload(institution, username))
assert res.status_code == 204
assert not mock_signals.signals_sent()
user.reload()
assert user.fullname == 'Foo Bar'
assert institution in user.affiliated_institutions.all()
def test_new_user_created(self, app, url_auth_institution, institution):
username = '******'
assert OSFUser.objects.filter(username=username).count() == 0
with capture_signals() as mock_signals:
res = app.post(url_auth_institution, make_payload(institution, username))
assert res.status_code == 204
assert mock_signals.signals_sent() == set([signals.user_confirmed])
user = OSFUser.objects.filter(username=username).first()
assert user
assert user.fullname == 'Fake User'
assert user.accepted_terms_of_service is None
assert institution in user.affiliated_institutions.all()
def test_create_does_not_send_mention_added_signal_if_unconfirmed_contributor_mentioned(self, node, user, auth):
with pytest.raises(ValidationError) as error:
with capture_signals() as mock_signals:
user = UnregUserFactory()
user.save()
node.add_unregistered_contributor(user.fullname, user.email, Auth(node.creator), permissions=[permissions.READ], save=True)
Comment.create(
auth=auth,
user=user,
node=node,
target=node.guids.all()[0],
content='This is a comment with a bad mention [@Unconfirmed User](http://localhost:5000/' + user._id + '/).'
)
assert mock_signals.signals_sent() == ({contributor_added})
assert error.value.message == 'User does not exist or is not active.'
def test_create_does_not_send_mention_added_signal_if_noncontributor_mentioned(self):
with assert_raises(ValidationValueError) as error:
with capture_signals() as mock_signals:
user = UserFactory()
comment = Comment.create(
auth=self.auth,
user=self.comment.user,
node=self.comment.node,
target=self.comment.target,
is_public=True,
content="This is a comment with a bad mention [@Non-contributor User](http://localhost:5000/"
+ user._id
+ "/).",
)
assert_equal(mock_signals.signals_sent(), set([]))
assert_equal(error.exception.message, "Mentioned user is not a contributor.")
def test_edit_does_not_send_mention_added_signal_if_unconfirmed_contributor_mentioned(self):
comment = CommentFactory()
auth = Auth(comment.user)
with pytest.raises(ValidationError) as error:
with capture_signals() as mock_signals:
user = UnregUserFactory()
user.save()
comment.node.add_unregistered_contributor(user.fullname, user.email, auth=Auth(comment.node.creator), visible=False, permissions=[permissions.READ])
comment.node.save()
comment.edit(
auth=auth,
content='This is a comment with a bad mention [@Unconfirmed User](http://localhost:5000/' + user._id + '/).',
save=True
)
assert mock_signals.signals_sent() == ({contributor_added})
assert error.value.message == 'User does not exist or is not active.'
def test_add_unregistered_contributor_without_email_no_email(
self, mock_mail, app, user, url_project_contribs):
url = '{}?send_email=draft_registration'.format(url_project_contribs)
payload = {
'data': {
'type': 'contributors',
'attributes': {
'full_name': 'Kanye West',
}
}
}
with capture_signals() as mock_signal:
res = app.post_json_api(url, payload, auth=user.auth)
assert contributor_added in mock_signal.signals_sent()
assert res.status_code == 201
assert mock_mail.call_count == 0
def test_edit_does_not_send_mention_added_signal_if_unconfirmed_contributor_mentioned(self):
with assert_raises(ValidationValueError) as error:
with capture_signals() as mock_signals:
user = UserFactory()
user.is_registered = False
user.is_claimed = False
user.save()
self.comment.node.add_contributor(user, visible=False,permissions=[permissions.READ])
self.comment.node.save()
self.comment.edit(
auth=self.auth,
content='This is a comment with a bad mention [@Unconfirmed User](http://localhost:5000/' + user._id + '/).',
save=True
)
assert_equal(mock_signals.signals_sent(), set([contributor_added]))
assert_equal(error.exception.message, 'User does not exist or is not active.')
def test_adds_institution(self, app, institution, url_auth_institution):
username = '******'
user = make_user(username, 'Mr Moco')
user.save()
with capture_signals() as mock_signals:
res = app.post(
url_auth_institution,
make_payload(institution, username)
)
assert res.status_code == 204
assert mock_signals.signals_sent() == set()
user.reload()
assert institution in user.affiliated_institutions.all()
def test_existing_user_primary_only_not_affiliated(self, app, url_auth_institution,
institution_primary, institution_secondary):
username = '******'
user = make_user(username, 'Foo Bar')
user.save()
number_of_affiliations = user.affiliated_institutions.count()
with capture_signals() as mock_signals:
res = app.post(url_auth_institution, make_payload(institution_primary, username))
assert res.status_code == 204
assert not mock_signals.signals_sent()
user.reload()
assert user.fullname == 'Foo Bar'
assert user.affiliated_institutions.count() == number_of_affiliations + 1
assert institution_primary in user.affiliated_institutions.all()
assert institution_secondary not in user.affiliated_institutions.all()
def test_creates_user(self, app, url_auth_institution, institution):
username = '******'
assert OSFUser.objects.filter(username=username).count() == 0
with capture_signals() as mock_signals:
res = app.post(
url_auth_institution,
make_payload(institution, username)
)
assert res.status_code == 204
assert mock_signals.signals_sent() == set([signals.user_confirmed])
user = OSFUser.objects.filter(username=username).first()
assert user
assert institution in user.affiliated_institutions.all()
def test_create_does_not_send_mention_added_signal_if_unconfirmed_contributor_mentioned(self, node, user, auth):
with pytest.raises(ValidationError) as error:
with capture_signals() as mock_signals:
user = UserFactory()
user.is_registered = False
user.is_claimed = False
user.save()
node.add_contributor(user, visible=False, permissions=[permissions.READ], save=True)
Comment.create(
auth=auth,
user=user,
node=node,
target=node.guids.all()[0],
content='This is a comment with a bad mention [@Unconfirmed User](http://localhost:5000/' + user._id + '/).'
)
assert mock_signals.signals_sent() == ({contributor_added})
assert error.value.message == 'User does not exist or is not active.'
def test_edit_comment(self, request, comment, comment_content, expected_signals, expected_error_msg):
if hasattr(comment_content, '_pytestfixturefunction'):
comment_content = request.getfixturevalue(comment_content.__name__)
error_msg = None
auth = Auth(comment.user)
with capture_signals() as mock_signals:
try:
comment.edit(
auth=auth,
content=comment_content,
save=True,
)
except Exception as e:
error_msg = str(e)
assert expected_signals == mock_signals.signals_sent()
assert error_msg == expected_error_msg
def test_user_unclaimed(self, app, institution, url_auth_institution):
username, fullname = '*****@*****.**', 'Foo Bar'
project = ProjectFactory()
user = project.add_unregistered_contributor(
fullname=fullname,
email=username,
auth=Auth(project.creator)
)
user.save()
# Unclaimed user is given an unusable password when being added as a contributor
assert not user.has_usable_password()
with capture_signals() as mock_signals:
res = app.post(
url_auth_institution,
make_payload(
institution,
username,
family_name='User',
given_name='Fake',
fullname='Fake User',
department='Fake Department',
)
)
assert res.status_code == 204
assert mock_signals.signals_sent() == set([signals.user_confirmed])
user = OSFUser.objects.filter(username=username).first()
assert user
# User becomes active and all names are updated
assert user.is_active
assert user.fullname == 'Fake User'
assert user.family_name == 'User'
assert user.given_name == 'Fake'
assert user.department == 'Fake Department'
# Unclaimed records must have been cleared
assert not user.unclaimed_records
# Previously unclaimed user must be assigned a usable password during institution auth
assert user.has_usable_password()
# User remains to be a contributor of the project
assert project.is_contributor(user)
# Confirm affiliation
assert institution in user.affiliated_institutions.all()
def test_edit_does_not_send_mention_added_signal_if_unconfirmed_contributor_mentioned(self):
with assert_raises(ValidationValueError) as error:
with capture_signals() as mock_signals:
user = UserFactory()
user.is_registered = False
user.is_claimed = False
user.save()
self.comment.node.add_contributor(user, visible=False, permissions=[permissions.READ])
self.comment.node.save()
self.comment.edit(
auth=self.auth,
content="This is a comment with a bad mention [@Unconfirmed User](http://localhost:5000/"
+ user._id
+ "/).",
save=True,
)
assert_equal(mock_signals.signals_sent(), set([contributor_added]))
assert_equal(error.exception.message, "User does not exist or is not active.")
def test_selective_sso_allowed_existing_user_not_affiliated(self, app, url_auth_institution, institution_selective):
username = '******'
user = make_user(username, 'Foo Bar')
user.save()
payload = make_payload(
institution_selective,
username,
selective_sso_filter='http://directory.manchester.ac.uk/epe/3rdparty/osf'
)
with capture_signals() as mock_signals:
res = app.post(url_auth_institution, payload)
assert res.status_code == 204
assert not mock_signals.signals_sent()
user.reload()
assert user.fullname == 'Foo Bar'
assert institution_selective in user.affiliated_institutions.all()
def test_edit_does_not_send_mention_added_signal_if_unconfirmed_contributor_mentioned(self):
comment = CommentFactory()
auth = Auth(comment.user)
with pytest.raises(ValidationError) as error:
with capture_signals() as mock_signals:
user = UserFactory()
user.is_registered = False
user.is_claimed = False
user.save()
comment.node.add_contributor(user, visible=False, permissions=[permissions.READ])
comment.node.save()
comment.edit(
auth=auth,
content='This is a comment with a bad mention [@Unconfirmed User](http://localhost:5000/' + user._id + '/).',
save=True
)
assert mock_signals.signals_sent() == ({contributor_added})
assert error.value.message == 'User does not exist or is not active.'
def test_create_comment(self, request, user, project, comment_content, expected_signals, expected_error_msg):
if hasattr(comment_content, '_pytestfixturefunction'):
comment_content = request.getfixturevalue(comment_content.__name__)
auth = Auth(user)
error_msg = None
with capture_signals() as mock_signals:
try:
Comment.create(
auth=auth,
user=user,
node=project,
target=project.guids.all()[0],
content=comment_content
)
except Exception as e:
error_msg = str(e)
assert expected_signals == mock_signals.signals_sent()
assert error_msg == expected_error_msg
def test_selective_sso_allowed_new_user(self, app, url_auth_institution, institution_selective):
username = '******'
assert OSFUser.objects.filter(username=username).count() == 0
payload = make_payload(
institution_selective,
username,
selective_sso_filter='http://directory.manchester.ac.uk/epe/3rdparty/osf'
)
with capture_signals() as mock_signals:
res = app.post(url_auth_institution, payload)
assert res.status_code == 204
assert mock_signals.signals_sent() == {signals.user_confirmed}
user = OSFUser.objects.filter(username=username).first()
assert user
assert user.fullname == 'Fake User'
assert user.accepted_terms_of_service is None
assert institution_selective in user.affiliated_institutions.all()
def test_node_subscriptions_and_backrefs_removed_when_node_is_deleted(self):
project = factories.ProjectFactory()
subscription = factories.NotificationSubscriptionFactory(
_id=project._id + '_comments',
owner=project
)
subscription.save()
subscription.email_transactional.append(project.creator)
subscription.save()
s = getattr(project.creator, 'email_transactional', [])
assert_equal(len(s), 1)
with capture_signals() as mock_signals:
project.remove_node(auth=Auth(project.creator))
assert_true(project.is_deleted)
assert_equal(mock_signals.signals_sent(), set([node_deleted]))
s = getattr(project.creator, 'email_transactional', [])
assert_equal(len(s), 0)
with assert_raises(NoResultsFound):
NotificationSubscription.find_one(Q('owner', 'eq', project))
def test_user_unconfirmed(self, app, institution, url_auth_institution):
username, fullname, password = '******', 'Foo Bar', 'FuAsKeEr'
user = OSFUser.create_unconfirmed(username, password, fullname)
user.save()
# Unconfirmed user has a usable password created during sign-up
assert user.has_usable_password()
with capture_signals() as mock_signals:
res = app.post(
url_auth_institution,
make_payload(
institution,
username,
family_name='User',
given_name='Fake',
fullname='Fake User'
)
)
assert res.status_code == 204
assert mock_signals.signals_sent() == set([signals.user_confirmed])
user = OSFUser.objects.filter(username=username).first()
assert user
# User becomes active and all names are updated
assert user.is_active
assert user.fullname == 'Fake User'
assert user.family_name == 'User'
assert user.given_name == 'Fake'
# Pending email verifications must be cleared
assert not user.email_verifications
# Previously unconfirmed user must be given a new password during institution auth
assert user.has_usable_password()
assert not user.check_password(password)
# Confirm affiliation
assert institution in user.affiliated_institutions.all()
def test_user_inactive(self, app, institution, url_auth_institution):
username, fullname, password = '******', 'Foo Bar', 'FuAsKeEr'
user = make_user(username, fullname)
user.set_password(password)
# User must be saved before deactivation
user.save()
user.deactivate_account()
user.save()
# Disabled user still has the original usable password
assert user.has_usable_password()
assert user.check_password(password)
with capture_signals() as mock_signals:
res = app.post(
url_auth_institution,
make_payload(
institution,
username,
family_name='User',
given_name='Fake',
fullname='Fake User'
),
expect_errors=True
)
assert res.status_code == 403
assert not mock_signals.signals_sent()
user = OSFUser.objects.filter(username=username).first()
assert user
# Inactive user remains untouched, including affiliation
assert user.is_disabled
assert user.fullname == fullname
assert user.given_name == 'Foo'
assert user.family_name == 'Bar'
assert institution not in user.affiliated_institutions.all()
def test_remove_contributor_signal_called_when_contributor_is_removed(self):
with capture_signals() as mock_signals:
self.project.remove_contributor(self.contributor, auth=Auth(self.project.creator))
assert_equal(mock_signals.signals_sent(), set([contributor_removed]))
