def node_one(self, user):
return NodeFactory(title='Ismael Lo: Tajabone',
creator=user,
is_public=True)
def node(self, user):
return NodeFactory(creator=user)
def setUp(self):
super(TestResolveGuid, self).setUp()
self.node = NodeFactory()
def public_component(self, user, public_project):
return NodeFactory(parent=public_project, creator=user, is_public=True)
def node(self, greg):
return NodeFactory(creator=greg)
def great_grandchild_node_two(self, user, grandchild_node_two, institution):
great_grandchild_node_two = NodeFactory(parent=grandchild_node_two, creator=user, is_public = True)
great_grandchild_node_two.affiliated_institutions.add(institution)
great_grandchild_node_two.save()
return great_grandchild_node_two
def test__get_readable_descendants(self):
project = ProjectFactory(creator=self.user)
child = NodeFactory(parent=project, creator=self.user)
nodes, all_readable = _get_readable_descendants(auth=Auth(project.creator), node=project)
assert_equal(nodes[0]._id, child._id)
assert_true(all_readable)
def node_other(self):
return NodeFactory()
def node_public(self):
return NodeFactory(is_public=True)
def node_contrib(self, user, user_two):
node_contrib = NodeFactory(creator=user_two)
node_contrib.add_contributor(user, auth=Auth(user_two))
node_contrib.save()
return node_contrib
def test_node_errors(self, app, user, node_private, node_contrib,
node_public, node_other, make_payload, url_private,
url_public, node_linking_private):
# test_node_doesnt_exist
res = app.post_json_api(url_private,
make_payload(['aquarela']),
auth=user.auth,
expect_errors=True)
assert res.status_code == 404
# test_type_mistyped
res = app.post_json_api(
url_private,
{'data': [{
'type': 'not_linked_nodes',
'id': node_contrib._id
}]},
auth=user.auth,
expect_errors=True)
assert res.status_code == 409
# test_type_nodes_not_acceptable_below_2_13
res = app.post_json_api(
url_private, {'data': [{
'type': 'nodes',
'id': node_contrib._id
}]},
auth=user.auth,
expect_errors=True)
assert res.status_code == 409
# test_type_linked_nodes_not_acceptable_as_of_2_13
res = app.post_json_api(
'{}?version=2.13'.format(url_private),
{'data': [{
'type': 'linked_nodes',
'id': node_contrib._id
}]},
auth=user.auth,
expect_errors=True)
assert res.status_code == 409
# test_creates_public_linked_node_relationship_logged_out
res = app.post_json_api(url_public,
make_payload([node_public._id]),
expect_errors=True)
assert res.status_code == 401
# test_creates_public_linked_node_relationship_logged_in
res = app.post_json_api(url_public,
make_payload([node_public._id]),
auth=user.auth,
expect_errors=True)
assert res.status_code == 403
# test_creates_private_linked_node_relationship_logged_out
res = app.post_json_api(url_private,
make_payload([node_other._id]),
expect_errors=True)
assert res.status_code == 401
# test_put_public_nodes_relationships_logged_out
res = app.put_json_api(url_public,
make_payload([node_public._id]),
expect_errors=True)
assert res.status_code == 401
# test_put_public_nodes_relationships_logged_in
res = app.put_json_api(url_public,
make_payload([node_private._id]),
auth=user.auth,
expect_errors=True)
# test_put_child_node
assert res.status_code == 403
# test_delete_public_nodes_relationships_logged_out
res = app.delete_json_api(url_public,
make_payload([node_public._id]),
expect_errors=True)
assert res.status_code == 401
# test_delete_public_nodes_relationships_logged_in
res = app.delete_json_api(url_public,
make_payload([node_private._id]),
auth=user.auth,
expect_errors=True)
assert res.status_code == 403
# test_node_child_cannot_be_linked_on_create
node_child = NodeFactory(creator=user)
node_parent = NodeFactory(creator=user)
node_parent_child = NodeRelationFactory(child=node_child,
parent=node_parent)
url = '/{}nodes/{}/relationships/linked_nodes/'.format(
API_BASE, node_parent_child.parent._id)
res = app.post_json_api(url, {
'data': [{
'type': 'linked_nodes',
'id': node_parent_child.child._id
}]
},
auth=user.auth,
expect_errors=True)
assert res.status_code == 400
# test_linking_node_to_itself _on_create
node_self = NodeFactory(creator=user)
url = '/{}nodes/{}/relationships/linked_nodes/'.format(
API_BASE, node_self._id)
res = app.post_json_api(url_private,
make_payload([node_linking_private._id]),
auth=user.auth,
expect_errors=True)
assert res.status_code == 400
# test_linking_child_node_to_parent_on_create
node_child = NodeFactory(creator=user)
node_parent = NodeFactory(creator=user)
node_parent_child = NodeRelationFactory(child=node_child,
parent=node_parent)
url = '/{}nodes/{}/relationships/linked_nodes/'.format(
API_BASE, node_parent_child.child._id)
res = app.post_json_api(url, {
'data': [{
'type': 'linked_nodes',
'id': node_parent_child.parent._id
}]
},
auth=user.auth,
expect_errors=True)
assert res.status_code == 400
# test_node_child_cannot_be_linked_on_update
node_child = NodeFactory(creator=user)
node_parent = NodeFactory(creator=user)
node_parent_child = NodeRelationFactory(child=node_child,
parent=node_parent)
url = '/{}nodes/{}/relationships/linked_nodes/'.format(
API_BASE, node_parent_child.parent._id)
res = app.put_json_api(url, {
'data': [{
'type': 'linked_nodes',
'id': node_parent_child.child._id
}]
},
auth=user.auth,
expect_errors=True)
assert res.status_code == 400
# test_linking_child_node_to_parent_on_update
node_child = NodeFactory(creator=user)
node_parent = NodeFactory(creator=user)
node_parent_child = NodeRelationFactory(child=node_child,
parent=node_parent)
url = '/{}nodes/{}/relationships/linked_nodes/'.format(
API_BASE, node_parent_child.child._id)
res = app.put_json_api(url, {
'data': [{
'type': 'linked_nodes',
'id': node_parent_child.parent._id
}]
},
auth=user.auth,
expect_errors=True)
assert res.status_code == 400
# test_linking_node_to_itself _on_update
node_self = NodeFactory(creator=user)
url = '/{}nodes/{}/relationships/linked_nodes/'.format(
API_BASE, node_self._id)
res = app.put_json_api(url_private,
make_payload([node_linking_private._id]),
auth=user.auth,
expect_errors=True)
assert res.status_code == 400
def setUp(self):
super(ApiSearchTestCase, self).setUp()
self.user = AuthUserFactory()
self.user_one = AuthUserFactory(fullname='Kanye Omari West')
self.user_one.schools = [{
'degree': 'English',
'institution': 'Chicago State University'
}]
self.user_one.jobs = [{
'title': 'Producer',
'institution': 'GOOD Music, Inc.'
}]
self.user_one.save()
self.user_two = AuthUserFactory(fullname='Chance The Rapper')
self.institution = InstitutionFactory(name='Social Experiment')
self.user_two.affiliated_institutions.add(self.institution)
self.user_two.save()
# self.institution.save()
self.project = ProjectFactory(title='The Life of Pablo',
creator=self.user_one,
is_public=True)
self.project.set_description('Name one genius who ain\'t crazy',
auth=Auth(self.user_one),
save=True)
self.project.add_tag('Yeezus', auth=Auth(self.user_one), save=True)
self.project_two = ProjectFactory(title='Graduation',
creator=self.user_one,
is_public=True)
self.private_project = ProjectFactory(title='Coloring Book',
creator=self.user_two)
self.component = NodeFactory(parent=self.project,
title='Ultralight Beam',
creator=self.user_two,
is_public=True)
self.component.set_description('This is my part, nobody else speak',
auth=Auth(self.user_two),
save=True)
self.component.add_tag('trumpets', auth=Auth(self.user_two), save=True)
self.component_two = NodeFactory(parent=self.project,
title='Highlights',
creator=self.user_one,
is_public=True)
self.private_component = NodeFactory(parent=self.project,
title='Wavves',
creator=self.user_one)
self.file = utils.create_test_file(self.component,
self.user_one,
filename='UltralightBeam.mp3')
self.file_two = utils.create_test_file(self.component_two,
self.user_one,
filename='Highlights.mp3')
self.private_file = utils.create_test_file(self.private_component,
self.user_one,
filename='Wavves.mp3')
def node_private(self, user):
return NodeFactory(title='Classified', creator=user)
def node_two(self, user):
return NodeFactory(title='Sambolera', creator=user, is_public=True)
def child_node_two(self, user, parent_project, institution):
child_node_two = NodeFactory(parent=parent_project, creator=user, is_public = True)
child_node_two.affiliated_institutions.add(institution)
child_node_two.save()
return child_node_two
def node_linking_private(self, user, node_private):
node_linking_private = NodeFactory(creator=user)
node_linking_private.add_pointer(node_private, auth=Auth(user))
return node_linking_private
def grandchild_node_one(self, user, child_node_one, institution):
grandchild_node_one = NodeFactory(parent=child_node_one, creator=user, is_public = True)
grandchild_node_one.affiliated_institutions.add(institution)
grandchild_node_one.save()
return grandchild_node_one
def node_public(self, user):
return NodeFactory(is_public=True, creator=user)
def test_view_project_embed_descendants(self):
child = NodeFactory(parent=self.project, creator=self.user)
res = _view_project(self.project, auth=Auth(self.project.creator), embed_descendants=True)
assert_in('descendants', res['node'])
assert_equal(len(res['node']['descendants']), 1)
assert_equal(res['node']['descendants'][0]['id'], child._id)
def node_linking_public(self, user_two, node_private, node_public):
node_linking_public = NodeFactory(is_public=True, creator=user_two)
node_linking_public.add_pointer(node_private, auth=Auth(user_two))
node_linking_public.add_pointer(node_public, auth=Auth(user_two))
return node_linking_public
def component(self, user, private_project):
return NodeFactory(parent=private_project, creator=user)
def project(self, submitter):
return NodeFactory(creator=submitter)
def test_node_children_list_does_not_include_unauthorized_projects(self, app, user, component, private_project, private_project_url):
private_component = NodeFactory(parent=private_project)
res = app.get(private_project_url, auth=user.auth)
assert len(res.json['data']) == 1
def node_public(self, registration):
node_public = NodeFactory(is_public=True)
node_public.add_pointer(registration, auth=Auth(node_public.creator))
node_public.save()
return node_public
def node_with_file(self):
node = NodeFactory()
file = create_test_file(node, node.creator)
file.save()
node.save()
return node
def test_initiate_withdraw_registration_fails(
self, app, user, read_write_contributor, public_registration,
make_payload, private_registration, public_url, private_url,
public_project, public_payload):
# test set pending_withdrawal with no auth
res = app.put_json_api(public_url, public_payload, expect_errors=True)
assert res.status_code == 401
# test set pending_withdrawal from a read write contrib
public_registration.add_contributor(read_write_contributor,
permissions=[permissions.WRITE])
public_registration.save()
res = app.put_json_api(public_url,
public_payload,
auth=read_write_contributor.auth,
expect_errors=True)
assert res.status_code == 403
# test set pending_withdrawal private registration fails
payload_private = make_payload(id=private_registration._id,
attributes={
'pending_withdrawal':
True,
'withdrawal_justification':
'fine whatever'
})
res = app.put_json_api(private_url,
payload_private,
auth=user.auth,
expect_errors=True)
assert res.status_code == 400
# test set pending_withdrawal for component fails
project = ProjectFactory(is_public=True, creator=user)
NodeFactory(is_public=True, creator=user, parent=project)
registration_with_comp = RegistrationFactory(is_public=True,
project=project)
registration_comp = registration_with_comp._nodes.first()
payload_component = make_payload(
id=registration_comp._id, attributes={'pending_withdrawal': True})
url = '/{}registrations/{}/'.format(API_BASE, registration_comp._id)
res = app.put_json_api(url,
payload_component,
auth=user.auth,
expect_errors=True)
assert res.status_code == 400
# setting pending_withdrawal to false fails
public_payload['data']['attributes'] = {'pending_withdrawal': False}
res = app.put_json_api(public_url,
public_payload,
auth=user.auth,
expect_errors=True)
assert res.status_code == 400
# test set pending_withdrawal with just withdrawal_justification key
public_payload['data']['attributes'] = {
'withdrawal_justification': 'Not enough oopmh.'
}
res = app.put_json_api(public_url,
public_payload,
auth=user.auth,
expect_errors=True)
assert res.status_code == 400
# set pending_withdrawal on a registration already pending withdrawal fails
public_registration._initiate_retraction(user)
res = app.put_json_api(public_url,
public_payload,
auth=user.auth,
expect_errors=True)
assert res.status_code == 400
def _create_n_nodes(n, roots=True):
return [ProjectFactory() if roots else NodeFactory() for _ in range(n)]
def child_node_one(self, user, parent_project, institution, parent_project_one):
child_node_one = NodeFactory(parent=parent_project, title='Friend of {}'.format(parent_project_one._id), creator=user, is_public=True)
child_node_one.affiliated_institutions.add(institution)
child_node_one.save()
return child_node_one
def node(self, user):
return NodeFactory(creator=user, is_public=True)
def component_private(self, user_one, project_public):
return NodeFactory(parent=project_public,
title='Wavves',
creator=user_one)
