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)