def test_migrate_project_contributed(self): user1 = UserFactory() fullname1 = 'hello world' email1 = '*****@*****.**' project1 = ProjectFactory(creator=user1) user2 = project1.add_unregistered_contributor(fullname=fullname1, email=email1, auth=Auth(user=user1)) project1.save() assert project1.is_contributor(user2) is True assert len(project1.contributors) is 2 migrate_project_contributed(user2) assert project1.is_contributor(user2) is False assert len(project1.contributors) is 1 user3 = UserFactory() project2 = ProjectFactory(creator=user1) project2.add_contributor(user3) project2.save() assert project2.is_contributor(user3) is True assert len(project2.contributors) is 2 migrate_project_contributed(user3) assert project2.is_contributor(user3) is False assert len(project2.contributors) is 1
class LogsTestCase(ApiTestCase): def setUp(self): super(LogsTestCase, self).setUp() self.user = AuthUserFactory() self.action_set = NodeLog.actions self.node = ProjectFactory(is_public=False) for i in range(len(self.action_set)): self.node.add_log(self.action_set[i], {}, Auth(self.node.creator), save=True) self.node.add_contributor(self.user, permissions=[osf_permissions.READ], auth=Auth(self.node.creator), log=False, save=True) self.node_log_url = '/{}nodes/{}/logs/'.format(API_BASE, self.node._id) self.url = '/{}logs/'.format(API_BASE) self.public_node = ProjectFactory(is_public=True) for i in range(len(self.action_set)): self.public_node.add_log(self.action_set[i], {}, Auth(self.public_node.creator), save=True) def tearDown(self): NodeLog.remove() Node.remove()
def test_do_migration(self): user1 = UserFactory() fullname1 = 'Presentation Service' email1 = '*****@*****.**' project1 = ProjectFactory(creator=user1) user2 = project1.add_unregistered_contributor(fullname=fullname1, email=email1, auth=Auth(user=user1)) project1.save() user3 = UserFactory.build(username='******', fullname=fullname1) user3.save() project2 = ProjectFactory(creator=user1) project2.add_contributor(user3) project2.save() assert project1.is_contributor(user2) is True assert len(project1.contributors) is 2 assert project2.is_contributor(user3) is True assert len(project2.contributors) is 2 user_list = get_targets() do_migration(user_list) assert project2.is_contributor(user3) is False assert len(project2.contributors) is 1 assert project1.is_contributor(user2) is False assert len(project1.contributors) is 1 assert user2.is_disabled is True assert user3.is_disabled is True
def test_get_children_only_returns_child_nodes_with_admin_permissions(self): user = UserFactory() admin_project = ProjectFactory() admin_project.add_contributor( user, auth=Auth(admin_project.creator), permissions=permissions.expand_permissions(permissions.ADMIN) ) admin_project.save() admin_component = NodeFactory(parent=admin_project) admin_component.add_contributor( user, auth=Auth(admin_component.creator), permissions=permissions.expand_permissions(permissions.ADMIN) ) admin_component.save() read_and_write = NodeFactory(parent=admin_project) read_and_write.add_contributor( user, auth=Auth(read_and_write.creator), permissions=permissions.expand_permissions(permissions.WRITE) ) read_and_write.save() read_only = NodeFactory(parent=admin_project) read_only.add_contributor( user, auth=Auth(read_only.creator), permissions=permissions.expand_permissions(permissions.READ) ) read_only.save() non_contributor = NodeFactory(parent=admin_project) components = _get_children(admin_project, Auth(user)) assert_equal(len(components), 1)
class TestMustBeContributorDecorator(AuthAppTestCase): def setUp(self): super(TestMustBeContributorDecorator, self).setUp() self.contrib = AuthUserFactory() self.project = ProjectFactory() self.project.add_contributor(self.contrib, auth=Auth(self.project.creator)) self.project.save() def test_must_be_contributor_when_user_is_contributor(self): result = view_that_needs_contributor(pid=self.project._primary_key, api_key=self.contrib.auth[1], api_node=self.project, user=self.contrib) assert_equal(result, self.project) def test_must_be_contributor_when_user_is_not_contributor_raises_error( self): non_contributor = AuthUserFactory() with assert_raises(HTTPError): view_that_needs_contributor(pid=self.project._primary_key, api_key=non_contributor.auth[1], api_node=non_contributor.auth[1], user=non_contributor) def test_must_be_contributor_no_user(self): res = view_that_needs_contributor( pid=self.project._primary_key, user=None, api_key='123', api_node='abc', ) assert_is_redirect(res) redirect_url = res.headers['Location'] assert_equal(redirect_url, '/login/?next=/')
def test_get_children_only_returns_child_nodes_with_admin_permissions( self): user = UserFactory() admin_project = ProjectFactory() admin_project.add_contributor( user, auth=Auth(admin_project.creator), permissions=permissions.expand_permissions(permissions.ADMIN)) admin_project.save() admin_component = NodeFactory(parent=admin_project) admin_component.add_contributor( user, auth=Auth(admin_component.creator), permissions=permissions.expand_permissions(permissions.ADMIN)) admin_component.save() read_and_write = NodeFactory(parent=admin_project) read_and_write.add_contributor( user, auth=Auth(read_and_write.creator), permissions=permissions.expand_permissions(permissions.WRITE)) read_and_write.save() read_only = NodeFactory(parent=admin_project) read_only.add_contributor(user, auth=Auth(read_only.creator), permissions=permissions.expand_permissions( permissions.READ)) read_only.save() non_contributor = NodeFactory(parent=admin_project) components = _get_children(admin_project, Auth(user)) assert_equal(len(components), 1)
class LogsTestCase(ApiTestCase): def setUp(self): super(LogsTestCase, self).setUp() self.user = AuthUserFactory() self.action_set = NodeLog.actions self.node = ProjectFactory(is_public=False) for i in range(len(self.action_set)): self.node.add_log( self.action_set[i], {}, Auth(self.node.creator), save=True ) self.node.add_contributor(self.user, permissions=[osf_permissions.READ], auth=Auth(self.node.creator), log=False, save=True) self.node_log_url = '/{}nodes/{}/logs/'.format(API_BASE, self.node._id) self.url = '/{}logs/'.format(API_BASE) self.public_node = ProjectFactory(is_public=True) for i in range(len(self.action_set)): self.public_node.add_log( self.action_set[i], {}, Auth(self.public_node.creator), save=True ) def tearDown(self): NodeLog.remove() Node.remove()
def test__initiate_retraction_adds_admins_on_child_nodes(self): project_admin = UserFactory() project_non_admin = UserFactory() child_admin = UserFactory() child_non_admin = UserFactory() grandchild_admin = UserFactory() project = ProjectFactory(creator=project_admin) project.add_contributor(project_non_admin, auth=Auth(project.creator), save=True) child = NodeFactory(creator=child_admin, parent=project) child.add_contributor(child_non_admin, auth=Auth(project.creator), save=True) grandchild = NodeFactory(creator=grandchild_admin, parent=child) # noqa registration = RegistrationFactory(project=project) retraction = registration._initiate_retraction(registration.creator) assert_in(project_admin._id, retraction.approval_state) assert_in(child_admin._id, retraction.approval_state) assert_in(grandchild_admin._id, retraction.approval_state) assert_not_in(project_non_admin._id, retraction.approval_state) assert_not_in(child_non_admin._id, retraction.approval_state)
def test_node_citation_view(self): node = ProjectFactory() user = AuthUserFactory() node.add_contributor(user) node.save() response = self.app.get("/api/v1" + "/project/" + node._id + "/citation/", auto_follow=True, auth=user.auth) assert_true(response.json)
class TestViewsAuth(OsfTestCase): def setUp(self): super(TestViewsAuth, self).setUp() self.user = AuthUserFactory() self.consolidated_auth = Auth(user=self.user) self.auth = ('test', self.user.api_keys[0]._primary_key) self.project = ProjectFactory(creator=self.user) self.non_authenticator = AuthUserFactory() self.project.add_contributor( contributor=self.non_authenticator, auth=Auth(self.project.creator), ) self.project.add_addon('figshare', auth=self.consolidated_auth) self.project.creator.add_addon('figshare') self.node_settings = self.project.get_addon('figshare') self.user_settings = self.project.creator.get_addon('figshare') self.node_settings.user_settings = self.user_settings self.node_settings.figshare_id = '436' self.node_settings.figshare_type = 'project' self.node_settings.save() @unittest.skip('finish this') def test_oauth_fail(self): url = '/api/v1/project/{0}/figshare/oauth/'.format(self.project._id) self.app.get(url, auth=self.user.auth) @unittest.skip('finish this') def test_oauth_bad_token(self): pass
def test_sees_log_events_on_watched_projects(self): # Another user has a public project u2 = UserFactory(username='******', fullname='Bono') key = ApiKeyFactory() u2.api_keys.append(key) u2.save() project = ProjectFactory(creator=u2, is_public=True) project.add_contributor(u2) auth = Auth(user=u2, api_key=key) # A file was added to the project project.add_file(auth=auth, file_name='test.html', content='123', size=2, content_type='text/html') project.save() # User watches the project watch_config = WatchConfigFactory(node=project) self.user.watch(watch_config) self.user.save() # Goes to her dashboard, already logged in res = self.app.get('/dashboard/', auth=self.auth, auto_follow=True) # Sees logs for the watched project assert_in('Watched Projects', res) # Watched Projects header # The log action is in the feed assert_in('added file test.html', res) assert_in(project.title, res)
class LogsTestCase(ApiTestCase): def setUp(self): super(LogsTestCase, self).setUp() self.user = AuthUserFactory() self.user_two = AuthUserFactory() self.action_set = NodeLog.actions self.node = ProjectFactory(is_public=False) self.node.add_contributor(self.user, permissions=[osf_permissions.READ], auth=Auth(self.node.creator), log=True, save=True) self.log = self.node.logs[0] self.log_add_contributor = self.node.logs[1] self.public_node = ProjectFactory(is_public=True) self.public_node.add_contributor(self.user, permissions=[osf_permissions.READ], auth=Auth(self.node.creator), log=True, save=True) self.public_log = self.public_node.logs[0] self.public_log_add_contributor = self.public_node.logs[1] self.node_log_url = '/{}nodes/{}/logs/'.format(API_BASE, self.node._id) self.url = '/{}logs/'.format(API_BASE) self.log_nodes_url = self.url + '{}/nodes/'.format(self.log._id) self.private_log_detail = self.url + '{}/'.format(self.log._id) self.log_public_nodes_url = self.url + '{}/nodes/'.format(self.public_log._id) self.public_log_detail = self.url + '{}/'.format(self.public_log._id) self.private_log_contribs_url = self.url + '{}/contributors/'.format(self.log_add_contributor._id) self.public_log_contribs_url = self.url + '{}/contributors/'.format(self.public_log_add_contributor._id) def tearDown(self): NodeLog.remove() Node.remove()
def test_sees_projects_in_her_dashboard(self): # the user already has a project project = ProjectFactory(creator=self.user) project.add_contributor(self.user) project.save() res = self.app.get('/myprojects/', auth=self.user.auth) assert_in('Projects', res) # Projects heading
def test_cant_see_make_private_button_if_not_admin(self): # User is a contributor on a project project = ProjectFactory(is_public=True) project.add_contributor(self.user, permissions=["read", "write"], save=True) # User goes to the project page res = self.app.get(project.url, auth=self.auth).maybe_follow() assert_not_in("Make Private", res)
def test_migrate_contributors(self): creator = UserFactory(is_registered=True) project = ProjectFactory(creator=creator) auth = Auth(project.creator) contrib1 = UserFactory() project.add_contributor(contrib1, auth=auth) project.save() # sanity checks assert len(project.contributor_list) == 2 nr_contrib = DeprecatedUnregUserFactory() project.contributor_list.append(nr_contrib) project.save() assert len(project.contributors) == 2 assert len(project.contributor_list) == 3 old_length = len(project.contributor_list) migrate_contributors(project) project.save() assert len(project.contributor_list) == old_length assert len(project.contributors) == old_length migrated_user = project.contributors[-1] assert migrated_user.fullname == nr_contrib['nr_name'] assert migrated_user.is_registered is False # has an unclaimed record assert project._primary_key in migrated_user.unclaimed_records rec = migrated_user.get_unclaimed_record(project._primary_key) assert rec['name'] == nr_contrib['nr_name'] assert rec['referrer_id'] == creator._primary_key assert rec['token'] assert rec['email'] == nr_contrib['nr_email']
def test_get_most_in_common_contributors(self): # project 1 (contrib 1, contrib 2, unreg_contrib 3) # - component 1 (contrib 1) # project 2 - add should show contrib 1 first (2 links), contrib 2 second (1 link) contributor_1 = AuthUserFactory() contributor_2 = AuthUserFactory() self.project.add_contributor(contributor_1, auth=self.auth) self.project.add_contributor(contributor_2, auth=self.auth) # has one unregistered contributor self.project.add_unregistered_contributor( fullname=fake.name(), email=fake.email(), auth=self.auth, ) self.project.save() component = NodeFactory(parent=self.project, creator=self.user) component.add_contributor(contributor_1, auth=self.auth) component.save() project_2 = ProjectFactory(creator=self.user) project_2.add_contributor(contributor_1, auth=self.auth) url = project_2.api_url_for('get_most_in_common_contributors') res = self.app.get(url, auth=self.user.auth) project_2.reload() res_contribs = res.json['contributors'] assert_equal(len(res.json['contributors']), 2) assert_equal(contributor_1._id, res_contribs[0]['id']) assert_equal(res_contribs[0]['n_projects_in_common'], 2) assert_equal(contributor_2._id, res_contribs[1]['id']) assert_equal(res_contribs[1]['n_projects_in_common'], 1)
def test_do_migration(self): user1 = UserFactory() fullname1 = 'Presentation Service' email1 = '*****@*****.**' project1 = ProjectFactory(creator=user1) user2 = project1.add_unregistered_contributor( fullname=fullname1, email=email1, auth=Auth(user=user1) ) project1.save() user3 = UserFactory.build(username='******', fullname=fullname1) user3.save() project2 = ProjectFactory(creator=user1) project2.add_contributor(user3) project2.save() assert project1.is_contributor(user2) is True assert len(project1.contributors) is 2 assert project2.is_contributor(user3) is True assert len(project2.contributors) is 2 user_list = get_targets() do_migration(user_list) assert project2.is_contributor(user3) is False assert len(project2.contributors) is 1 assert project1.is_contributor(user2) is False assert len(project1.contributors) is 1 assert user2.is_disabled is True assert user3.is_disabled is True
def create_fake_project(creator, n_users, privacy, n_components, name, n_tags, presentation_name, is_registration): auth = Auth(user=creator) project_title = name if name else fake.science_sentence() if not is_registration: project = ProjectFactory(title=project_title, description=fake.science_paragraph(), creator=creator) else: project = RegistrationFactory(title=project_title, description=fake.science_paragraph(), creator=creator) project.set_privacy(privacy) for _ in range(n_users): contrib = create_fake_user() project.add_contributor(contrib, auth=auth) if isinstance(n_components, int): for _ in range(n_components): NodeFactory(project=project, title=fake.science_sentence(), description=fake.science_paragraph(), creator=creator) elif isinstance(n_components, list): render_generations_from_node_structure_list(project, creator, n_components) for _ in range(n_tags): project.add_tag(fake.science_word(), auth=auth) if presentation_name is not None: project.add_tag(presentation_name, auth=auth) project.add_tag('poster', auth=auth) project.save() logger.info('Created project: {0}'.format(project.title)) return project
class TestMustBeContributorDecorator(AuthAppTestCase): def setUp(self): super(TestMustBeContributorDecorator, self).setUp() self.contrib = AuthUserFactory() self.project = ProjectFactory() self.project.add_contributor(self.contrib, auth=Auth(self.project.creator)) self.project.save() def test_must_be_contributor_when_user_is_contributor(self): result = view_that_needs_contributor( pid=self.project._primary_key, api_key=self.contrib.auth[1], api_node=self.project, user=self.contrib) assert_equal(result, self.project) def test_must_be_contributor_when_user_is_not_contributor_raises_error(self): non_contributor = AuthUserFactory() with assert_raises(HTTPError): view_that_needs_contributor( pid=self.project._primary_key, api_key=non_contributor.auth[1], api_node=non_contributor.auth[1], user=non_contributor ) def test_must_be_contributor_no_user(self): res = view_that_needs_contributor( pid=self.project._primary_key, user=None, api_key='123', api_node='abc', ) assert_is_redirect(res) redirect_url = res.headers['Location'] assert_equal(redirect_url, '/login/?next=/') def test_must_be_contributor_parent_admin(self): user = UserFactory() node = NodeFactory(parent=self.project, creator=user) res = view_that_needs_contributor( pid=self.project._id, nid=node._id, user=self.project.creator, ) assert_equal(res, node) def test_must_be_contributor_parent_write(self): user = UserFactory() node = NodeFactory(parent=self.project, creator=user) self.project.set_permissions(self.project.creator, ['read', 'write']) self.project.save() with assert_raises(HTTPError) as exc_info: view_that_needs_contributor( pid=self.project._id, nid=node._id, user=self.project.creator, ) assert_equal(exc_info.exception.code, 403)
def test__initiate_embargo_adds_admins_on_child_nodes(self): project_admin = UserFactory() project_non_admin = UserFactory() child_admin = UserFactory() child_non_admin = UserFactory() grandchild_admin = UserFactory() project = ProjectFactory(creator=project_admin) project.add_contributor(project_non_admin, auth=Auth(project.creator), save=True) child = NodeFactory(creator=child_admin, parent=project) child.add_contributor(child_non_admin, auth=Auth(project.creator), save=True) grandchild = NodeFactory(creator=grandchild_admin, parent=child) # noqa embargo = project._initiate_embargo( project.creator, self.valid_embargo_end_date, for_existing_registration=True ) assert_in(project_admin._id, embargo.approval_state) assert_in(child_admin._id, embargo.approval_state) assert_in(grandchild_admin._id, embargo.approval_state) assert_not_in(project_non_admin._id, embargo.approval_state) assert_not_in(child_non_admin._id, embargo.approval_state)
def test_migrate_project_contributed(self): user1 = UserFactory() fullname1 = 'hello world' email1 = '*****@*****.**' project1 = ProjectFactory(creator=user1) user2 = project1.add_unregistered_contributor( fullname=fullname1, email=email1, auth=Auth(user=user1) ) project1.save() assert project1.is_contributor(user2) is True assert len(project1.contributors) is 2 migrate_project_contributed(user2) assert project1.is_contributor(user2) is False assert len(project1.contributors) is 1 user3 = UserFactory() project2 = ProjectFactory(creator=user1) project2.add_contributor(user3) project2.save() assert project2.is_contributor(user3) is True assert len(project2.contributors) is 2 migrate_project_contributed(user3) assert project2.is_contributor(user3) is False assert len(project2.contributors) is 1
class DraftRegistrationTestCase(ApiTestCase): def setUp(self): super(DraftRegistrationTestCase, self).setUp() self.user = AuthUserFactory() self.read_only_user = AuthUserFactory() self.read_write_user = AuthUserFactory() self.non_contributor = AuthUserFactory() self.public_project = ProjectFactory(is_public=True, creator=self.user) self.public_project.add_contributor(self.read_only_user, permissions=[permissions.READ]) self.public_project.add_contributor(self.read_write_user, permissions=[permissions.WRITE]) self.public_project.save() def prereg_metadata(self, draft): test_metadata = {} json_schema = create_jsonschema_from_metaschema( draft.registration_schema.schema) for key, value in json_schema['properties'].iteritems(): response = 'Test response' if value['properties']['value'].get('enum'): response = value['properties']['value']['enum'][0] if value['properties']['value'].get('properties'): response = {'question': {'value': 'Test Response'}} test_metadata[key] = {'value': response} return test_metadata
class LogsTestCase(ApiTestCase): def setUp(self): super(LogsTestCase, self).setUp() self.user = AuthUserFactory() self.user_two = AuthUserFactory() self.action_set = NodeLog.actions self.node = ProjectFactory(is_public=False) self.node.add_contributor(self.user, permissions=[osf_permissions.READ], auth=Auth(self.node.creator), log=True, save=True) self.log = self.node.logs[0] self.log_add_contributor = self.node.logs[1] self.public_node = ProjectFactory(is_public=True) self.public_node.add_contributor(self.user, permissions=[osf_permissions.READ], auth=Auth(self.node.creator), log=True, save=True) self.public_log = self.public_node.logs[0] self.public_log_add_contributor = self.public_node.logs[1] self.node_log_url = '/{}nodes/{}/logs/'.format(API_BASE, self.node._id) self.url = '/{}logs/'.format(API_BASE) self.log_nodes_url = self.url + '{}/nodes/'.format(self.log._id) self.private_log_detail = self.url + '{}/'.format(self.log._id) self.log_public_nodes_url = self.url + '{}/nodes/'.format(self.public_log._id) self.public_log_detail = self.url + '{}/'.format(self.public_log._id) def tearDown(self): NodeLog.remove() Node.remove()
class TestMustBeContributorDecorator(AuthAppTestCase): def setUp(self): super(TestMustBeContributorDecorator, self).setUp() self.contrib = AuthUserFactory() self.project = ProjectFactory() self.project.add_contributor(self.contrib, auth=Auth(self.project.creator)) self.project.save() def test_must_be_contributor_when_user_is_contributor(self): result = view_that_needs_contributor(pid=self.project._primary_key, api_key=self.contrib.auth[1], api_node=self.project, user=self.contrib) assert_equal(result, self.project) def test_must_be_contributor_when_user_is_not_contributor_raises_error( self): non_contributor = AuthUserFactory() with assert_raises(HTTPError): view_that_needs_contributor(pid=self.project._primary_key, api_key=non_contributor.auth[1], api_node=non_contributor.auth[1], user=non_contributor) def test_must_be_contributor_no_user(self): res = view_that_needs_contributor( pid=self.project._primary_key, user=None, api_key='123', api_node='abc', ) assert_is_redirect(res) # redirects to login url redirect_url = res.headers['Location'] login_url = cas.get_login_url(service_url='http://localhost/') assert_equal(redirect_url, login_url) def test_must_be_contributor_parent_admin(self): user = UserFactory() node = NodeFactory(parent=self.project, creator=user) res = view_that_needs_contributor( pid=self.project._id, nid=node._id, user=self.project.creator, ) assert_equal(res, node) def test_must_be_contributor_parent_write(self): user = UserFactory() node = NodeFactory(parent=self.project, creator=user) self.project.set_permissions(self.project.creator, ['read', 'write']) self.project.save() with assert_raises(HTTPError) as exc_info: view_that_needs_contributor( pid=self.project._id, nid=node._id, user=self.project.creator, ) assert_equal(exc_info.exception.code, 403)
class DraftRegistrationTestCase(ApiTestCase): def setUp(self): super(DraftRegistrationTestCase, self).setUp() self.user = AuthUserFactory() self.read_only_user = AuthUserFactory() self.read_write_user = AuthUserFactory() self.non_contributor = AuthUserFactory() self.public_project = ProjectFactory(is_public=True, creator=self.user) self.public_project.add_contributor(self.read_only_user, permissions=[permissions.READ]) self.public_project.add_contributor(self.read_write_user, permissions=[permissions.WRITE]) self.public_project.save() def prereg_metadata(self, draft): test_metadata = {} json_schema = create_jsonschema_from_metaschema(draft.registration_schema.schema) for key, value in json_schema["properties"].iteritems(): response = "Test response" if value["properties"]["value"].get("enum"): response = value["properties"]["value"]["enum"][0] if value["properties"]["value"].get("properties"): response = {"question": {"value": "Test Response"}} test_metadata[key] = {"value": response} return test_metadata
def test_sees_osffiles_in_project_addon_settings(self): project = ProjectFactory(creator=self.user) project.add_contributor( self.user, permissions=['read', 'write', 'admin'], save=True) res = self.app.get('/{0}/settings/'.format(project._primary_key), auth=self.auth, auto_follow=True) assert_in('OSF Storage', res)
def test_find_unread_new_comments(self): project = ProjectFactory() user = UserFactory() project.add_contributor(user) project.save() comment = CommentFactory(node=project, user=project.creator) n_unread = Comment.find_n_unread(user=user, node=project) assert_equal(n_unread, 1)
def test_read_permission_contributor_can_comment(self): project = ProjectFactory() user = UserFactory() project.set_privacy('private') project.add_contributor(user, permissions=[permissions.READ]) project.save() assert_true(project.can_comment(Auth(user=user)))
def test_find_unread_does_not_include_deleted_comments(self): project = ProjectFactory() user = AuthUserFactory() project.add_contributor(user) project.save() comment = CommentFactory(node=project, user=project.creator, is_deleted=True) n_unread = Comment.find_n_unread(user=user, node=project, page='node') assert_equal(n_unread, 0)
def test_find_unread_does_not_include_deleted_comments(self): project = ProjectFactory() user = AuthUserFactory() project.add_contributor(user) project.save() comment = CommentFactory(node=project, user=project.creator, is_deleted=True) n_unread = Comment.find_n_unread(user=user, node=project) assert_equal(n_unread, 0)
class RegistrationsTestBase(OsfTestCase): def setUp(self): super(RegistrationsTestBase, self).setUp() self.user = AuthUserFactory() self.auth = Auth(self.user) self.node = ProjectFactory(creator=self.user) self.non_admin = AuthUserFactory() self.node.add_contributor( self.non_admin, permissions.DEFAULT_CONTRIBUTOR_PERMISSIONS, auth=self.auth, save=True ) self.non_contrib = AuthUserFactory() MetaSchema.remove() ensure_schemas() self.meta_schema = MetaSchema.find_one( Q('name', 'eq', 'Open-Ended Registration') & Q('schema_version', 'eq', 2) ) self.draft = DraftRegistrationFactory( initiator=self.user, branched_from=self.node, registration_schema=self.meta_schema, registration_metadata={ 'summary': {'value': 'Some airy'} } ) current_month = dt.datetime.now().strftime("%B") current_year = dt.datetime.now().strftime("%Y") valid_date = dt.datetime.now() + dt.timedelta(days=180) self.embargo_payload = { u'embargoEndDate': unicode(valid_date.strftime('%a, %d, %B %Y %H:%M:%S')) + u' GMT', u'registrationChoice': 'embargo' } self.invalid_embargo_date_payload = { u'embargoEndDate': u"Thu, 01 {month} {year} 05:00:00 GMT".format( month=current_month, year=str(int(current_year) - 1) ), u'registrationChoice': 'embargo' } self.immediate_payload = { 'registrationChoice': 'immediate' } self.invalid_payload = { 'registrationChoice': 'foobar' } def draft_url(self, view_name): return self.node.web_url_for(view_name, draft_id=self.draft._id) def draft_api_url(self, view_name): return self.node.api_url_for(view_name, draft_id=self.draft._id)
class TestNodeFileLogDetail(ApiTestCase): def setUp(self): super(TestNodeFileLogDetail, self).setUp() self.user_one = AuthUserFactory() self.user_two = AuthUserFactory() self.node = ProjectFactory(creator=self.user_one) self.node.add_contributor(self.user_two) self.component = NodeFactory(parent=self.node, creator=self.user_one) self.file = api_utils.create_test_file(node=self.component, user=self.user_one) self.node.add_log( 'osf_storage_file_moved', auth=Auth(self.user_one), params={ 'node': self.node._id, 'project': self.node.parent_id, 'path': self.file.materialized_path, 'source': { 'materialized': self.file.materialized_path, 'addon': 'osfstorage', 'node': { '_id': self.component._id, 'url': self.component.url, 'title': self.component.title, } }, 'destination': { 'materialized': self.file.materialized_path, 'addon': 'osfstorage', 'node': { '_id': self.node._id, 'url': self.node.url, 'title': self.node.title, } } }, ) self.node.save() self.node_logs_url = '/{}nodes/{}/logs/'.format(API_BASE, self.node._id) self.component_logs_url = '/{}nodes/{}/logs/'.format(API_BASE, self.component._id) def test_title_not_hidden_from_contributor_in_file_move(self): res = self.app.get(self.node_logs_url, auth=self.user_two.auth) assert_equal(res.status_code, 200) assert_equal(res.json['data'][0]['attributes']['params']['destination']['node_title'], self.node.title) def test_title_hidden_from_non_contributor_in_file_move(self): res = self.app.get(self.node_logs_url, auth=self.user_two.auth) assert_equal(res.status_code, 200) assert_not_in(self.component.title, res.json['data']) assert_equal(res.json['data'][0]['attributes']['params']['source']['node_title'], 'Private Component')
class TestRemoveContributor(AdminTestCase): def setUp(self): super(TestRemoveContributor, self).setUp() self.user = AuthUserFactory() self.node = ProjectFactory(creator=self.user) self.user_2 = AuthUserFactory() self.node.add_contributor(self.user_2) self.node.save() self.view = NodeRemoveContributorView() self.request = RequestFactory().post('/fake_path') def test_get_object(self): view = setup_log_view(self.view, self.request, node_id=self.node._id, user_id=self.user._id) node, user = view.get_object() nt.assert_is_instance(node, Node) nt.assert_is_instance(user, User) @mock.patch('admin.nodes.views.Node.remove_contributor') def test_remove_contributor(self, mock_remove_contributor): user_id = self.user_2._id node_id = self.node._id view = setup_log_view(self.view, self.request, node_id=node_id, user_id=user_id) view.delete(self.request) mock_remove_contributor.assert_called_with(self.user_2, None, log=False) def test_integration_remove_contributor(self): nt.assert_in(self.user_2, self.node.contributors) view = setup_log_view(self.view, self.request, node_id=self.node._id, user_id=self.user_2._id) count = OSFLogEntry.objects.count() view.delete(self.request) nt.assert_not_in(self.user_2, self.node.contributors) nt.assert_equal(OSFLogEntry.objects.count(), count + 1) def test_do_not_remove_last_admin(self): nt.assert_equal( len(list(self.node.get_admin_contributors(self.node.contributors))), 1 ) view = setup_log_view(self.view, self.request, node_id=self.node._id, user_id=self.user._id) count = OSFLogEntry.objects.count() view.delete(self.request) self.node.reload() # Reloads instance to show that nothing was removed nt.assert_equal(len(list(self.node.contributors)), 2) nt.assert_equal( len(list(self.node.get_admin_contributors(self.node.contributors))), 1 ) nt.assert_equal(OSFLogEntry.objects.count(), count) def test_no_log(self): view = setup_log_view(self.view, self.request, node_id=self.node._id, user_id=self.user_2._id) view.delete(self.request) nt.assert_not_equal(self.node.logs[-1].action, NodeLog.CONTRIB_REMOVED)
def test_find_unread_includes_comment_replies(self): project = ProjectFactory() user = UserFactory() project.add_contributor(user) project.save() comment = CommentFactory(node=project, user=user) reply = CommentFactory(node=project, target=Guid.load(comment._id), user=project.creator) n_unread = Comment.find_n_unread(user=user, node=project, page='node') assert_equal(n_unread, 1)
def test_get_recently_added_contributors_with_limit(self): project = ProjectFactory(creator=self.user) for _ in range(5): project.add_contributor(AuthUserFactory(), auth=self.auth) project.save() url = self.project.api_url_for('get_recently_added_contributors', max=4) res = self.app.get(url, auth=self.user.auth) project.reload() assert_equal(len(res.json['contributors']), 4)
def test_find_unread_includes_comment_replies(self): project = ProjectFactory() user = UserFactory() project.add_contributor(user) project.save() comment = CommentFactory(node=project, user=user) reply = CommentFactory(node=project, target=comment, user=project.creator) n_unread = Comment.find_n_unread(user=user, node=project) assert_equal(n_unread, 1)
def test_cant_see_make_private_button_if_not_admin(self): # User is a contributor on a project project = ProjectFactory(is_public=True) project.add_contributor(self.user, permissions=['read', 'write'], save=True) # User goes to the project page res = self.app.get(project.url, auth=self.auth).maybe_follow() assert_not_in('Make Private', res)
class TestCommentViews(OsfTestCase): def setUp(self): super(TestCommentViews, self).setUp() self.project = ProjectFactory(is_public=True) self.user = AuthUserFactory() self.project.add_contributor(self.user) self.project.save() self.user.save() def test_view_project_comments_updates_user_comments_view_timestamp(self): url = self.project.api_url_for('update_comments_timestamp') res = self.app.put_json(url, { 'page': 'node', 'rootId': self.project._id }, auth=self.user.auth) self.user.reload() user_timestamp = self.user.comments_viewed_timestamp[self.project._id]['node'] view_timestamp = dt.datetime.utcnow() assert_datetime_equal(user_timestamp, view_timestamp) def test_confirm_non_contrib_viewers_dont_have_pid_in_comments_view_timestamp(self): non_contributor = AuthUserFactory() url = self.project.api_url_for('update_comments_timestamp') res = self.app.put_json(url, { 'page': 'node', 'rootId': self.project._id }, auth=self.user.auth) non_contributor.reload() assert_not_in(self.project._id, non_contributor.comments_viewed_timestamp) def test_view_comments_updates_user_comments_view_timestamp_files(self): osfstorage = self.project.get_addon('osfstorage') root_node = osfstorage.get_root() test_file = root_node.append_file('test_file') test_file.create_version(self.user, { 'object': '06d80e', 'service': 'cloud', osfstorage_settings.WATERBUTLER_RESOURCE: 'osf', }, { 'size': 1337, 'contentType': 'img/png' }).save() url = self.project.api_url_for('update_comments_timestamp') res = self.app.put_json(url, { 'page': 'files', 'rootId': test_file._id }, auth=self.user.auth) self.user.reload() user_timestamp = self.user.comments_viewed_timestamp[self.project._id]['files'][test_file._id] view_timestamp = dt.datetime.utcnow() assert_datetime_equal(user_timestamp, view_timestamp)
class TestCommentViews(OsfTestCase): def setUp(self): super(TestCommentViews, self).setUp() self.project = ProjectFactory(is_public=True) self.user = AuthUserFactory() self.project.add_contributor(self.user) self.project.save() self.user.save() def test_view_project_comments_updates_user_comments_view_timestamp(self): url = self.project.api_url_for('update_comments_timestamp') res = self.app.put_json(url, { 'page': 'node', 'rootId': self.project._id }, auth=self.user.auth) self.user.reload() user_timestamp = self.user.comments_viewed_timestamp[self.project._id] view_timestamp = dt.datetime.utcnow() assert_datetime_equal(user_timestamp, view_timestamp) def test_confirm_non_contrib_viewers_dont_have_pid_in_comments_view_timestamp(self): non_contributor = AuthUserFactory() url = self.project.api_url_for('update_comments_timestamp') res = self.app.put_json(url, { 'page': 'node', 'rootId': self.project._id }, auth=self.user.auth) non_contributor.reload() assert_not_in(self.project._id, non_contributor.comments_viewed_timestamp) def test_view_comments_updates_user_comments_view_timestamp_files(self): osfstorage = self.project.get_addon('osfstorage') root_node = osfstorage.get_root() test_file = root_node.append_file('test_file') test_file.create_version(self.user, { 'object': '06d80e', 'service': 'cloud', osfstorage_settings.WATERBUTLER_RESOURCE: 'osf', }, { 'size': 1337, 'contentType': 'img/png' }).save() url = self.project.api_url_for('update_comments_timestamp') res = self.app.put_json(url, { 'page': 'files', 'rootId': test_file._id }, auth=self.user.auth) self.user.reload() user_timestamp = self.user.comments_viewed_timestamp[test_file._id] view_timestamp = dt.datetime.utcnow() assert_datetime_equal(user_timestamp, view_timestamp)
def test_sees_projects_in_her_dashboard(self): # the user already has a project project = ProjectFactory(creator=self.user) project.add_contributor(self.user) project.save() # Goes to homepage, already logged in res = self.app.get("/", auth=self.user.auth).follow(auth=self.user.auth) # Clicks Dashboard link in navbar res = res.click("My Dashboard", index=0, auth=self.user.auth) assert_in("Projects", res) # Projects heading
def test_sees_projects_in_her_dashboard(self): # the user already has a project project = ProjectFactory(creator=self.user) project.add_contributor(self.user) project.save() # Goes to homepage, already logged in res = self.app.get('/', auth=self.user.auth).follow(auth=self.user.auth) # Clicks Dashboard link in navbar res = res.click('My Dashboard', index=0, auth=self.user.auth) assert_in('Projects', res) # Projects heading
def test_cant_see_make_public_button_if_not_admin(self): # User is a contributor on a project project = ProjectFactory() project.add_contributor( self.user, permissions=['read', 'write'], save=True) # User goes to the project page res = self.app.get(project.url, auth=self.auth).maybe_follow() assert_not_in('Make Public', res)
def test_sees_projects_in_her_dashboard(self): # the user already has a project project = ProjectFactory(creator=self.user) project.add_contributor(self.user) project.save() # Goes to homepage, already logged in res = self._login(self.user.username, 'science') res = self.app.get('/').maybe_follow() # Clicks Dashboard link in navbar res = res.click('Dashboard', index=0) assert_in('Projects', res) # Projects heading
class TestUserSpamListView(AdminTestCase): def setUp(self): super(TestUserSpamListView, self).setUp() self.project = ProjectFactory(is_public=True) self.user_1 = AuthUserFactory() self.user_2 = AuthUserFactory() self.project.add_contributor(self.user_1) self.project.add_contributor(self.user_2) self.project.save() self.user_1.save() self.user_2.save() self.comment_1 = CommentFactory(node=self.project, user=self.user_1) self.comment_2 = CommentFactory(node=self.project, user=self.user_1) self.comment_3 = CommentFactory(node=self.project, user=self.user_1) self.comment_4 = CommentFactory(node=self.project, user=self.user_1) self.comment_5 = CommentFactory(node=self.project, user=self.user_2) self.comment_6 = CommentFactory(node=self.project, user=self.user_2) self.comment_1.report_abuse(user=self.user_2, save=True, category='spam') self.comment_2.report_abuse(user=self.user_2, save=True, category='spam') self.comment_3.report_abuse(user=self.user_2, save=True, category='spam') self.comment_4.report_abuse(user=self.user_2, save=True, category='spam') self.comment_5.report_abuse(user=self.user_1, save=True, category='spam') self.comment_6.report_abuse(user=self.user_1, save=True, category='spam') self.request = RequestFactory().get('/fake_path') self.view = UserSpamList() self.view = setup_view(self.view, self.request, user_id=self.user_1._id) def test_get_user_spam(self): res = list(self.view.get_queryset()) nt.assert_equal(len(res), 4) def test_get_context_data(self): self.view.object_list = self.view.get_queryset() res = self.view.get_context_data() nt.assert_is_instance(res['spam'], list) nt.assert_is_instance(res['spam'][0], dict) nt.assert_equal(res['status'], '1') nt.assert_equal(res['page_number'], 1) nt.assert_equal(res['user_id'], self.user_1._id)
def create_project(creator, public=True, contrib=None, citation=False, registration=False): project = ProjectFactory(creator=creator, is_public=public) if contrib: project.add_contributor(contrib, permissions=[permissions.READ, permissions.WRITE], visible=True) if citation: citation = AlternativeCitationFactory(name='name', text='text') project.alternative_citations.append(citation) project.save() if registration: registration = RegistrationFactory(project=project, is_public=public) return registration return project
class TestPiwik(OsfTestCase): def setUp(self): super(TestPiwik, self).setUp() self.users = [ AuthUserFactory() for _ in range(3) ] self.consolidate_auth = Auth(user=self.users[0]) self.project = ProjectFactory(creator=self.users[0], is_public=True) self.project.add_contributor(contributor=self.users[1]) self.project.save() def test_contains_iframe_and_src(self): res = self.app.get( '/{0}/statistics/'.format(self.project._primary_key), auth=self.users[0].auth ).maybe_follow() assert_in('iframe', res) assert_in('src', res) assert_in(settings.PIWIK_HOST, res) def test_anonymous_no_token(self): res = self.app.get( '/{0}/statistics/'.format(self.project._primary_key), auth=self.users[2].auth ).maybe_follow() assert_in('token_auth=anonymous', res) def test_contributor_token(self): res = self.app.get( '/{0}/statistics/'.format(self.project._primary_key), auth=self.users[1].auth ).maybe_follow() assert_in(self.users[1].piwik_token, res) def test_no_user_token(self): res = self.app.get( '/{0}/statistics/'.format(self.project._primary_key) ).maybe_follow() assert_in('token_auth=anonymous', res) def test_private_alert(self): self.project.set_privacy('private', auth=self.consolidate_auth) self.project.save() res = self.app.get( '/{0}/statistics/'.format(self.project._primary_key), auth=self.users[0].auth ).maybe_follow().normal_body assert_in( 'Usage statistics are collected only for public resources.', res )