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)