def setUp(self):
super(TestExplorePublicActivity, self).setUp()
self.project = ProjectFactory(is_public=True)
self.registration = RegistrationFactory(project=self.project)
self.private_project = ProjectFactory(title="Test private project")
self.popular_project = ProjectFactory(is_public=True)
self.popular_registration = RegistrationFactory(project=self.project)
# Add project to new and noteworthy projects
self.new_and_noteworthy_links_node = ProjectFactory()
self.new_and_noteworthy_links_node._id = settings.NEW_AND_NOTEWORTHY_LINKS_NODE
self.new_and_noteworthy_links_node.add_pointer(
self.project,
auth=Auth(self.new_and_noteworthy_links_node.creator),
save=True)
# Set up popular projects and registrations
self.popular_links_node = ProjectFactory()
self.popular_links_node._id = settings.POPULAR_LINKS_NODE
self.popular_links_node.add_pointer(
self.popular_project,
auth=Auth(self.popular_links_node.creator),
save=True)
self.popular_links_registrations = ProjectFactory()
self.popular_links_registrations._id = settings.POPULAR_LINKS_REGISTRATIONS
self.popular_links_registrations.add_pointer(
self.popular_registration,
auth=Auth(self.popular_links_registrations.creator),
save=True)
def setUp(self):
super(TestNodeRelationshipNodeLinks, self).setUp()
self.user = AuthUserFactory()
self.user2 = AuthUserFactory()
self.auth = Auth(self.user)
self.linking_node_source = NodeFactory(creator=self.user)
self.admin_node = NodeFactory(creator=self.user)
self.contributor_node = NodeFactory(creator=self.user2)
self.contributor_node.add_contributor(self.user, auth=Auth(self.user2))
self.contributor_node.save()
self.other_node = NodeFactory()
self.private_node = NodeFactory(creator=self.user)
self.public_node = NodeFactory(is_public=True)
self.linking_node_source.add_pointer(self.private_node, auth=self.auth)
self.linking_node_source.add_pointer(self.admin_node, auth=self.auth)
self.public_linking_node_source = NodeFactory(is_public=True,
creator=self.user2)
self.public_linking_node_source.add_pointer(self.private_node,
auth=Auth(self.user2))
self.public_linking_node_source.add_pointer(self.public_node,
auth=Auth(self.user2))
self.public_linking_node = RegistrationFactory(
project=self.public_linking_node_source,
is_public=True,
creator=self.user2)
self.linking_node = RegistrationFactory(
project=self.linking_node_source, creator=self.user)
self.url = '/{}registrations/{}/relationships/linked_nodes/'.format(
API_BASE, self.linking_node._id)
self.public_url = '/{}registrations/{}/relationships/linked_nodes/'.format(
API_BASE, self.public_linking_node._id)
def setUp(self):
super(TestPopulateNewAndNoteworthy, self).setUp()
self.pop1 = ProjectFactory(is_public=True)
self.pop2 = ProjectFactory(is_public=True)
self.popreg1 = RegistrationFactory(is_public=True)
self.popreg2 = RegistrationFactory(is_public=True)
def setUp(self):
super(TestRegistrationEmbeds, self).setUp()
self.user = AuthUserFactory()
self.auth = Auth(self.user)
make_public_node = functools.partial(ProjectFactory,
is_public=False,
creator=self.user)
self.root_node = make_public_node()
self.child1 = make_public_node(parent=self.root_node)
self.child2 = make_public_node(parent=self.root_node)
self.contribs = [AuthUserFactory() for i in range(2)]
for contrib in self.contribs:
self.root_node.add_contributor(contrib, ['read', 'write'],
auth=self.auth,
save=True)
self.child1.add_contributor(contrib, ['read', 'write'],
auth=self.auth,
save=True)
self.contrib1 = self.contribs[0]
self.contrib2 = self.contribs[1]
self.subchild = ProjectFactory(parent=self.child2,
creator=self.contrib1)
self.registration = RegistrationFactory(project=self.root_node,
is_public=True)
self.registration_child = RegistrationFactory(project=self.child1,
is_public=True)
def setUp(self):
super(TestRegistrationForkCreate, self).setUp()
self.user = AuthUserFactory()
self.user_two = AuthUserFactory()
self.user_three = AuthUserFactory()
self.private_project = ProjectFactory(creator=self.user)
private_pointer = ProjectFactory(creator=self.user_two)
actual_pointer = self.private_project.add_pointer(private_pointer, auth=Auth(self.user_two), save=True)
self.private_registration = RegistrationFactory(creator=self.user, project=self.private_project)
self.fork_data = {
'data': {
'type': 'nodes'
}
}
self.fork_data_with_title = {
'data': {
'type': 'nodes',
'attributes':
{'title': 'My Forked Project'}
}
}
self.private_registration_url = '/{}registrations/{}/forks/'.format(API_BASE, self.private_registration._id)
self.public_project = ProjectFactory(is_public=True, creator=self.user)
self.public_registration = RegistrationFactory(creator=self.user, project=self.public_project, is_public=True)
self.public_registration_url = '/{}registrations/{}/forks/'.format(API_BASE, self.public_registration._id)
def setUp(self):
super(TestRegistrationFiltering, self).setUp()
self.user_one = AuthUserFactory()
self.user_two = AuthUserFactory()
self.project_one = ProjectFactory(title="Project One", description='Two', is_public=True, creator=self.user_one, category='hypothesis')
self.project_two = ProjectFactory(title="Project Two", description="One Three", is_public=True, creator=self.user_one)
self.project_three = ProjectFactory(title="Three", is_public=True, creator=self.user_two)
self.private_project_user_one = ProjectFactory(title="Private Project User One",
is_public=False,
creator=self.user_one)
self.private_project_user_two = ProjectFactory(title="Private Project User Two",
is_public=False,
creator=self.user_two)
self.project_one.add_tag('tag1', Auth(self.project_one.creator), save=False)
self.project_one.add_tag('tag2', Auth(self.project_one.creator), save=False)
self.project_one.save()
self.project_two.add_tag('tag1', Auth(self.project_two.creator), save=True)
self.project_two.save()
self.project_one_reg = RegistrationFactory(creator=self.user_one, project=self.project_one, is_public=True)
self.project_two_reg = RegistrationFactory(creator=self.user_one, project=self.project_two, is_public=True)
self.project_three_reg = RegistrationFactory(creator=self.user_two, project=self.project_three, is_public=True)
self.private_project_user_one_reg = RegistrationFactory(creator=self.user_one, project=self.private_project_user_one, is_public=False)
self.private_project_user_two_reg = RegistrationFactory(creator=self.user_two, project=self.private_project_user_two, is_public=False)
self.folder = CollectionFactory()
self.bookmark_collection = find_bookmark_collection(self.user_one)
self.url = "/{}registrations/".format(API_BASE)
def setUp(self):
super(TestRegistrationList, self).setUp()
self.user = AuthUserFactory()
self.project = ProjectFactory(is_public=False, creator=self.user)
self.registration_project = RegistrationFactory(creator=self.user, project=self.project)
self.url = '/{}registrations/'.format(API_BASE)
self.public_project = ProjectFactory(is_public=True, creator=self.user)
self.public_registration_project = RegistrationFactory(creator=self.user, project=self.public_project, is_public=True)
self.user_two = AuthUserFactory()
def setUp(self):
super(TestUserRegistrations, self).setUp()
self.user_one = AuthUserFactory()
self.user_one.social['twitter'] = 'howtopizza'
self.user_one.save()
self.user_two = AuthUserFactory()
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 = CollectionFactory(
title="Deleted Project User One",
is_public=False,
creator=self.user_one,
is_deleted=True)
self.folder = CollectionFactory()
self.deleted_folder = CollectionFactory(
title="Deleted Folder User One",
is_public=False,
creator=self.user_one,
is_deleted=True)
self.bookmark_collection = find_bookmark_collection(self.user_one)
self.reg_public_project_user_one = RegistrationFactory(
project=self.public_project_user_one,
creator=self.user_one,
is_public=True)
self.reg_private_project_user_one = RegistrationFactory(
project=self.private_project_user_one,
creator=self.user_one,
is_private=True)
self.reg_public_project_user_two = RegistrationFactory(
project=self.public_project_user_two,
creator=self.user_two,
is_public=True)
self.reg_private_project_user_two = RegistrationFactory(
project=self.private_project_user_two,
creator=self.user_two,
is_private=True)
def test_bulk_cannot_add_link_to_registration(self):
registration = RegistrationFactory(creator=self.user)
url = '/{}nodes/{}/node_links/'.format(API_BASE, registration._id)
payload = {'data': [{'type': 'node_links', 'relationships': {'nodes': {'data': {'type': 'nodes', 'id': self.public_pointer_project._id}}}}]}
res = self.app.post_json_api(url, payload, auth=self.user.auth, expect_errors=True, bulk=True)
assert_equal(res.status_code, 404)
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 setUp(self):
super(RegistrationRetractionModelsTestCase, self).setUp()
self.user = UserFactory()
self.registration = RegistrationFactory(creator=self.user,
is_public=True)
self.valid_justification = fake.sentence()
self.invalid_justification = fake.text(max_nb_chars=3000)
def test_draft_that_has_been_registered_cannot_be_deleted(self):
reg = RegistrationFactory(project=self.public_project)
self.draft_registration.registered_node = reg
self.draft_registration.save()
res = self.app.delete_json_api(self.url, auth=self.user.auth, expect_errors=True)
assert_equal(res.status_code, 403)
assert_equal(res.json['errors'][0]['detail'], 'This draft has already been registered and cannot be modified.')
def test_serialization(self):
user = UserFactory()
req = make_drf_request()
reg = RegistrationFactory(creator=user)
result = RegistrationSerializer(reg, context={'request': req}).data
data = result['data']
assert_equal(data['id'], reg._id)
assert_equal(data['type'], 'registrations')
# Attributes
attributes = data['attributes']
assert_datetime_equal(parse_date(attributes['date_registered']),
reg.registered_date)
assert_equal(attributes['retracted'], reg.is_retracted)
# Relationships
relationships = data['relationships']
assert_in('registered_by', relationships)
registered_by = relationships['registered_by']['links']['related'][
'href']
assert_equal(
urlparse(registered_by).path,
'/{}users/{}/'.format(API_BASE, user._id))
assert_in('registered_from', relationships)
registered_from = relationships['registered_from']['links']['related'][
'href']
assert_equal(
urlparse(registered_from).path,
'/{}nodes/{}/'.format(API_BASE, reg.registered_from._id))
def test_cancelling_registration_approval_deletes_component_registrations(self):
component = NodeFactory(
creator=self.user,
parent=self.project,
title='Component'
)
NodeFactory(
creator=self.user,
parent=component,
title='Subcomponent'
)
project_registration = RegistrationFactory(project=self.project)
component_registration = project_registration.nodes[0]
subcomponent_registration = component_registration.nodes[0]
project_registration.require_approval(
self.user
)
project_registration.save()
rejection_token = project_registration.registration_approval.approval_state[self.user._id]['rejection_token']
project_registration.registration_approval.reject(self.user, rejection_token)
assert_equal(project_registration.registration_approval.state, Sanction.REJECTED)
assert_true(project_registration.is_deleted)
assert_true(component_registration.is_deleted)
assert_true(subcomponent_registration.is_deleted)
def test_cannot_delete_if_registration(self):
registration = RegistrationFactory(project=self.public_project)
url = '/{}nodes/{}/node_links/'.format(API_BASE, registration._id)
res = self.app.delete_json_api(url, self.public_payload, auth=self.user.auth, expect_errors=True, bulk=True)
assert_equal(res.status_code, 404)
def setUp(self):
super(RegistrationEmbargoViewsTestCase, self).setUp()
ensure_schemas()
self.user = AuthUserFactory()
self.project = ProjectFactory(creator=self.user)
self.draft = DraftRegistrationFactory(branched_from=self.project)
self.registration = RegistrationFactory(project=self.project, creator=self.user)
current_month = datetime.datetime.now().strftime("%B")
current_year = datetime.datetime.now().strftime("%Y")
self.valid_make_public_payload = json.dumps({
u'embargoEndDate': u'Fri, 01, {month} {year} 00:00:00 GMT'.format(
month=current_month,
year=current_year
),
u'registrationChoice': 'immediate',
u'summary': unicode(fake.sentence())
})
valid_date = datetime.datetime.now() + datetime.timedelta(days=180)
self.valid_embargo_payload = json.dumps({
u'embargoEndDate': unicode(valid_date.strftime('%a, %d, %B %Y %H:%M:%S')) + u' GMT',
u'registrationChoice': 'embargo',
u'summary': unicode(fake.sentence())
})
self.invalid_embargo_date_payload = json.dumps({
u'embargoEndDate': u"Thu, 01 {month} {year} 05:00:00 GMT".format(
month=current_month,
year=str(int(current_year)-1)
),
u'registrationChoice': 'embargo',
u'summary': unicode(fake.sentence())
})
def test_redirect_to_registration_view(self):
registration = RegistrationFactory()
url = '/{}guids/{}/'.format(API_BASE, registration._id)
res = self.app.get(url, auth=self.user.auth)
redirect_url = '{}{}registrations/{}/'.format(API_DOMAIN, API_BASE, registration._id)
assert_equal(res.status_code, 302)
assert_equal(res.location, redirect_url)
def test_make_child_embargoed_registration_public_asks_all_admins_in_tree(self, mock_ask):
# Initiate and approve embargo
node = NodeFactory(creator=self.user)
c1 = AuthUserFactory()
child = NodeFactory(parent=node, creator=c1)
c2 = AuthUserFactory()
NodeFactory(parent=child, creator=c2)
registration = RegistrationFactory(project=node)
registration.embargo_registration(
self.user,
datetime.datetime.utcnow() + datetime.timedelta(days=10)
)
for user_id, embargo_tokens in registration.embargo.approval_state.iteritems():
approval_token = embargo_tokens['approval_token']
registration.embargo.approve_embargo(User.load(user_id), approval_token)
self.registration.save()
res = self.app.post(
registration.api_url_for('project_set_privacy', permissions='public'),
auth=self.user.auth
)
assert_equal(res.status_code, 200)
asked_admins = [(admin._id, n._id) for admin, n in mock_ask.call_args[0][0]]
for admin, node in registration.get_admin_contributors_recursive():
assert_in((admin._id, node._id), asked_admins)
def setUp(self):
super(TestMetricsGetProjects, self).setUp()
Node.remove()
self.public_node = ProjectFactory(is_public=True)
self.private_node = ProjectFactory(is_public=False)
self.node_2 = NodeFactory() # creates parent project + node
self.reg = RegistrationFactory(project=self.public_node)
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
def setUp(self):
super(TestMetricsGetProjects, self).setUp()
Node.remove()
self.node = NodeFactory(category='project',
is_public=True) # makes 2 nodes bc of category
self.reg = RegistrationFactory() # makes 2 nodes
self.node_2 = NodeFactory()
def _set_up_public_registration_with_wiki_page(self):
self._set_up_public_project_with_wiki_page()
self.public_registration = RegistrationFactory(project=self.public_project, user=self.user, is_public=True)
self.public_registration_wiki_id = self.public_registration.wiki_pages_versions['home'][0]
self.public_registration.wiki_pages_current = {'home': self.public_registration_wiki_id}
self.public_registration.save()
self.public_registration_url = '/{}registrations/{}/wikis/'.format(API_BASE, self.public_registration._id)
def setUp(self):
super(TestRetractRegistrations, self).setUp()
self.user = UserFactory()
self.registration = RegistrationFactory(creator=self.user)
self.registration.is_public = True
self.registration.retract_registration(self.user)
self.registration.save()
def setUp(self):
super(RegistrationEmbargoModelsTestCase, self).setUp()
self.user = UserFactory()
self.project = ProjectFactory(creator=self.user)
self.registration = RegistrationFactory(project=self.project)
self.embargo = EmbargoFactory(user=self.user)
self.valid_embargo_end_date = datetime.datetime.utcnow() + datetime.timedelta(days=3)
def setUp(self):
super(ComponentRegistrationRetractionViewsTestCase, self).setUp()
self.user = AuthUserFactory()
self.auth = self.user.auth
self.project = ProjectFactory(is_public=True, creator=self.user)
self.component = NodeFactory(
is_public=True,
creator=self.user,
parent=self.project,
title='Component'
)
self.subproject = ProjectFactory(
is_public=True,
creator=self.user,
parent=self.project,
title='Subproject'
)
self.subproject_component = NodeFactory(
is_public=True,
creator=self.user,
parent=self.subproject,
title='Subcomponent'
)
self.registration = RegistrationFactory(is_public=True, project=self.project)
self.component_registration = self.registration.nodes[0]
self.subproject_registration = self.registration.nodes[1]
self.subproject_component_registration = self.subproject_registration.nodes[0]
def setUp(self):
super(RegistrationRetractionApprovalDisapprovalViewsTestCase,
self).setUp()
self.user = AuthUserFactory()
self.auth = self.user.auth
self.registration = RegistrationFactory(is_public=True,
creator=self.user)
def test_retract_component_raises_NodeStateError(self):
project = ProjectFactory(is_public=True, creator=self.user)
component = NodeFactory(is_public=True, creator=self.user, parent=project)
registration = RegistrationFactory(is_public=True, project=project)
with assert_raises(NodeStateError):
registration.nodes[0].retract_registration(self.user, self.valid_justification)
def _set_up_private_registration_with_wiki_page(self):
self._set_up_private_project_with_wiki_page()
self.private_registration = RegistrationFactory(project=self.private_project, user=self.user)
self.private_registration_wiki_id = self.private_registration.wiki_pages_versions['home'][0]
self.private_registration.wiki_pages_current = {'home': self.private_registration_wiki_id}
self.private_registration.save()
self.private_registration_url = '/{}wikis/{}/'.format(API_BASE, self.private_registration_wiki_id)
def test_rejecting_embargo_for_existing_registration_does_not_deleted_component_registrations(
self):
component = NodeFactory(creator=self.user,
parent=self.project,
title='Component')
subcomponent = NodeFactory(creator=self.user,
parent=component,
title='Subcomponent')
project_registration = RegistrationFactory(project=self.project)
component_registration = project_registration.nodes[0]
subcomponent_registration = component_registration.nodes[0]
project_registration.embargo_registration(
self.user,
datetime.datetime.utcnow() + datetime.timedelta(days=10),
for_existing_registration=True)
rejection_token = project_registration.embargo.approval_state[
self.user._id]['rejection_token']
project_registration.embargo.disapprove_embargo(
self.user, rejection_token)
project_registration.save()
assert_equal(project_registration.embargo.state, Embargo.REJECTED)
assert_false(project_registration.is_deleted)
assert_false(component_registration.is_deleted)
assert_false(subcomponent_registration.is_deleted)
def test_cannot_access_retracted_files_list(self):
registration = RegistrationFactory(creator=self.user,
project=self.public_project)
url = '/{}nodes/{}/files/'.format(API_BASE, registration._id)
retraction = RetractedRegistrationFactory(registration=registration,
user=registration.creator)
res = self.app.get(url, auth=self.user.auth, expect_errors=True)
assert_equal(res.status_code, 404)
