def setUp(self):
super(TestMigrateMailingLists, self).setUp()
self.user1 = UserFactory(mailing_lists={'mail': True})
self.user2 = UserFactory(mailing_lists={'mail': False})
self.user3 = UserFactory()
self.user1.save()
self.user2.save()
class TestNodeSettings(OsfTestCase):
def setUp(self):
super(TestNodeSettings, self).setUp()
self.user = UserFactory()
self.project = ProjectFactory(creator=self.user)
self.user.add_addon('s3')
self.project.add_addon('s3', auth=Auth(self.user))
self.user_settings = self.user.get_addon('s3')
self.node_settings = self.project.get_addon('s3')
self.user_settings.access_key = 'We-Will-Rock-You'
self.user_settings.secret_key = 'Idontknowanyqueensongs'
self.user_settings.save()
self.node_settings.bucket = 'Sheer-Heart-Attack'
self.node_settings.user_settings = self.user_settings
self.node_settings.save()
def test_complete_true(self):
assert_true(self.node_settings.has_auth)
assert_true(self.node_settings.complete)
def test_complete_false(self):
self.node_settings.bucket = None
assert_true(self.node_settings.has_auth)
assert_false(self.node_settings.complete)
def test_complete_auth_false(self):
self.node_settings.user_settings = None
assert_false(self.node_settings.has_auth)
assert_false(self.node_settings.complete)
def setUp(self):
super(TestMigrateProfileWebsites, self).setUp()
self.user_one = UserFactory.build(
fullname="Martin Luther King",
social=dict(
github="userOneGithub",
scholar="userOneScholar",
personal="http://www.useronewebsite.com",
twitter="userOneTwitter",
linkedIn="userOneLinkedIn",
impactStory="userOneImpactStory",
orcid="userOneOrcid",
researcherId="userOneResearcherId",
),
)
self.user_one.save()
self.user_two = UserFactory.build(
fullname="el-Hajj Malik el-Shabazz",
social=dict(
github="userTwoGithub",
scholar="userTwoScholar",
profileWebsites=["http://www.usertwowebsite.com"],
twitter="userTwoTwitter",
linkedIn="userTwoLinkedIn",
impactStory="userTwoImpactStory",
orcid="userTwoOrcid",
researcherId="userTwoResearcherId",
),
)
self.user_two.save()
self.user_three = UserFactory()
class TestSearchExceptions(OsfTestCase):
"""
Verify that the correct exception is thrown when the connection is lost
"""
@classmethod
def setUpClass(cls):
super(TestSearchExceptions, cls).setUpClass()
if settings.SEARCH_ENGINE == "elastic":
cls._es = search.search_engine.es
search.search_engine.es = None
@classmethod
def tearDownClass(cls):
super(TestSearchExceptions, cls).tearDownClass()
if settings.SEARCH_ENGINE == "elastic":
search.search_engine.es = cls._es
def test_connection_error(self):
"""
Ensures that saving projects/users doesn't break as a result of connection errors
"""
self.user = UserFactory(usename="Doug Bogie")
self.project = ProjectFactory(title="Tom Sawyer", creator=self.user, is_public=True)
self.user.save()
self.project.save()
class TestDisableSpamUser(AdminTestCase):
def setUp(self):
self.user = UserFactory()
self.public_node = ProjectFactory(creator=self.user, is_public=True)
self.public_node = ProjectFactory(creator=self.user, is_public=False)
self.request = RequestFactory().post('/fake_path')
self.view = SpamUserDeleteView()
self.view = setup_log_view(self.view, self.request, guid=self.user._id)
def test_get_object(self):
obj = self.view.get_object()
nt.assert_is_instance(obj, User)
def test_get_context(self):
res = self.view.get_context_data(object=self.user)
nt.assert_in('guid', res)
nt.assert_equal(res.get('guid'), self.user._id)
def test_disable_spam_user(self):
settings.ENABLE_EMAIL_SUBSCRIPTIONS = False
count = OSFLogEntry.objects.count()
self.view.delete(self.request)
self.user.reload()
self.public_node.reload()
nt.assert_true(self.user.is_disabled)
nt.assert_false(self.public_node.is_public)
nt.assert_equal(OSFLogEntry.objects.count(), count + 3)
def test_no_user(self):
view = setup_view(UserDeleteView(), self.request, guid='meh')
with nt.assert_raises(Http404):
view.delete(self.request)
def test_user(self):
with self.instance.test_request_context() as request:
u = UserFactory(login='******', email='*****@*****.**')
self.assertTrue(u.is_authenticated())
self.assertTrue(u.is_active())
self.assertFalse(u.is_anonymous())
class TestSignInRedirect:
def get_redirect_response(self, client, next=None):
password = "******"
self.user = UserFactory()
self.user.set_password(password)
self.user.save()
url = reverse("userena_signin")
if next:
url += f"?next={next}"
return client.post(
url,
data={"identification": self.user.username, "password": password},
follow=True,
)
def test_default_redirect(self, client):
response = self.get_redirect_response(client)
assert response.redirect_chain[0][1] == status.HTTP_302_FOUND
assert response.redirect_chain[0][0] == reverse("profile_redirect")
assert response.status_code == status.HTTP_200_OK
def test_redirect(self, client):
expected_url = "/challenges/"
response = self.get_redirect_response(client, expected_url)
assert response.redirect_chain[0][1] == status.HTTP_302_FOUND
assert response.status_code == status.HTTP_200_OK
assert response.redirect_chain[0][0] == expected_url
def test_no_logout_redirect(self, client):
response = self.get_redirect_response(client, settings.LOGOUT_URL)
assert response.redirect_chain[0][1] == status.HTTP_302_FOUND
assert response.redirect_chain[0][0] == reverse("profile_redirect")
assert response.status_code == status.HTTP_200_OK
def test_migration(self):
BoxUserSettings.remove()
user = UserFactory()
node = ProjectFactory(creator=user)
account = BoxAccountFactory()
user.external_accounts = [account]
user.add_addon('box', auth=Auth(user))
user_addon = user.get_addon('box')
user_addon.save()
node.add_addon('box', auth=Auth(user))
node_addon = node.get_addon('box')
node_addon.foreign_user_settings = user_addon
node_addon.folder_id = 'abcdef0'
node_addon.folder_path = '/'
node_addon.folder_name = '/ (Full Box)'
node_addon.save()
assert_equal(node_addon.external_account, None)
assert_equal(node_addon.folder_id, 'abcdef0')
do_migration()
node_addon.reload()
assert_equal(node_addon.external_account, account)
assert_equal(node_addon.folder_id, 'abcdef0')
assert_equal(node_addon.folder_path, '/')
assert_equal(node_addon.folder_name, '/ (Full Box)')
def test_email_uniqueness_case_insensitive(self):
UserFactory.create(email="*****@*****.**")
with self.assertRaises(ValidationError) as error:
UserFactory.create(email="*****@*****.**")
self.assertEqual(
error.exception.messages,
["That email address is already in use."])
def setUp(self):
super(TestUserNodes, self).setUp()
self.user_one = UserFactory.build()
self.user_one.set_password('justapoorboy')
self.user_one.social['twitter'] = 'howtopizza'
self.user_one.save()
self.auth_one = (self.user_one.username, 'justapoorboy')
self.user_two = UserFactory.build()
self.user_two.set_password('justapoorboy')
self.user_two.save()
self.auth_two = (self.user_two.username, 'justapoorboy')
self.public_project_user_one = ProjectFactory(title="Public Project User One",
is_public=True,
creator=self.user_one)
self.private_project_user_one = ProjectFactory(title="Private Project User One",
is_public=False,
creator=self.user_one)
self.public_project_user_two = ProjectFactory(title="Public Project User Two",
is_public=True,
creator=self.user_two)
self.private_project_user_two = ProjectFactory(title="Private Project User Two",
is_public=False,
creator=self.user_two)
self.deleted_project_user_one = FolderFactory(title="Deleted Project User One",
is_public=False,
creator=self.user_one,
is_deleted=True)
self.folder = FolderFactory()
self.deleted_folder = FolderFactory(title="Deleted Folder User One",
is_public=False,
creator=self.user_one,
is_deleted=True)
self.dashboard = DashboardFactory()
class TestDisableUser(AdminTestCase):
def setUp(self):
self.user = UserFactory()
self.request = RequestFactory().post('/fake_path')
self.view = UserDeleteView()
self.view = setup_log_view(self.view, self.request, guid=self.user._id)
def test_get_object(self):
obj = self.view.get_object()
nt.assert_is_instance(obj, User)
def test_get_context(self):
res = self.view.get_context_data(object=self.user)
nt.assert_in('guid', res)
nt.assert_equal(res.get('guid'), self.user._id)
def test_disable_user(self):
settings.ENABLE_EMAIL_SUBSCRIPTIONS = False
count = OSFLogEntry.objects.count()
self.view.delete(self.request)
self.user.reload()
nt.assert_true(self.user.is_disabled)
nt.assert_equal(OSFLogEntry.objects.count(), count + 1)
def test_reactivate_user(self):
settings.ENABLE_EMAIL_SUBSCRIPTIONS = False
self.view.delete(self.request)
count = OSFLogEntry.objects.count()
self.view.delete(self.request)
self.user.reload()
nt.assert_false(self.user.is_disabled)
nt.assert_equal(OSFLogEntry.objects.count(), count + 1)
def test_increment_user_activity_counters(self):
user = UserFactory()
date = datetime.utcnow()
assert_equal(user.get_activity_points(db=self.db), 0)
analytics.increment_user_activity_counters(user._id, 'project_created', date, db=self.db)
assert_equal(user.get_activity_points(db=self.db), 1)
class TestSearchExceptions(OsfTestCase):
"""
Verify that the correct exception is thrown when the connection is lost
"""
@classmethod
def setUpClass(cls):
logging.getLogger('website.project.model').setLevel(logging.CRITICAL)
super(TestSearchExceptions, cls).setUpClass()
if settings.SEARCH_ENGINE == 'elastic':
cls._es = search.search_engine.es
search.search_engine.es = None
@classmethod
def tearDownClass(cls):
super(TestSearchExceptions, cls).tearDownClass()
if settings.SEARCH_ENGINE == 'elastic':
search.search_engine.es = cls._es
def test_connection_error(self):
# Ensures that saving projects/users doesn't break as a result of connection errors
self.user = UserFactory(usename='Doug Bogie')
self.project = ProjectFactory(
title="Tom Sawyer",
creator=self.user,
is_public=True,
)
self.user.save()
self.project.save()
def test_userfactory(session):
user = UserFactory()
user.save()
assert isinstance(user, User)
assert user.id is not None
assert user.email is not None
assert user.active is not None
def setUp(self):
super(TestMergingAccounts, self).setUp()
self.user = UserFactory.build()
self.user.set_password('science')
self.user.save()
self.dupe = UserFactory.build()
self.dupe.set_password('example')
self.dupe.save()
def test_no_two_emails_to_same_person(self, mock_send):
user = UserFactory()
user.osf_mailing_lists[settings.OSF_HELP_LIST] = True
user.save()
self.queue_mail(user=user)
self.queue_mail(user=user)
main(dry_run=False)
assert_equal(mock_send.call_count, 1)
def test_authenticate_using_token(self):
user = UserFactory.create()
exists, auth_user = User.authenticate(email=user.email, password=UserFactory.get_default_password())
expect(auth_user).not_to_be_null()
auth_user = User.authenticate_with_token(token=auth_user.token)
expect(auth_user).not_to_be_null()
class TestGithubNodeSettings(OsfTestCase):
def setUp(self):
OsfTestCase.setUp(self)
self.user = UserFactory()
self.user.add_addon('github')
self.user_settings = self.user.get_addon('github')
self.external_account = GitHubAccountFactory()
self.user_settings.owner.external_accounts.append(self.external_account)
self.user_settings.owner.save()
self.node_settings = GitHubNodeSettingsFactory(user_settings=self.user_settings)
@mock.patch('website.addons.github.api.GitHubClient.delete_hook')
def test_delete_hook(self, mock_delete_hook):
self.node_settings.hook_id = 'hook'
self.node_settings.save()
args = (
self.node_settings.user,
self.node_settings.repo,
self.node_settings.hook_id,
)
res = self.node_settings.delete_hook()
assert_true(res)
mock_delete_hook.assert_called_with(*args)
@mock.patch('website.addons.github.api.GitHubClient.delete_hook')
def test_delete_hook_no_hook(self, mock_delete_hook):
res = self.node_settings.delete_hook()
assert_false(res)
assert_false(mock_delete_hook.called)
@mock.patch('website.addons.github.api.GitHubClient.delete_hook')
def test_delete_hook_not_found(self, mock_delete_hook):
self.node_settings.hook_id = 'hook'
self.node_settings.save()
mock_delete_hook.side_effect = NotFoundError
args = (
self.node_settings.user,
self.node_settings.repo,
self.node_settings.hook_id,
)
res = self.node_settings.delete_hook()
assert_false(res)
mock_delete_hook.assert_called_with(*args)
@mock.patch('website.addons.github.api.GitHubClient.delete_hook')
def test_delete_hook_error(self, mock_delete_hook):
self.node_settings.hook_id = 'hook'
self.node_settings.save()
mock_delete_hook.side_effect = GitHubError(mock.Mock())
args = (
self.node_settings.user,
self.node_settings.repo,
self.node_settings.hook_id,
)
res = self.node_settings.delete_hook()
assert_false(res)
mock_delete_hook.assert_called_with(*args)
def setUp(self):
super(TestMergingAccounts, self).setUp()
self.user = UserFactory.build()
self.user.fullname = "tess' test string"
self.user.set_password("science")
self.user.save()
self.dupe = UserFactory.build()
self.dupe.set_password("example")
self.dupe.save()
def test_create_user():
# Check there are 0 users before a new user is added
number_users = OCDActionUser.objects.count()
assert number_users == 0
# Check there is 1 user after a new user is added
UserFactory.create()
number_users = OCDActionUser.objects.count()
assert number_users == 1
def test_cant_have_same_member_twice(self):
u1 = UserFactory.create()
u2 = UserFactory.create()
try:
Team.create(name="test-team-same-member-twice", owner=u1, members=[u2, u2])
except ValueError:
ex = sys.exc_info()[1]
expect(ex).to_have_an_error_message_of("Can't have the same user twice in the members collection.")
return
assert False, "Should not have gotten this far"
def test_can_create_user(self):
user = UserFactory.create()
password = UserFactory.get_default_password()
password = hmac.new(six.b(str(user.salt)), six.b(password), hashlib.sha1).hexdigest()
retrieved = User.objects(id=user.id)
expect(retrieved.count()).to_equal(1)
expect(retrieved.first().password).to_equal(password)
expect(retrieved.first().email).to_equal(user.email)
expect(retrieved.first().token).to_equal(user.token)
class TestDisabledUser(OsfTestCase):
def setUp(self):
super(TestDisabledUser, self).setUp()
self.user = UserFactory()
self.user.set_password("Korben Dallas")
self.user.is_disabled = True
self.user.save()
def test_profile_disabled_returns_401(self):
res = self.app.get(self.user.url, expect_errors=True)
assert_equal(res.status_code, 410)
def setUp(self):
ApiTestCase.setUp(self)
self.user_one = UserFactory.build()
self.user_one.set_password('justapoorboy')
self.user_one.social['twitter'] = 'howtopizza'
self.user_one.save()
self.auth_one = (self.user_one.username, 'justapoorboy')
self.user_two = UserFactory.build()
self.user_two.set_password('justapoorboy')
self.user_two.save()
self.auth_two = (self.user_two.username, 'justapoorboy')
def test_get_total_activity_count(self):
user = UserFactory()
date = datetime.utcnow()
assert_equal(analytics.get_total_activity_count(user._id), 0)
assert_equal(analytics.get_total_activity_count(user._id), user.get_activity_points(db=self.db))
analytics.increment_user_activity_counters(user._id, 'project_created', date.isoformat(), db=self.db)
assert_equal(analytics.get_total_activity_count(user._id, db=self.db), 1)
assert_equal(analytics.get_total_activity_count(user._id, db=self.db), user.get_activity_points(db=self.db))
def test_get_email_appellation_priority_list(self):
user = UserFactory.create(first_name="my_first", last_name="my_last")
from accounts.utils import relate_user_method_settings
relate_user_method_settings.__dict__ = {}
with override_settings(
RELATE_USER_FULL_NAME_FORMAT_METHOD=None):
self.assertEqual(user.get_email_appellation(), "my_first")
relate_user_method_settings.__dict__ = {}
with override_settings(
RELATE_EMAIL_APPELLATION_PRIORITY_LIST=[""]):
relate_user_method_settings.__dict__ = {}
self.assertEqual(user.get_email_appellation(), "my_first")
relate_user_method_settings.__dict__ = {}
with override_settings(
RELATE_EMAIL_APPELLATION_PRIORITY_LIST=["whatever"]):
self.assertEqual(user.get_email_appellation(), "my_first")
relate_user_method_settings.__dict__ = {}
# not a list
with override_settings(
RELATE_EMAIL_APPELLATION_PRIORITY_LIST="whatever"):
self.assertEqual(user.get_email_appellation(), "my_first")
relate_user_method_settings.__dict__ = {}
with override_settings(
RELATE_EMAIL_APPELLATION_PRIORITY_LIST=["full_name"],
RELATE_USER_FULL_NAME_FORMAT_METHOD=None):
self.assertEqual(user.get_email_appellation(), "my_first my_last")
# create a user without first_name
user = UserFactory.create(last_name="my_last")
relate_user_method_settings.__dict__ = {}
# the next appelation is email
with override_settings(
RELATE_USER_FULL_NAME_FORMAT_METHOD=None):
self.assertEqual(user.get_email_appellation(), user.email)
relate_user_method_settings.__dict__ = {}
with override_settings(
RELATE_EMAIL_APPELLATION_PRIORITY_LIST=["full_name", "username"],
RELATE_USER_FULL_NAME_FORMAT_METHOD=None):
# because full_name is None
self.assertEqual(user.get_email_appellation(), user.username)
def test_serialize_account_status(self):
user = UserFactory()
info = serialize_user(user)
nt.assert_equal(info['disabled'], False)
user.is_disabled = True
info = serialize_user(user)
nt.assert_almost_equal(
int(info['disabled'].strftime('%s')),
int(datetime.utcnow().strftime('%s')),
delta=50)
nt.assert_is_instance(info['disabled'], datetime)
def test_employment(self):
user = UserFactory(fullname="Helga Finn")
user.save()
institution = "Finn's Fine Filers"
docs = query_user(institution)["results"]
assert_equal(len(docs), 0)
user.jobs.append({"institution": institution, "title": "The Big Finn"})
user.save()
docs = query_user(institution)["results"]
assert_equal(len(docs), 1)
def test_education(self):
user = UserFactory(fullname="Henry Johnson")
user.save()
institution = "Henry's Amazing School!!!"
docs = query_user(institution)["results"]
assert_equal(len(docs), 0)
user.schools.append({"institution": institution, "degree": "failed all classes"})
user.save()
docs = query_user(institution)["results"]
assert_equal(len(docs), 1)
def test_serialize_two_factor(self):
user = UserFactory()
info = serialize_user(user)
nt.assert_false(info['two_factor'])
user.get_or_add_addon('twofactor')
info = serialize_user(user)
nt.assert_is_instance(info, dict)
nt.assert_equal(info['name'], user.fullname)
nt.assert_equal(info['emails'], user.emails)
nt.assert_equal(info['last_login'], user.date_last_login)
nt.assert_equal(len(info['nodes']), 0)
nt.assert_true(info['two_factor'])
def test_question_update(client):
rs = ReaderStudyFactory(use_display_sets=False)
editor = UserFactory()
reader = UserFactory()
rs.editors_group.user_set.add(editor)
rs.readers_group.user_set.add(reader)
question = QuestionFactory(
question_text="foo",
reader_study=rs,
answer_type=Question.AnswerType.SINGLE_LINE_TEXT,
direction=Question.Direction.HORIZONTAL,
order=100,
)
response = get_view_for_user(
viewname="reader-studies:question-update",
client=client,
method=client.get,
reverse_kwargs={"slug": rs.slug, "pk": question.pk},
follow=True,
user=reader,
)
assert response.status_code == 403
response = get_view_for_user(
viewname="reader-studies:question-update",
client=client,
method=client.get,
reverse_kwargs={"slug": rs.slug, "pk": question.pk},
follow=True,
user=editor,
)
assert response.status_code == 200
assert question.question_text == "foo"
assert question.answer_type == Question.AnswerType.SINGLE_LINE_TEXT
assert question.direction == Question.Direction.HORIZONTAL
assert question.order == 100
get_view_for_user(
viewname="reader-studies:question-update",
client=client,
method=client.post,
data={
"question_text": "bar",
"answer_type": Question.AnswerType.BOOL,
"direction": Question.Direction.VERTICAL,
"order": 200,
"options-TOTAL_FORMS": 2,
"options-INITIAL_FORMS": 1,
"options-MIN_NUM_FORMS": 0,
"options-MAX_NUM_FORMS": 1000,
},
reverse_kwargs={"slug": rs.slug, "pk": question.pk},
follow=True,
user=editor,
)
question.refresh_from_db()
assert question.question_text == "bar"
assert question.answer_type == Question.AnswerType.BOOL
assert question.direction == Question.Direction.VERTICAL
assert question.order == 200
AnswerFactory(question=question, answer="true")
# An answer is added, so changing the question text should no longer be possible
get_view_for_user(
viewname="reader-studies:question-update",
client=client,
method=client.post,
data={
"question_text": "foo",
"answer_type": Question.AnswerType.SINGLE_LINE_TEXT,
"direction": Question.Direction.HORIZONTAL,
"order": 100,
"options-TOTAL_FORMS": 2,
"options-INITIAL_FORMS": 1,
"options-MIN_NUM_FORMS": 0,
"options-MAX_NUM_FORMS": 1000,
},
reverse_kwargs={"slug": rs.slug, "pk": question.pk},
follow=True,
user=editor,
)
question.refresh_from_db()
assert question.question_text == "bar"
assert question.answer_type == Question.AnswerType.BOOL
assert question.direction == Question.Direction.HORIZONTAL
assert question.order == 100
def test_get_user_with_wrong_password_returns_false(self):
user = UserFactory.build()
user.set_password('killerqueen')
assert_false(auth.get_user(email=user.username, password='******'))
def create_factories(self):
super().create_factories()
self.group = PropertyGroupFactory.create()
self.user, self.processor = UserFactory.create_batch(2)
def test_permission_required_views(self, client):
ai = AlgorithmImageFactory(ready=True)
s = RawImageUploadSessionFactory()
u = UserFactory()
j = AlgorithmJobFactory(algorithm_image=ai)
p = AlgorithmPermissionRequestFactory(algorithm=ai.algorithm)
for view_name, kwargs, permission, obj, redirect in [
("create", {}, "algorithms.add_algorithm", None, None),
(
"detail",
{
"slug": ai.algorithm.slug
},
"view_algorithm",
ai.algorithm,
reverse(
"algorithms:permission-request-create",
kwargs={"slug": ai.algorithm.slug},
),
),
(
"update",
{
"slug": ai.algorithm.slug
},
"change_algorithm",
ai.algorithm,
None,
),
(
"image-create",
{
"slug": ai.algorithm.slug
},
"change_algorithm",
ai.algorithm,
None,
),
(
"image-detail",
{
"slug": ai.algorithm.slug,
"pk": ai.pk
},
"view_algorithmimage",
ai,
None,
),
(
"image-update",
{
"slug": ai.algorithm.slug,
"pk": ai.pk
},
"change_algorithmimage",
ai,
None,
),
(
"execution-session-create",
{
"slug": ai.algorithm.slug
},
"execute_algorithm",
ai.algorithm,
None,
),
(
"execution-session-detail",
{
"slug": ai.algorithm.slug,
"pk": s.pk
},
"view_rawimageuploadsession",
s,
None,
),
(
"job-detail",
{
"slug": ai.algorithm.slug,
"pk": j.pk
},
"view_job",
j,
None,
),
(
"job-update",
{
"slug": ai.algorithm.slug,
"pk": j.pk
},
"change_job",
j,
None,
),
(
"job-viewers-update",
{
"slug": ai.algorithm.slug,
"pk": j.pk
},
"change_job",
j,
None,
),
(
"editors-update",
{
"slug": ai.algorithm.slug
},
"change_algorithm",
ai.algorithm,
None,
),
(
"users-update",
{
"slug": ai.algorithm.slug
},
"change_algorithm",
ai.algorithm,
None,
),
(
"permission-request-update",
{
"slug": ai.algorithm.slug,
"pk": p.pk
},
"change_algorithm",
ai.algorithm,
None,
),
]:
def _get_view():
return get_view_for_user(
client=client,
viewname=f"algorithms:{view_name}",
reverse_kwargs=kwargs,
user=u,
)
response = _get_view()
if redirect is not None:
assert response.status_code == 302
assert response.url == redirect
else:
assert response.status_code == 403
assign_perm(permission, u, obj)
response = _get_view()
assert response.status_code == 200
remove_perm(permission, u, obj)
def test_user_get_posts_by_followers1(self):
"""Should only return posts from users I'm following"""
user1 = UserFactory()
user2 = UserFactory()
user3 = UserFactory()
user4 = UserFactory()
user2_post1 = TextPost('Hello there friends', timestamp=datetime(2017, 2, 2))
user2_post2 = TextPost('Hello there friends', timestamp=datetime(2017, 2, 3))
user3_post1 = TextPost('Hello there friends', timestamp=datetime(2017, 2, 1))
user4_post1 = TextPost('Hello there friends', timestamp=datetime(2017, 2, 3))
user2.add_post(user2_post1)
user2.add_post(user2_post2)
user3.add_post(user3_post1)
user4.add_post(user4_post1)
# user1 follows user2 and user3
user1.follow(user2)
user1.follow(user3)
# 2 posts from user2 and 1 from user3
# post from user4 is excluded
self.assertEqual(len(user1.get_timeline()), 3)
self.assertFalse(user4_post1 in user1.get_timeline())
# should be sorted by creation timestamp
self.assertEqual(user1.get_timeline(), [
user2_post2,
user2_post1,
user3_post1
])
def test_full_name(db):
"""User full name."""
user = UserFactory(first_name="Foo", last_name="Bar")
assert user.full_name == "Foo Bar"
def test_algorithm_permission_request_update(client):
user = UserFactory()
editor = UserFactory()
alg = AlgorithmFactory(public=True)
alg.add_editor(editor)
pr = AlgorithmPermissionRequestFactory(algorithm=alg, user=user)
assert pr.status == AlgorithmPermissionRequest.PENDING
response = get_view_for_user(
viewname="algorithms:permission-request-update",
reverse_kwargs={
"slug": slugify(alg.slug),
"pk": pr.pk
},
client=client,
user=editor,
method=client.get,
follow=True,
)
assert "review access request for user" in response.rendered_content
assert "Request access" not in response.rendered_content
response = get_view_for_user(
viewname="algorithms:permission-request-update",
reverse_kwargs={
"slug": slugify(alg.slug),
"pk": pr.pk
},
client=client,
user=editor,
method=client.post,
follow=True,
data={"status": "NONEXISTENT"},
)
pr.refresh_from_db()
assert response.status_code == 200
assert pr.status == AlgorithmPermissionRequest.PENDING
response = get_view_for_user(
viewname="algorithms:permission-request-update",
reverse_kwargs={
"slug": slugify(alg.slug),
"pk": pr.pk
},
client=client,
user=editor,
method=client.post,
follow=True,
data={"status": AlgorithmPermissionRequest.REJECTED},
)
pr.refresh_from_db()
assert response.status_code == 200
assert pr.status == AlgorithmPermissionRequest.REJECTED
response = get_view_for_user(
viewname="algorithms:permission-request-update",
reverse_kwargs={
"slug": slugify(alg.slug),
"pk": pr.pk
},
client=client,
user=user,
method=client.get,
follow=True,
)
assert response.status_code == 403
# User should not be able to change the status
response = get_view_for_user(
viewname="algorithms:permission-request-update",
reverse_kwargs={
"slug": slugify(alg.slug),
"pk": pr.pk
},
client=client,
user=user,
method=client.post,
follow=True,
data={"status": AlgorithmPermissionRequest.ACCEPTED},
)
pr.refresh_from_db()
assert response.status_code == 403
assert pr.status == AlgorithmPermissionRequest.REJECTED
response = get_view_for_user(
viewname="algorithms:permission-request-update",
reverse_kwargs={
"slug": slugify(alg.slug),
"pk": pr.pk
},
client=client,
user=editor,
method=client.post,
follow=True,
data={"status": AlgorithmPermissionRequest.ACCEPTED},
)
pr.refresh_from_db()
assert response.status_code == 200
assert pr.status == AlgorithmPermissionRequest.ACCEPTED
class TestDropboxNodeSettingsModel(OsfTestCase):
def setUp(self):
super(TestDropboxNodeSettingsModel, self).setUp()
self.user = UserFactory()
self.user.add_addon('dropbox')
self.user.save()
self.user_settings = self.user.get_addon('dropbox')
self.project = ProjectFactory()
self.node_settings = DropboxNodeSettingsFactory(
user_settings=self.user_settings, owner=self.project)
def test_complete_true(self):
self.node_settings.user_settings.access_token = 'seems legit'
assert_true(self.node_settings.has_auth)
assert_true(self.node_settings.complete)
def test_complete_false(self):
self.node_settings.user_settings.access_token = 'seems legit'
self.node_settings.folder = None
assert_true(self.node_settings.has_auth)
assert_false(self.node_settings.complete)
def test_complete_auth_false(self):
self.node_settings.user_settings = None
assert_false(self.node_settings.has_auth)
assert_false(self.node_settings.complete)
def test_fields(self):
node_settings = DropboxNodeSettings(user_settings=self.user_settings)
node_settings.save()
assert_true(node_settings.user_settings)
assert_equal(node_settings.user_settings.owner, self.user)
assert_true(hasattr(node_settings, 'folder'))
assert_true(hasattr(node_settings, 'registration_data'))
def test_folder_defaults_to_none(self):
node_settings = DropboxNodeSettings(user_settings=self.user_settings)
node_settings.save()
assert_is_none(node_settings.folder)
def test_has_auth(self):
settings = DropboxNodeSettings(user_settings=self.user_settings)
settings.save()
assert_false(settings.has_auth)
settings.user_settings.access_token = '123abc'
settings.user_settings.save()
assert_true(settings.has_auth)
def test_to_json(self):
settings = self.node_settings
user = UserFactory()
result = settings.to_json(user)
assert_equal(result['addon_short_name'], 'dropbox')
def test_delete(self):
assert_true(self.node_settings.user_settings)
assert_true(self.node_settings.folder)
old_logs = self.project.logs
self.node_settings.delete()
self.node_settings.save()
assert_is(self.node_settings.user_settings, None)
assert_is(self.node_settings.folder, None)
assert_true(self.node_settings.deleted)
assert_equal(self.project.logs, old_logs)
def test_deauthorize(self):
assert_true(self.node_settings.user_settings)
assert_true(self.node_settings.folder)
self.node_settings.deauthorize(auth=Auth(self.user))
self.node_settings.save()
assert_is(self.node_settings.user_settings, None)
assert_is(self.node_settings.folder, None)
last_log = self.project.logs[-1]
assert_equal(last_log.action, 'dropbox_node_deauthorized')
params = last_log.params
assert_in('node', params)
assert_in('project', params)
assert_in('folder', params)
def test_set_folder(self):
folder_name = 'queen/freddie'
self.node_settings.set_folder(folder_name, auth=Auth(self.user))
self.node_settings.save()
# Folder was set
assert_equal(self.node_settings.folder, folder_name)
# Log was saved
last_log = self.project.logs[-1]
assert_equal(last_log.action, 'dropbox_folder_selected')
def test_set_user_auth(self):
node_settings = DropboxNodeSettingsFactory()
user_settings = DropboxUserSettingsFactory()
node_settings.set_user_auth(user_settings)
node_settings.save()
assert_true(node_settings.has_auth)
assert_equal(node_settings.user_settings, user_settings)
# A log was saved
last_log = node_settings.owner.logs[-1]
assert_equal(last_log.action, 'dropbox_node_authorized')
log_params = last_log.params
assert_equal(log_params['folder'], node_settings.folder)
assert_equal(log_params['node'], node_settings.owner._primary_key)
assert_equal(last_log.user, user_settings.owner)
def test_serialize_credentials(self):
self.user_settings.access_token = 'secret'
self.user_settings.save()
credentials = self.node_settings.serialize_waterbutler_credentials()
expected = {'token': self.node_settings.user_settings.access_token}
assert_equal(credentials, expected)
def test_serialize_credentials_not_authorized(self):
self.node_settings.user_settings = None
self.node_settings.save()
with assert_raises(exceptions.AddonError):
self.node_settings.serialize_waterbutler_credentials()
def test_serialize_settings(self):
settings = self.node_settings.serialize_waterbutler_settings()
expected = {'folder': self.node_settings.folder}
assert_equal(settings, expected)
def test_serialize_settings_not_configured(self):
self.node_settings.folder = None
self.node_settings.save()
with assert_raises(exceptions.AddonError):
self.node_settings.serialize_waterbutler_settings()
def test_create_log(self):
action = 'file_added'
path = 'pizza.nii'
nlog = len(self.project.logs)
self.node_settings.create_waterbutler_log(
auth=Auth(user=self.user),
action=action,
metadata={'path': path},
)
self.project.reload()
assert_equal(len(self.project.logs), nlog + 1)
assert_equal(
self.project.logs[-1].action,
'dropbox_{0}'.format(action),
)
assert_equal(
self.project.logs[-1].params['path'],
os.path.join(self.node_settings.folder, path),
)
def test_does_not_get_copied_to_registrations(self):
registration = self.project.register_node(
schema=None,
auth=Auth(user=self.project.creator),
template='Template1',
data='hodor')
assert_false(registration.has_addon('dropbox'))
def test_to_json(self):
settings = self.node_settings
user = UserFactory()
result = settings.to_json(user)
assert_equal(result['addon_short_name'], 'dropbox')
def setUp(self):
super(TestSerializingFolders, self).setUp()
self.user = UserFactory()
self.auth = AuthFactory(user=self.user)
def setUp(self):
super(TestUserSettingsModel, self).setUp()
self.user = UserFactory()
def admins(self, create, extracted, **kwargs):
self.admins = extracted or [UserFactory()]
def test_reader_study_add_ground_truth(client, settings):
settings.task_eager_propagates = (True,)
settings.task_always_eager = (True,)
rs = ReaderStudyFactory(use_display_sets=False)
q = QuestionFactory(
reader_study=rs,
question_text="bar",
answer_type=Question.AnswerType.SINGLE_LINE_TEXT,
)
q0 = QuestionFactory(
reader_study=rs,
question_text="bool",
answer_type=Question.AnswerType.BOOL,
)
q1 = QuestionFactory(
reader_study=rs,
question_text="choice",
answer_type=Question.AnswerType.CHOICE,
)
q2 = QuestionFactory(
reader_study=rs,
question_text="mchoice",
answer_type=Question.AnswerType.MULTIPLE_CHOICE,
)
options = {}
for i, q_ in enumerate([q1, q2]):
for x in range(3):
options[f"{i}-{x}"] = CategoricalOptionFactory(
question=q_, title=f"option{x}"
)
im1, im2, im3, im4 = (
ImageFactory(name="im1"),
ImageFactory(name="im2"),
ImageFactory(name="im3"),
ImageFactory(name="im4"),
)
rs.images.set([im1.pk, im2.pk, im3.pk, im4.pk])
rs.hanging_list = [
{"primary": "im1"},
{"primary": "im2"},
{"primary": "im3"},
{"secondary": "im4"},
]
rs.save()
assert rs.hanging_list_valid
editor = UserFactory()
reader = UserFactory()
rs.editors_group.user_set.add(editor)
rs.readers_group.user_set.add(reader)
response = get_view_for_user(
viewname="reader-studies:add-ground-truth",
client=client,
method=client.get,
reverse_kwargs={"slug": rs.slug},
follow=True,
user=reader,
)
assert response.status_code == 403
response = get_view_for_user(
viewname="reader-studies:add-ground-truth",
client=client,
method=client.get,
reverse_kwargs={"slug": rs.slug},
follow=True,
user=editor,
)
assert response.status_code == 200
assert Answer.objects.all().count() == 0
with open(RESOURCE_PATH / "ground_truth.csv") as gt:
response = get_view_for_user(
viewname="reader-studies:add-ground-truth",
client=client,
method=client.post,
reverse_kwargs={"slug": rs.slug},
data={"ground_truth": gt},
follow=True,
user=editor,
)
assert response.status_code == 200
assert (
f"Fields provided do not match with reader study. Fields should "
f"be: {','.join(rs.ground_truth_file_headers)}"
in response.rendered_content
)
q.question_text = "foo"
q.save()
with open(RESOURCE_PATH / "ground_truth.csv") as gt:
response = get_view_for_user(
viewname="reader-studies:add-ground-truth",
client=client,
method=client.post,
reverse_kwargs={"slug": rs.slug},
data={"ground_truth": gt},
follow=True,
user=editor,
)
assert response.status_code == 200
assert (
"Images provided do not match hanging protocol"
in response.rendered_content
)
with open(RESOURCE_PATH / "ground_truth_wrong_images.csv") as gt:
response = get_view_for_user(
viewname="reader-studies:add-ground-truth",
client=client,
method=client.post,
reverse_kwargs={"slug": rs.slug},
data={"ground_truth": gt},
follow=True,
user=editor,
)
assert response.status_code == 200
assert (
"Images provided do not match hanging protocol"
in response.rendered_content
)
assert (
"The following images appear in the file, but not in the hanging "
"list: im5." in response.rendered_content
)
assert (
"These images appear in the hanging list, but not in the file: im4."
in response.rendered_content.replace(r"[\n']", "")
)
rs.hanging_list = [
{"primary": "im1"},
{"primary": "im2"},
{"primary": "im3", "secondary": "im4"},
]
rs.save()
assert rs.hanging_list_valid
with open(RESOURCE_PATH / "ground_truth_invalid.csv") as gt:
response = get_view_for_user(
viewname="reader-studies:add-ground-truth",
client=client,
method=client.post,
reverse_kwargs={"slug": rs.slug},
data={"ground_truth": gt},
follow=True,
user=editor,
)
assert response.status_code == 200
assert (
html.escape("Option 'option3' is not valid for question choice")
in response.rendered_content
)
with open(RESOURCE_PATH / "ground_truth.csv") as gt:
response = get_view_for_user(
viewname="reader-studies:add-ground-truth",
client=client,
method=client.post,
reverse_kwargs={"slug": rs.slug},
data={"ground_truth": gt},
follow=True,
user=editor,
)
assert response.status_code == 200
answer_count = len(rs.hanging_list) * rs.answerable_question_count
assert Answer.objects.all().count() == answer_count
assert Answer.objects.filter(is_ground_truth=True).count() == answer_count
assert Answer.objects.get(images__in=[im1.pk], question=q).answer == "yes"
assert (
Answer.objects.get(images__in=[im1.pk], question=q).explanation
== "explanation, with a comma"
)
assert (
Answer.objects.get(images__in=[im2.pk], question=q).explanation == ""
)
assert Answer.objects.get(images__in=[im1.pk], question=q0).answer is True
assert (
Answer.objects.get(images__in=[im1.pk], question=q1).answer
== options["0-1"].pk
)
assert sorted(
Answer.objects.get(images__in=[im1.pk], question=q2).answer
) == sorted([options["1-1"].pk, options["1-2"].pk])
with open(RESOURCE_PATH / "ground_truth_new.csv") as gt:
response = get_view_for_user(
viewname="reader-studies:add-ground-truth",
client=client,
method=client.post,
reverse_kwargs={"slug": rs.slug},
data={"ground_truth": gt},
follow=True,
user=editor,
)
assert response.status_code == 200
assert Answer.objects.all().count() == answer_count
assert Answer.objects.filter(is_ground_truth=True).count() == answer_count
assert Answer.objects.get(images__in=[im1.pk], question=q).answer == "no"
assert (
Answer.objects.get(images__in=[im1.pk], question=q).explanation
== "new explanation"
)
assert (
Answer.objects.get(images__in=[im2.pk], question=q).explanation
== "explanation"
)
assert Answer.objects.get(images__in=[im1.pk], question=q0).answer is False
assert (
Answer.objects.get(images__in=[im1.pk], question=q1).answer
== options["0-2"].pk
)
assert Answer.objects.get(images__in=[im1.pk], question=q2).answer == [
options["1-0"].pk
]
def test_reader_study_copy(client):
rs = ReaderStudyFactory(title="copied")
editor = UserFactory()
editor2 = UserFactory()
reader = UserFactory()
rs.add_reader(reader)
rs.add_editor(editor)
rs.add_editor(editor2)
QuestionFactory(
reader_study=rs,
answer_type=Question.AnswerType.BOOL,
question_text="q1",
),
QuestionFactory(
reader_study=rs,
answer_type=Question.AnswerType.BOOL,
question_text="q2",
)
im1, im2 = ImageFactory(), ImageFactory()
rs.images.set([im1, im2])
rs.hanging_list = [{"main": im1.name}, {"main": im2.name}]
rs.case_text = {im1.name: "test", im2.name: "test2"}
rs.save()
assert ReaderStudy.objects.count() == 1
response = get_view_for_user(
viewname="reader-studies:copy",
client=client,
method=client.post,
reverse_kwargs={"slug": rs.slug},
data={"title": "1"},
user=reader,
follow=True,
)
assert response.status_code == 403
assert ReaderStudy.objects.count() == 1
response = get_view_for_user(
viewname="reader-studies:copy",
client=client,
method=client.post,
reverse_kwargs={"slug": rs.slug},
data={"title": "1"},
user=editor,
follow=True,
)
assert response.status_code == 403
assert ReaderStudy.objects.count() == 1
add_perm = Permission.objects.get(
codename=f"add_{ReaderStudy._meta.model_name}"
)
editor.user_permissions.add(add_perm)
response = get_view_for_user(
viewname="reader-studies:copy",
client=client,
method=client.post,
reverse_kwargs={"slug": rs.slug},
data={"title": "1"},
user=editor,
follow=True,
)
assert response.status_code == 200
assert ReaderStudy.objects.count() == 2
_rs = ReaderStudy.objects.order_by("created").last()
assert _rs.title == "1"
assert _rs.images.count() == 0
assert _rs.questions.count() == 0
assert _rs.readers_group.user_set.count() == 0
assert _rs.editors_group.user_set.count() == 1
assert _rs.hanging_list == []
assert _rs.case_text == {}
response = get_view_for_user(
viewname="reader-studies:copy",
client=client,
method=client.post,
reverse_kwargs={"slug": rs.slug},
data={"title": "2", "copy_questions": True},
user=editor,
follow=True,
)
assert response.status_code == 200
assert ReaderStudy.objects.count() == 3
_rs = ReaderStudy.objects.order_by("created").last()
assert _rs.title == "2"
assert _rs.questions.count() == 2
assert _rs.images.count() == 0
assert _rs.hanging_list == []
assert _rs.case_text == {}
assert _rs.readers_group.user_set.count() == 0
assert _rs.editors_group.user_set.count() == 1
response = get_view_for_user(
viewname="reader-studies:copy",
client=client,
method=client.post,
reverse_kwargs={"slug": rs.slug},
data={"title": "3", "copy_images": True},
user=editor,
follow=True,
)
assert response.status_code == 200
assert ReaderStudy.objects.count() == 4
_rs = ReaderStudy.objects.order_by("created").last()
assert _rs.title == "3"
assert _rs.questions.count() == 0
assert _rs.images.count() == 2
assert _rs.hanging_list == []
assert _rs.case_text == {}
assert _rs.readers_group.user_set.count() == 0
assert _rs.editors_group.user_set.count() == 1
response = get_view_for_user(
viewname="reader-studies:copy",
client=client,
method=client.post,
reverse_kwargs={"slug": rs.slug},
data={"title": "4", "copy_hanging_list": True},
user=editor,
follow=True,
)
assert response.status_code == 200
assert (
"Hanging list and case text can only be copied if the images are copied as well"
in response.rendered_content
)
assert ReaderStudy.objects.count() == 4
response = get_view_for_user(
viewname="reader-studies:copy",
client=client,
method=client.post,
reverse_kwargs={"slug": rs.slug},
data={"title": "4", "copy_images": True, "copy_hanging_list": True},
user=editor,
follow=True,
)
assert response.status_code == 200
assert ReaderStudy.objects.count() == 5
_rs = ReaderStudy.objects.order_by("created").last()
assert _rs.title == "4"
assert _rs.questions.count() == 0
assert _rs.images.count() == 2
assert _rs.hanging_list == rs.hanging_list
assert _rs.case_text == {}
assert _rs.readers_group.user_set.count() == 0
assert _rs.editors_group.user_set.count() == 1
response = get_view_for_user(
viewname="reader-studies:copy",
client=client,
method=client.post,
reverse_kwargs={"slug": rs.slug},
data={"title": "5", "copy_images": True, "copy_case_text": True},
user=editor,
follow=True,
)
assert response.status_code == 200
assert ReaderStudy.objects.count() == 6
_rs = ReaderStudy.objects.order_by("created").last()
assert _rs.title == "5"
assert _rs.questions.count() == 0
assert _rs.images.count() == 2
assert _rs.hanging_list == []
assert _rs.case_text == rs.case_text
assert _rs.readers_group.user_set.count() == 0
assert _rs.editors_group.user_set.count() == 1
response = get_view_for_user(
viewname="reader-studies:copy",
client=client,
method=client.post,
reverse_kwargs={"slug": rs.slug},
data={"title": "6", "copy_readers": True},
user=editor,
follow=True,
)
assert response.status_code == 200
assert ReaderStudy.objects.count() == 7
_rs = ReaderStudy.objects.order_by("created").last()
assert _rs.title == "6"
assert _rs.questions.count() == 0
assert _rs.images.count() == 0
assert _rs.hanging_list == []
assert _rs.case_text == {}
assert _rs.readers_group.user_set.count() == 1
assert _rs.editors_group.user_set.count() == 1
response = get_view_for_user(
viewname="reader-studies:copy",
client=client,
method=client.post,
reverse_kwargs={"slug": rs.slug},
data={"title": "7", "copy_editors": True},
user=editor,
follow=True,
)
assert response.status_code == 200
assert ReaderStudy.objects.count() == 8
_rs = ReaderStudy.objects.order_by("created").last()
assert _rs.title == "7"
assert _rs.questions.count() == 0
assert _rs.images.count() == 0
assert _rs.hanging_list == []
assert _rs.case_text == {}
assert _rs.readers_group.user_set.count() == 0
assert _rs.editors_group.user_set.count() == 2
class TestAddonGithubNodeSettings(OsfTestCase):
def setUp(self):
OsfTestCase.setUp(self)
self.user = UserFactory()
self.user.add_addon('github')
self.user_settings = self.user.get_addon('github')
self.oauth_settings = AddonGitHubOauthSettings(oauth_access_token='foobar')
self.oauth_settings.github_user_id = 'testuser'
self.oauth_settings.save()
self.user_settings.oauth_settings = self.oauth_settings
self.user_settings.save()
self.node_settings = AddonGitHubNodeSettings(
owner=ProjectFactory(),
user='******',
repo='openpokemon',
user_settings=self.user_settings,
)
self.node_settings.save()
def test_complete_true(self):
assert_true(self.node_settings.has_auth)
assert_true(self.node_settings.complete)
def test_complete_false(self):
self.node_settings.user = None
assert_true(self.node_settings.has_auth)
assert_false(self.node_settings.complete)
def test_complete_repo_false(self):
self.node_settings.repo = None
assert_true(self.node_settings.has_auth)
assert_false(self.node_settings.complete)
def test_complete_auth_false(self):
self.node_settings.user_settings = None
assert_false(self.node_settings.has_auth)
assert_false(self.node_settings.complete)
@mock.patch('website.addons.github.api.GitHub.delete_hook')
def test_delete_hook(self, mock_delete_hook):
self.node_settings.hook_id = 'hook'
self.node_settings.save()
args = (
self.node_settings.user,
self.node_settings.repo,
self.node_settings.hook_id,
)
res = self.node_settings.delete_hook()
assert_true(res)
mock_delete_hook.assert_called_with(*args)
@mock.patch('website.addons.github.api.GitHub.delete_hook')
def test_delete_hook_no_hook(self, mock_delete_hook):
res = self.node_settings.delete_hook()
assert_false(res)
assert_false(mock_delete_hook.called)
@mock.patch('website.addons.github.api.GitHub.delete_hook')
def test_delete_hook_not_found(self, mock_delete_hook):
self.node_settings.hook_id = 'hook'
self.node_settings.save()
mock_delete_hook.side_effect = NotFoundError
args = (
self.node_settings.user,
self.node_settings.repo,
self.node_settings.hook_id,
)
res = self.node_settings.delete_hook()
assert_false(res)
mock_delete_hook.assert_called_with(*args)
@mock.patch('website.addons.github.api.GitHub.delete_hook')
def test_delete_hook_error(self, mock_delete_hook):
self.node_settings.hook_id = 'hook'
self.node_settings.save()
mock_delete_hook.side_effect = GitHubError(mock.Mock())
args = (
self.node_settings.user,
self.node_settings.repo,
self.node_settings.hook_id,
)
res = self.node_settings.delete_hook()
assert_false(res)
mock_delete_hook.assert_called_with(*args)
def test_to_json_noauthorizing_authed_user(self):
user = UserFactory()
user.add_addon('github')
user_settings = user.get_addon('github')
oauth_settings = AddonGitHubOauthSettings(oauth_access_token='foobar')
oauth_settings.github_user_id = 'testuser'
oauth_settings.save()
user_settings.oauth_settings = self.oauth_settings
user_settings.save()
self.node_settings.to_json(user)
def setUp(self):
super(OsfTestCase, self).setUp()
self.user = UserFactory()
self.project = ProjectFactory(creator=self.user)
self.project.add_addon('s3', auth=Auth(self.user))
self.node_addon = self.project.get_addon('s3')
def test_must_be_logged_in_decorator_with_user(self, mock_from_kwargs):
user = UserFactory()
mock_from_kwargs.return_value = Auth(user=user)
protected()
def test_node_settings_no_contributor_user_settings(self, mock_is_valid):
mock_is_valid.return_value = True
user2 = UserFactory()
self.project.add_contributor(user2)
assert_false(self.node_settings.to_json(user2)['user_has_auth'])
def test_user_can_download_images(client, reverse):
alg_set = TwoAlgorithms()
j1_creator, j2_creator = UserFactory(), UserFactory()
alg1_job = AlgorithmJobFactory(algorithm_image__algorithm=alg_set.alg1,
creator=j1_creator)
alg2_job = AlgorithmJobFactory(algorithm_image__algorithm=alg_set.alg2,
creator=j2_creator)
alg1_job.viewer_groups.add(alg_set.alg1.editors_group)
alg2_job.viewer_groups.add(alg_set.alg2.editors_group)
iv1, iv2, iv3, iv4 = (
ComponentInterfaceValueFactory(image=ImageFactory()),
ComponentInterfaceValueFactory(image=ImageFactory()),
ComponentInterfaceValueFactory(image=ImageFactory()),
ComponentInterfaceValueFactory(image=ImageFactory()),
)
if reverse:
for im in [iv1, iv2, iv3, iv4]:
im.algorithms_jobs_as_output.add(alg1_job, alg2_job)
for im in [iv3, iv4]:
im.algorithms_jobs_as_output.remove(alg1_job, alg2_job)
for im in [iv1, iv2]:
im.algorithms_jobs_as_output.remove(alg2_job)
else:
# Test that adding images works
alg1_job.outputs.add(iv1, iv2, iv3, iv4)
# Test that removing images works
alg1_job.outputs.remove(iv3, iv4)
tests = (
(None, 200, []),
(alg_set.creator, 200, []),
(
alg_set.editor1,
200,
[
*[i.image.pk for i in alg1_job.inputs.all()],
iv1.image.pk,
iv2.image.pk,
],
),
(alg_set.user1, 200, []),
(
j1_creator,
200,
[
*[i.image.pk for i in alg1_job.inputs.all()],
iv1.image.pk,
iv2.image.pk,
],
),
(
alg_set.editor2,
200,
[i.image.pk for i in alg2_job.inputs.all()],
),
(alg_set.user2, 200, []),
(j2_creator, 200, [i.image.pk for i in alg2_job.inputs.all()]),
(alg_set.u, 200, []),
)
for test in tests:
response = get_view_for_user(
viewname="api:image-list",
client=client,
user=test[0],
content_type="application/json",
)
assert response.status_code == test[1]
assert response.json()["count"] == len(test[2])
pks = {obj["pk"] for obj in response.json()["results"]}
assert {str(pk) for pk in test[2]} == pks
# Test clearing
if reverse:
iv1.algorithms_jobs_as_output.clear()
iv2.algorithms_jobs_as_output.clear()
else:
alg1_job.outputs.clear()
response = get_view_for_user(
viewname="api:image-list",
client=client,
user=j1_creator,
content_type="application/json",
)
assert response.status_code == 200
assert response.json()["count"] == 1
def test_get_user_ids_for_site(self):
expected_users = [UserFactory() for i in range(3)]
with mock.patch('figures.helpers.settings.FEATURES', self.features):
user_ids = figures.sites.get_user_ids_for_site(self.site)
assert set(user_ids) == set([user.id for user in expected_users])
def test_algorithm_jobs_list_view(client):
editor = UserFactory()
alg = AlgorithmFactory(public=True)
alg.add_editor(editor)
im = AlgorithmImageFactory(algorithm=alg)
for x in range(50):
created = timezone.now() - datetime.timedelta(days=x + 365)
job = AlgorithmJobFactory(algorithm_image=im, status=Job.SUCCESS)
job.created = created
job.save()
job.viewer_groups.add(alg.editors_group)
response = get_view_for_user(
viewname="algorithms:job-list",
reverse_kwargs={"slug": slugify(alg.slug)},
client=client,
user=editor,
method=client.get,
follow=True,
)
assert response.status_code == 200
response = get_view_for_user(
viewname="algorithms:job-list",
reverse_kwargs={"slug": slugify(alg.slug)},
client=client,
user=editor,
method=client.get,
follow=True,
data={
"length": 10,
"draw": 1,
"order[0][dir]": "desc",
"order[0][column]": 0,
},
**{"HTTP_X_REQUESTED_WITH": "XMLHttpRequest"},
)
resp = response.json()
assert resp["recordsTotal"] == 50
assert len(resp["data"]) == 10
response = get_view_for_user(
viewname="algorithms:job-list",
reverse_kwargs={"slug": slugify(alg.slug)},
client=client,
user=editor,
method=client.get,
follow=True,
data={
"length": 50,
"draw": 1,
"order[0][dir]": "desc",
"order[0][column]": 0,
},
**{"HTTP_X_REQUESTED_WITH": "XMLHttpRequest"},
)
resp = response.json()
assert resp["recordsTotal"] == 50
assert len(resp["data"]) == 50
response = get_view_for_user(
viewname="algorithms:job-list",
reverse_kwargs={"slug": slugify(alg.slug)},
client=client,
user=editor,
method=client.get,
follow=True,
data={
"length": 50,
"draw": 1,
"order[0][dir]": "asc",
"order[0][column]": 0,
},
**{"HTTP_X_REQUESTED_WITH": "XMLHttpRequest"},
)
resp_new = response.json()
assert resp_new["recordsTotal"] == 50
assert resp_new["data"] == resp["data"][::-1]
response = get_view_for_user(
viewname="algorithms:job-list",
reverse_kwargs={"slug": slugify(alg.slug)},
client=client,
user=editor,
method=client.get,
follow=True,
data={
"length": 50,
"draw": 1,
"search[value]": job.creator.username,
"order[0][column]": 0,
},
**{"HTTP_X_REQUESTED_WITH": "XMLHttpRequest"},
)
resp = response.json()
assert resp["recordsTotal"] == 50
assert resp["recordsFiltered"] == 1
assert len(resp["data"]) == 1
def user_no_room(address):
return UserFactory(address=address, room=None)
def test_user_follow(self):
user1 = UserFactory()
user2 = UserFactory()
user1.follow(user2)
self.assertEqual(len(user1.following), 1)
self.assertTrue(user2 in user1.following)
def user_with_room(session, address):
return UserFactory(address=address)
def test_logged_in(self):
user = UserFactory()
auth_obj = Auth(user=user)
assert_true(auth_obj.logged_in)
auth2 = Auth(user=None)
assert_false(auth2.logged_in)
def test_before_page_load_not_contributor(self):
message = self.node_settings.before_page_load(self.project, UserFactory())
assert_false(message)
class TestGoogleDriveNodeSettingsModel(OsfTestCase):
def setUp(self):
super(TestGoogleDriveNodeSettingsModel, self).setUp()
self.user = UserFactory()
self.user.add_addon('googledrive')
self.user.save()
self.user_settings = self.user.get_addon('googledrive')
oauth_settings = GoogleDriveOAuthSettingsFactory()
oauth_settings.save()
self.user_settings.oauth_settings = oauth_settings
self.user_settings.save()
self.project = ProjectFactory()
self.node_settings = GoogleDriveNodeSettingsFactory(
user_settings=self.user_settings,
owner=self.project,
)
def test_fields(self):
node_settings = GoogleDriveNodeSettings(user_settings=self.user_settings)
node_settings.save()
assert_true(node_settings.user_settings)
assert_true(hasattr(node_settings, 'folder_id'))
assert_true(hasattr(node_settings, 'folder_path'))
assert_true(hasattr(node_settings, 'folder_name'))
assert_equal(node_settings.user_settings.owner, self.user)
def test_complete_true(self):
assert_true(self.node_settings.has_auth)
assert_true(self.node_settings.complete)
def test_complete_false(self):
self.node_settings.folder_id = None
assert_true(self.node_settings.has_auth)
assert_false(self.node_settings.complete)
def test_complete_auth_false(self):
self.node_settings.user_settings = None
assert_false(self.node_settings.has_auth)
assert_false(self.node_settings.complete)
def test_folder_defaults_to_none(self):
node_settings = GoogleDriveNodeSettings(user_settings=self.user_settings)
node_settings.save()
assert_is_none(node_settings.folder_id)
assert_is_none(node_settings.folder_path)
def test_has_auth(self):
settings = GoogleDriveNodeSettings(user_settings=self.user_settings)
settings.user_settings.access_token = None
settings.save()
assert_false(settings.has_auth)
settings.user_settings.access_token = '123abc'
settings.user_settings.save()
assert_true(settings.has_auth)
# TODO use this test if delete function is used in googledrive/model
# def test_delete(self):
# assert_true(self.node_settings.user_settings)
# assert_true(self.node_settings.folder)
# old_logs = self.project.logs
# self.node_settings.delete()
# self.node_settings.save()
# assert_is(self.node_settings.user_settings, None)
# assert_is(self.node_settings.folder, None)
# assert_true(self.node_settings.deleted)
# assert_equal(self.project.logs, old_logs)
def test_deauthorize(self):
assert_true(self.node_settings.folder_id)
assert_true(self.node_settings.user_settings)
self.node_settings.deauthorize(auth=Auth(self.user))
self.node_settings.save()
assert_is(self.node_settings.folder_id, None)
assert_is(self.node_settings.user_settings, None)
last_log = self.project.logs[-1]
params = last_log.params
assert_in('node', params)
assert_in('folder', params)
assert_in('project', params)
assert_equal(last_log.action, 'googledrive_node_deauthorized')
def test_set_folder(self):
folder_name = {
'id': '1234',
'name': 'freddie',
'path': 'queen/freddie',
}
self.node_settings.set_folder(folder_name, auth=Auth(self.user))
self.node_settings.save()
# Folder was set
assert_equal(self.node_settings.folder_name, folder_name['name'])
# Log was saved
last_log = self.project.logs[-1]
assert_equal(last_log.action, 'googledrive_folder_selected')
def test_set_user_auth(self):
node_settings = GoogleDriveNodeSettingsFactory()
user_settings = GoogleDriveUserSettingsFactory()
node_settings.set_user_auth(user_settings)
node_settings.save()
assert_true(node_settings.has_auth)
assert_equal(node_settings.user_settings, user_settings)
# A log was saved
last_log = node_settings.owner.logs[-1]
log_params = last_log.params
assert_equal(last_log.user, user_settings.owner)
assert_equal(log_params['folder'], node_settings.folder_path)
assert_equal(last_log.action, 'googledrive_node_authorized')
assert_equal(log_params['node'], node_settings.owner._primary_key)
def test_serialize_credentials(self):
self.user_settings.access_token = 'secret'
self.user_settings.save()
credentials = self.node_settings.serialize_waterbutler_credentials()
expected = {'token': self.node_settings.user_settings.access_token}
assert_equal(credentials, expected)
def test_serialize_credentials_not_authorized(self):
self.node_settings.user_settings = None
self.node_settings.save()
with assert_raises(exceptions.AddonError):
self.node_settings.serialize_waterbutler_credentials()
def test_serialize_settings(self):
self.node_settings.folder_path = 'camera uploads/pizza.nii'
self.node_settings.save()
settings = self.node_settings.serialize_waterbutler_settings()
expected = {
'folder': {
'id': '12345',
'name': 'pizza.nii',
'path': 'camera uploads/pizza.nii',
}
}
assert_equal(settings, expected)
def test_serialize_settings_not_configured(self):
self.node_settings.folder_id = None
self.node_settings.save()
with assert_raises(exceptions.AddonError):
self.node_settings.serialize_waterbutler_settings()
def test_create_log(self):
action = 'file_added'
path = '12345/camera uploads/pizza.nii'
nlog = len(self.project.logs)
self.node_settings.create_waterbutler_log(
auth=Auth(user=self.user),
action=action,
metadata={'path': path},
)
self.project.reload()
assert_equal(len(self.project.logs), nlog + 1)
assert_equal(
self.project.logs[-1].action,
'googledrive_{0}'.format(action),
)
assert_equal(self.project.logs[-1].params['path'], path)
def test_repr(self):
self.user_settings.owner = UserFactory()
assert_in(self.user_settings.owner._id, repr(self.user_settings))
oauth_settings = GitHubOauthSettingsFactory()
def test_get_user_by_email(self):
user = UserFactory()
assert_equal(auth.get_user(email=user.username), user)
def test_get_user_by_id(self):
user = UserFactory()
assert_equal(User.load(user._id), user)
