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
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)
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()
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__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_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
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_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_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_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_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)
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)))
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_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_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_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)
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
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
)
