class TestSubjectEditValidation(OsfTestCase):
def setUp(self):
super(TestSubjectEditValidation, self).setUp()
self.subject = SubjectFactory()
def test_edit_unused_subject(self):
self.subject.text = 'asdfg'
self.subject.save()
def test_edit_used_subject(self):
preprint = PreprintFactory(subjects=[[self.subject._id]])
self.subject.text = 'asdfg'
with assert_raises(ValidationError):
self.subject.save()
def test_delete_unused_subject(self):
self.subject.delete()
def test_delete_used_subject(self):
preprint = PreprintFactory(subjects=[[self.subject._id]])
with assert_raises(ValidationError):
self.subject.delete()
def test_max_highlighted_count(self):
highlights = [SubjectFactory(provider=self.subject.provider, highlighted=True) for _ in range(10)]
with assert_raises(ValidationError):
self.subject.highlighted=True
self.subject.save()
def test_highlighted_subjects(self):
subj_a = SubjectFactory(provider=self.provider, text='A')
subj_b = SubjectFactory(provider=self.provider, text='B')
subj_aa = SubjectFactory(provider=self.provider, text='AA', parent=subj_a)
subj_ab = SubjectFactory(provider=self.provider, text='AB', parent=subj_a)
subj_ba = SubjectFactory(provider=self.provider, text='BA', parent=subj_b)
subj_bb = SubjectFactory(provider=self.provider, text='BB', parent=subj_b)
subj_aaa = SubjectFactory(provider=self.provider, text='AAA', parent=subj_aa)
assert set(self.provider.highlighted_subjects) == set([subj_a, subj_b])
subj_aaa.highlighted = True
subj_aaa.save()
assert set(self.provider.highlighted_subjects) == set([subj_aaa])
def test_change_preprint_provider_subjects_to_osf(self, plain_view,
preprint_user,
provider_one,
provider_osf,
subject_osf):
""" Testing that subjects are changed when providers are changed to osf using the bepress subject id of the old subject
"""
subject_one = SubjectFactory(provider=provider_one,
bepress_subject=subject_osf)
preprint = PreprintFactory(subjects=[[subject_one._id]],
provider=provider_one,
creator=preprint_user)
request = RequestFactory().post(reverse('preprints:preprint',
kwargs={'guid': preprint._id}),
data={'provider': provider_osf.id})
request.user = preprint_user
response = plain_view.as_view()(request, guid=preprint._id)
assert response.status_code == 302
preprint.refresh_from_db()
assert preprint.provider == provider_osf
assert subject_osf in preprint.subjects.all()
def test_nonadmin_cannot_set_subjects(self):
initial_subjects = list(self.preprint.subjects.all())
with assert_raises(PermissionsError):
self.preprint.set_subjects([[SubjectFactory()._id]], auth=Auth(self.write_contrib))
self.preprint.reload()
assert_equal(initial_subjects, list(self.preprint.subjects.all()))
def setUp(self):
super(TestPreprintIsPublishedDetail, self).setUp()
self.admin = AuthUserFactory()
self.write_contrib = AuthUserFactory()
self.non_contrib = AuthUserFactory()
self.public_project = ProjectFactory(creator=self.admin,
is_public=True)
self.public_project.add_contributor(self.write_contrib,
permissions=['read', 'write'],
save=True)
self.subject = SubjectFactory()
self.provider = PreprintProviderFactory()
self.file_one_public_project = test_utils.create_test_file(
self.public_project, self.admin, 'mgla.pdf')
self.unpublished_preprint = PreprintFactory(
creator=self.admin,
filename='mgla.pdf',
provider=self.provider,
subjects=[[self.subject._id]],
project=self.public_project,
is_published=False)
self.url = '/{}preprints/{}/'.format(API_BASE,
self.unpublished_preprint._id)
def test_create_preprint_from_project_unpublished_does_not_hit_update(self, mock_on_preprint_updated):
private_project_payload = build_preprint_create_payload(self.private_project._id, self.provider._id, self.file_one_private_project._id, attrs={
'subjects': [[SubjectFactory()._id]],
'is_published': False
})
res = self.app.post_json_api(self.url, private_project_payload, auth=self.user.auth)
assert not mock_on_preprint_updated.called
def setUp(self):
super(TestOnPreprintUpdatedTask, self).setUp()
self.user = AuthUserFactory()
if len(self.user.fullname.split(' ')) > 2:
# Prevent unexpected keys ('suffix', 'additional_name')
self.user.fullname = 'David Davidson'
self.user.middle_names = ''
self.user.suffix = ''
self.user.save()
self.auth = Auth(user=self.user)
self.preprint = PreprintFactory()
thesis_provider = PreprintProviderFactory(share_publish_type='Thesis')
self.thesis = PreprintFactory(provider=thesis_provider)
for pp in [self.preprint, self.thesis]:
pp.node.add_tag('preprint', self.auth, save=False)
pp.node.add_tag('spoderman', self.auth, save=False)
pp.node.add_unregistered_contributor('BoJack Horseman', '*****@*****.**', Auth(pp.node.creator))
pp.node.add_contributor(self.user, visible=False)
pp.node.save()
pp.node.creator.given_name = u'ZZYZ'
if len(pp.node.creator.fullname.split(' ')) > 2:
# Prevent unexpected keys ('suffix', 'additional_name')
pp.node.creator.fullname = 'David Davidson'
pp.node.creator.middle_names = ''
pp.node.creator.suffix = ''
pp.node.creator.save()
pp.set_subjects([[SubjectFactory()._id]], auth=Auth(pp.node.creator))
def test_admin_can_set_subjects(self):
initial_subjects = list(self.preprint.subjects.all())
self.preprint.set_subjects([[SubjectFactory()._id]],
auth=Auth(self.user))
self.preprint.reload()
assert_not_equal(initial_subjects, list(self.preprint.subjects.all()))
def setUp(self):
super(TestPreprintUpdate, self).setUp()
self.user = AuthUserFactory()
self.preprint = PreprintFactory(creator=self.user)
self.url = '/{}preprints/{}/'.format(API_BASE, self.preprint._id)
self.subject = SubjectFactory()
def test_max_highlighted_count(self):
highlights = [
SubjectFactory(provider=self.subject.provider, highlighted=True)
for _ in range(10)
]
with assert_raises(ValidationError):
self.subject.highlighted = True
self.subject.save()
def setUp(self):
super(TestTaxonomy, self).setUp()
# Subject 1 has 3 children
self.subject1 = SubjectFactory()
self.subject1_child1 = SubjectFactory(parents=[self.subject1])
self.subject1_child2 = SubjectFactory(parents=[self.subject1])
# Subject 2 has a child whose parent is both subject 1 and subject 2
self.subject2 = SubjectFactory()
self.subject2_child1_subject1_child3 = SubjectFactory(
parents=[self.subject1, self.subject2])
self.subjects = Subject.find()
self.url = '/{}taxonomies/'.format(API_BASE)
self.res = self.app.get(self.url)
self.data = self.res.json['data']
def setUp(self):
super(TestPreprintSaveShareHook, self).setUp()
self.admin = AuthUserFactory()
self.auth = Auth(user=self.admin)
self.provider = PreprintProviderFactory(
name='Lars Larson Snowmobiling Experience')
self.project = ProjectFactory(creator=self.admin, is_public=True)
self.subject = SubjectFactory()
self.subject_two = SubjectFactory()
self.file = api_test_utils.create_test_file(self.project, self.admin,
'second_place.pdf')
self.preprint = PreprintFactory(creator=self.admin,
filename='second_place.pdf',
provider=self.provider,
subjects=[[self.subject._id]],
project=self.project,
is_published=False)
def test_set_subjects_as_attributes_validation(self, app, user_admin_contrib, resource, subject, resource_type_plural,
url, make_resource_payload):
grandparent = SubjectFactory()
parent = SubjectFactory(parent=grandparent)
subject.parent = parent
subject.save()
# test_not_list
update_subjects_payload = make_resource_payload(resource, resource_type_plural, attributes={'subjects': grandparent._id})
res = app.patch_json_api(url, update_subjects_payload, auth=user_admin_contrib.auth, expect_errors=True)
assert res.status_code == 400
assert res.json['errors'][0]['detail'] == 'Subjects are improperly formatted. Expecting list of lists.'
# test_not_list_of_lists
update_subjects_payload = make_resource_payload(resource, resource_type_plural, attributes={'subjects': [grandparent._id]})
res = app.patch_json_api(url, update_subjects_payload, auth=user_admin_contrib.auth, expect_errors=True)
assert res.status_code == 400
assert res.json['errors'][0]['detail'] == 'Subjects are improperly formatted. Expecting list of lists.'
# test_invalid_subject_in_payload
update_subjects_payload = make_resource_payload(resource, resource_type_plural, attributes={'subjects': [['bad_id']]})
res = app.patch_json_api(url, update_subjects_payload, auth=user_admin_contrib.auth, expect_errors=True)
assert res.status_code == 400
assert res.json['errors'][0]['detail'] == 'Subject with id <bad_id> could not be found.'
# test_invalid_hierarchy
update_subjects_payload = make_resource_payload(resource, resource_type_plural, attributes={'subjects': [[grandparent._id, 'bad_id']]})
res = app.patch_json_api(url, update_subjects_payload, auth=user_admin_contrib.auth, expect_errors=True)
assert res.status_code == 400
assert 'Invalid subject hierarchy' in res.json['errors'][0]['detail']
# test_full_hierarchy_not_present
update_subjects_payload = make_resource_payload(resource, resource_type_plural, attributes={'subjects': [[grandparent._id, subject._id]]})
res = app.patch_json_api(url, update_subjects_payload, auth=user_admin_contrib.auth, expect_errors=True)
assert res.status_code == 400
assert 'Invalid subject hierarchy' in res.json['errors'][0]['detail']
# test_unordered_hierarchy
update_subjects_payload = make_resource_payload(resource, resource_type_plural, attributes={'subjects': [[parent._id, grandparent._id, subject._id]]})
res = app.patch_json_api(url, update_subjects_payload, auth=user_admin_contrib.auth, expect_errors=True)
assert res.status_code == 200
subjects = resource.subjects.all()
assert parent in subjects
assert grandparent in subjects
assert subject in subjects
def setUp(self):
super(TestPreprintProviderChangeForm, self).setUp()
self.user = AuthUserFactory()
self.preprint_provider = PreprintProviderFactory()
self.request = RequestFactory().get('/fake_path')
self.request.user = self.user
self.view = views.PreprintProviderChangeForm()
self.view = setup_form_view(self.view, self.request, form=PreprintProviderForm())
self.parent_1 = SubjectFactory(provider=PreprintProviderFactory(_id='osf'))
self.child_1 = SubjectFactory(parent=self.parent_1)
self.child_2 = SubjectFactory(parent=self.parent_1)
self.grandchild_1 = SubjectFactory(parent=self.child_1)
self.view.kwargs = {'preprint_provider_id': self.preprint_provider.id}
def test_has_highlighted_subjects_flag(
self, app, provider,
provider_two, provider_url, provider_url_two):
SubjectFactory(
provider=provider,
text='A', highlighted=True)
SubjectFactory(provider=provider_two, text='B')
res = app.get(provider_url)
assert res.status_code == 200
res_subjects = res.json['data']['relationships']['highlighted_taxonomies']
assert res_subjects['links']['related']['meta']['has_highlighted_subjects'] is True
res = app.get(provider_url_two)
assert res.status_code == 200
res_subjects = res.json['data']['relationships']['highlighted_taxonomies']
assert res_subjects['links']['related']['meta']['has_highlighted_subjects'] is False
def setUp(self):
super(TestPreprintBannerView, self).setUp()
self.admin = AuthUserFactory()
self.provider_one = PreprintProviderFactory()
self.provider_two = PreprintProviderFactory()
self.project_one = ProjectFactory(creator=self.admin, is_public=True)
self.project_two = ProjectFactory(creator=self.admin, is_public=True)
self.project_three = ProjectFactory(creator=self.admin, is_public=True)
self.subject_one = SubjectFactory()
self.subject_two = SubjectFactory()
self.file_one = test_utils.create_test_file(self.project_one, self.admin, 'mgla.pdf')
self.file_two = test_utils.create_test_file(self.project_two, self.admin, 'saor.pdf')
self.published_preprint = PreprintFactory(creator=self.admin, filename='mgla.pdf', provider=self.provider_one, subjects=[[self.subject_one._id]], project=self.project_one, is_published=True)
self.unpublished_preprint = PreprintFactory(creator=self.admin, filename='saor.pdf', provider=self.provider_two, subjects=[[self.subject_two._id]], project=self.project_two, is_published=False)
def test_has_highlighted_subjects_flag(
self, app, preprint_provider,
preprint_provider_two, provider_url):
SubjectFactory(
provider=preprint_provider,
text='A', highlighted=True)
SubjectFactory(provider=preprint_provider_two, text='B')
res = app.get(provider_url)
assert res.status_code == 200
res_subjects = res.json['data']['relationships']['highlighted_taxonomies']
assert res_subjects['links']['related']['meta']['has_highlighted_subjects'] is True
url_provider_two = '/{}preprint_providers/{}/'.format(
API_BASE, preprint_provider_two._id)
res = app.get(url_provider_two)
assert res.status_code == 200
res_subjects = res.json['data']['relationships']['highlighted_taxonomies']
assert res_subjects['links']['related']['meta']['has_highlighted_subjects'] is False
def test_create_preprint_from_private_project(self):
private_project_payload = build_preprint_create_payload(self.private_project._id, self.provider._id, self.file_one_private_project._id, attrs={
'subjects': [[SubjectFactory()._id]],
'is_published': True
})
res = self.app.post_json_api(self.url, private_project_payload, auth=self.user.auth)
self.private_project.reload()
assert_equal(res.status_code, 201)
assert_true(self.private_project.is_public)
def setUp(self):
super(TestSubjectRules, self).setUp()
self.parent_one = SubjectFactory() # 0
self.parent_two = SubjectFactory() # 1
self.child_one_1 = SubjectFactory(parent=self.parent_one) # 2
self.child_one_2 = SubjectFactory(parent=self.parent_one) # 3
self.grandchild_one_1 = SubjectFactory(parent=self.child_one_1) # 4
self.grandchild_one_2 = SubjectFactory(parent=self.child_one_1) # 5
self.child_two_1 = SubjectFactory(parent=self.parent_two) # 6
self.child_two_2 = SubjectFactory(parent=self.parent_two) # 7
def test_all_subjects(self):
subj_a = SubjectFactory(provider=self.provider, text='A')
subj_b = SubjectFactory(provider=self.provider, text='B')
subj_aa = SubjectFactory(provider=self.provider, text='AA', parent=subj_a)
subj_ab = SubjectFactory(provider=self.provider, text='AB', parent=subj_a)
subj_ba = SubjectFactory(provider=self.provider, text='BA', parent=subj_b)
subj_bb = SubjectFactory(provider=self.provider, text='BB', parent=subj_b)
subj_aaa = SubjectFactory(provider=self.provider, text='AAA', parent=subj_aa)
some_other_provider = PreprintProviderFactory(name='asdfArxiv')
subj_asdf = SubjectFactory(provider=some_other_provider)
assert set(self.provider.all_subjects) == set([subj_a, subj_b, subj_aa, subj_ab, subj_ba, subj_bb, subj_aaa])
def test_project_made_public(self):
assert_false(self.project.is_public)
self.preprint.set_primary_file(self.file, auth=self.auth, save=True)
assert_false(self.project.is_public)
with assert_raises(ValueError):
self.preprint.set_published(True, auth=self.auth, save=True)
self.preprint.provider = PreprintProviderFactory()
self.preprint.set_subjects([[SubjectFactory()._id]], auth=self.auth)
self.project.reload()
assert_false(self.project.is_public)
self.preprint.set_published(True, auth=self.auth, save=True)
self.project.reload()
assert_true(self.project.is_public)
def test_publish_preprint_fails_with_invalid_primary_file(self, mock_get_identifiers):
no_file_payload = build_preprint_create_payload(
node_id=self.public_project._id,
provider_id=self.provider._id,
file_id='totallynotanid',
attrs= {
'is_published': True,
'subjects': [[SubjectFactory()._id]],
}
)
res = self.app.post_json_api(self.url, no_file_payload, auth=self.user.auth, expect_errors=True)
assert_equal(res.status_code, 400)
assert_equal(res.json['errors'][0]['detail'], 'A valid primary_file must be set before publishing a preprint.')
def setUp(self):
super(PreprintIsValidListMixin, self).setUp()
assert self.admin, 'Subclasses of PreprintIsValidListMixin must define self.admin'
assert self.project, 'Subclasses of PreprintIsValidListMixin must define self.project'
assert self.provider, 'Subclasses of PreprintIsValidListMixin must define self.provider'
assert self.url, 'Subclasses of PreprintIsValidListMixin must define self.url'
self.write_contrib = AuthUserFactory()
self.non_contrib = AuthUserFactory()
self.subject = SubjectFactory()
self.file_one_project = test_utils.create_test_file(self.project, self.admin, 'saor.pdf')
self.project.add_contributor(self.write_contrib, permissions=permissions.DEFAULT_CONTRIBUTOR_PERMISSIONS, save=True)
self.preprint = PreprintFactory(creator=self.admin, filename='saor.pdf', provider=self.provider, subjects=[[self.subject._id]], project=self.project, is_published=True)
def test_create_preprint_adds_log_if_published(self, mock_get_identifiers):
public_project_payload = build_preprint_create_payload(
self.public_project._id, self.provider._id,
self.file_one_public_project._id, {
'is_published': True,
'subjects': [[SubjectFactory()._id]],
})
res = self.app.post_json_api(self.url,
public_project_payload,
auth=self.user.auth)
assert_equal(res.status_code, 201)
preprint_id = res.json['data']['id']
preprint = PreprintService.load(preprint_id)
log = preprint.node.logs.latest()
assert_equal(log.action, 'preprint_initiated')
assert_equal(log.params.get('preprint'), preprint_id)
def test_setting_is_published_with_moderated_provider_fails(
self, mock_on_preprint_updated):
self.provider.reviews_workflow = 'pre-moderation'
self.provider.save()
public_project_payload = build_preprint_create_payload(
self.public_project._id, self.provider._id,
self.file_one_public_project._id, {
'is_published': True,
'subjects': [[SubjectFactory()._id]],
})
res = self.app.post_json_api(self.url,
public_project_payload,
auth=self.user.auth,
expect_errors=True)
assert res.status_code == 409
assert not mock_on_preprint_updated.called
def setUp(self):
super(TestPreprintBannerView, self).setUp()
self.admin = AuthUserFactory()
self.write_contrib = AuthUserFactory()
self.read_contrib = AuthUserFactory()
self.non_contrib = AuthUserFactory()
self.provider_one = PreprintProviderFactory()
self.project_one = ProjectFactory(creator=self.admin, is_public=True)
self.project_one.add_contributor(self.write_contrib, ['write', 'read'])
self.project_one.add_contributor(self.read_contrib, ['read'])
self.subject_one = SubjectFactory()
self.preprint = PreprintFactory(creator=self.admin, filename='mgla.pdf', provider=self.provider_one, subjects=[[self.subject_one._id]], project=self.project_one, is_published=True)
self.preprint.add_contributor(self.write_contrib, 'write')
self.preprint.add_contributor(self.read_contrib, 'read')
def setUp(self):
super(TestPreprintCreate, self).setUp()
self.user = AuthUserFactory()
self.other_user = AuthUserFactory()
self.private_project = ProjectFactory(creator=self.user)
self.public_project = ProjectFactory(creator=self.user, is_public=True)
self.public_project.add_contributor(
self.other_user,
permissions=permissions.DEFAULT_CONTRIBUTOR_PERMISSIONS,
save=True)
self.subject = SubjectFactory()
self.provider = PreprintProviderFactory()
self.user_two = AuthUserFactory()
self.url = '/{}preprints/'.format(API_BASE)
def test_change_preprint_provider_subjects_custom_taxonomies(self, plain_view, preprint_user, provider_one, provider_two, subject_one):
""" Testing that subjects are changed when providers are changed between two custom taxonomies.
"""
subject_two = SubjectFactory(provider=provider_two,
bepress_subject=subject_one.bepress_subject)
preprint = PreprintFactory(subjects=[[subject_one._id]], provider=provider_one, creator=preprint_user)
request = RequestFactory().post(reverse('preprints:preprint', kwargs={'guid': preprint._id}), data={'provider': provider_two.id})
request.user = preprint_user
response = plain_view.as_view()(request, guid=preprint._id)
assert response.status_code == 302
preprint.refresh_from_db()
assert preprint.provider == provider_two
assert subject_two in preprint.subjects.all()
def setUp(self):
super(TestPreprintProviderSpecificSubjects, self).setUp()
self.provider_1 = PreprintProviderFactory()
self.provider_2 = PreprintProviderFactory()
self.root_subject_1 = SubjectFactory(text='R1', provider=self.provider_1)
self.parent_subject_1 = SubjectFactory(text='P1', provider=self.provider_1, parent=self.root_subject_1)
self.child_subject_1 = SubjectFactory(text='C1', provider=self.provider_1, parent=self.parent_subject_1)
self.root_subject_2 = SubjectFactory(text='R2', provider=self.provider_2)
self.parent_subject_2 = SubjectFactory(text='P2', provider=self.provider_2, parent=self.root_subject_2)
self.child_subject_2 = SubjectFactory(text='C2', provider=self.provider_2, parent=self.parent_subject_2)
self.url_1 = '/{}preprint_providers/{}/taxonomies/?page[size]=15&'.format(API_BASE, self.provider_1._id)
self.url_2 = '/{}preprint_providers/{}/taxonomies/?page[size]=15&'.format(API_BASE, self.provider_2._id)
def setUp(self):
super(TestPreprintProviderExportImport, self).setUp()
self.user = AuthUserFactory()
self.preprint_provider = PreprintProviderFactory()
self.request = RequestFactory().get('/fake_path')
self.view = views.ExportPreprintProvider()
self.view = setup_user_view(self.view, self.request, user=self.user)
self.view.kwargs = {'preprint_provider_id': self.preprint_provider.id}
self.import_request = RequestFactory().get('/fake_path')
self.import_view = views.ImportPreprintProvider()
self.import_view = setup_user_view(self.import_view, self.import_request, user=self.user)
self.preprint_provider.licenses_acceptable = [NodeLicense.objects.get(license_id='NONE')]
self.subject = SubjectFactory(provider=self.preprint_provider)
def setUp(self):
self.user = AuthUserFactory()
self.subject1 = SubjectFactory()
self.subject2 = SubjectFactory()
self.subject3 = SubjectFactory()
self.subject1_1 = SubjectFactory(parent=self.subject1)
self.subject2_1 = SubjectFactory(parent=self.subject2)
self.subject3_1 = SubjectFactory(parent=self.subject3)
self.subject1_1_1 = SubjectFactory(parent=self.subject1_1)
self.preprint_provider = PreprintProviderFactory()
self.request = RequestFactory().get('/fake_path')
self.view = views.ProcessCustomTaxonomy()
self.view = setup_user_view(self.view, self.request, user=self.user)
class TestSubjectEditValidation(OsfTestCase):
def setUp(self):
super(TestSubjectEditValidation, self).setUp()
self.subject = SubjectFactory()
def test_edit_unused_subject(self):
self.subject.text = 'asdfg'
self.subject.save()
def test_edit_used_subject(self):
preprint = PreprintFactory(subjects=[[self.subject._id]])
self.subject.text = 'asdfg'
with assert_raises(ValidationError):
self.subject.save()
def test_delete_unused_subject(self):
self.subject.delete()
def test_delete_used_subject(self):
preprint = PreprintFactory(subjects=[[self.subject._id]])
with assert_raises(ValidationError):
self.subject.delete()
def setUp(self):
super(TestSubjectEditValidation, self).setUp()
self.subject = SubjectFactory()
def setUp(self):
super(TestSubjectTreeValidation, self).setUp()
self.root_subject = SubjectFactory()
self.one_level_root = SubjectFactory()
self.two_level_root = SubjectFactory()
self.outside_root = SubjectFactory()
self.root_subject.save()
self.outside_root.save()
self.two_level_root.save()
self.one_level_root.save()
self.parent_subj_0 = SubjectFactory(parent=self.root_subject)
self.parent_subj_1 = SubjectFactory(parent=self.root_subject)
self.two_level_parent = SubjectFactory(parent=self.two_level_root)
self.outside_parent = SubjectFactory(parent=self.outside_root)
self.parent_subj_0.save()
self.parent_subj_1.save()
self.outside_parent.save()
self.two_level_parent.save()
self.child_subj_00 = SubjectFactory(parent=self.parent_subj_0)
self.child_subj_01 = SubjectFactory(parent=self.parent_subj_0)
self.child_subj_10 = SubjectFactory(parent=self.parent_subj_1)
self.child_subj_11 = SubjectFactory(parent=self.parent_subj_1)
self.outside_child = SubjectFactory(parent=self.outside_parent)
self.child_subj_00.save()
self.child_subj_01.save()
self.child_subj_10.save()
self.child_subj_11.save()
self.outside_child.save()
self.valid_full_hierarchy = [self.root_subject._id, self.parent_subj_0._id, self.child_subj_00._id]
self.valid_two_level_hierarchy = [self.two_level_root._id, self.two_level_parent._id]
self.valid_one_level_hierarchy = [self.one_level_root._id]
self.valid_partial_hierarchy = [self.root_subject._id, self.parent_subj_1._id]
self.valid_root = [self.root_subject._id]
self.no_root = [self.parent_subj_0._id, self.child_subj_00._id]
self.no_parent = [self.root_subject._id, self.child_subj_00._id]
self.invalid_child_leaf = [self.root_subject._id, self.parent_subj_0._id, self.child_subj_10._id]
self.invalid_parent_leaf = [self.root_subject._id, self.outside_parent._id, self.child_subj_00._id]
self.invalid_root_leaf = [self.outside_root._id, self.parent_subj_0._id, self.child_subj_00._id]
self.invalid_ids = ['notarealsubjectid', 'thisisalsoafakeid']
class TestSubjectTreeValidation(OsfTestCase):
def setUp(self):
super(TestSubjectTreeValidation, self).setUp()
self.root_subject = SubjectFactory()
self.one_level_root = SubjectFactory()
self.two_level_root = SubjectFactory()
self.outside_root = SubjectFactory()
self.root_subject.save()
self.outside_root.save()
self.two_level_root.save()
self.one_level_root.save()
self.parent_subj_0 = SubjectFactory(parent=self.root_subject)
self.parent_subj_1 = SubjectFactory(parent=self.root_subject)
self.two_level_parent = SubjectFactory(parent=self.two_level_root)
self.outside_parent = SubjectFactory(parent=self.outside_root)
self.parent_subj_0.save()
self.parent_subj_1.save()
self.outside_parent.save()
self.two_level_parent.save()
self.child_subj_00 = SubjectFactory(parent=self.parent_subj_0)
self.child_subj_01 = SubjectFactory(parent=self.parent_subj_0)
self.child_subj_10 = SubjectFactory(parent=self.parent_subj_1)
self.child_subj_11 = SubjectFactory(parent=self.parent_subj_1)
self.outside_child = SubjectFactory(parent=self.outside_parent)
self.child_subj_00.save()
self.child_subj_01.save()
self.child_subj_10.save()
self.child_subj_11.save()
self.outside_child.save()
self.valid_full_hierarchy = [self.root_subject._id, self.parent_subj_0._id, self.child_subj_00._id]
self.valid_two_level_hierarchy = [self.two_level_root._id, self.two_level_parent._id]
self.valid_one_level_hierarchy = [self.one_level_root._id]
self.valid_partial_hierarchy = [self.root_subject._id, self.parent_subj_1._id]
self.valid_root = [self.root_subject._id]
self.no_root = [self.parent_subj_0._id, self.child_subj_00._id]
self.no_parent = [self.root_subject._id, self.child_subj_00._id]
self.invalid_child_leaf = [self.root_subject._id, self.parent_subj_0._id, self.child_subj_10._id]
self.invalid_parent_leaf = [self.root_subject._id, self.outside_parent._id, self.child_subj_00._id]
self.invalid_root_leaf = [self.outside_root._id, self.parent_subj_0._id, self.child_subj_00._id]
self.invalid_ids = ['notarealsubjectid', 'thisisalsoafakeid']
def test_hiarachy_property(self):
assert_equal(self.child_subj_00.hierarchy, [self.root_subject._id, self.parent_subj_0._id, self.child_subj_00._id])
assert_equal(self.two_level_parent.hierarchy, [self.two_level_root._id, self.two_level_parent._id])
assert_equal(self.one_level_root.hierarchy, [self.one_level_root._id])
assert_equal(self.parent_subj_1.hierarchy, [self.root_subject._id, self.parent_subj_1._id])
assert_equal(self.root_subject.hierarchy, [self.root_subject._id])
def test_object_hierarchy_property(self):
assert_equal(self.child_subj_00.object_hierarchy, [self.root_subject, self.parent_subj_0, self.child_subj_00])
assert_equal(self.two_level_parent.object_hierarchy, [self.two_level_root, self.two_level_parent])
assert_equal(self.one_level_root.object_hierarchy, [self.one_level_root])
assert_equal(self.parent_subj_1.object_hierarchy, [self.root_subject, self.parent_subj_1])
assert_equal(self.root_subject.object_hierarchy, [self.root_subject])
def test_validation_full_hierarchy(self):
assert_equal(validate_subject_hierarchy(self.valid_full_hierarchy), None)
def test_validation_two_level_hierarchy(self):
assert_equal(validate_subject_hierarchy(self.valid_two_level_hierarchy), None)
def test_validation_one_level_hierarchy(self):
assert_equal(validate_subject_hierarchy(self.valid_one_level_hierarchy), None)
def test_validation_partial_hierarchy(self):
assert_equal(validate_subject_hierarchy(self.valid_partial_hierarchy), None)
def test_validation_root_only(self):
assert_equal(validate_subject_hierarchy(self.valid_root), None)
def test_invalidation_no_root(self):
with assert_raises(ValidationValueError) as e:
validate_subject_hierarchy(self.no_root)
assert_in('Unable to find root', e.exception.message)
def test_invalidation_no_parent(self):
with assert_raises(ValidationValueError) as e:
validate_subject_hierarchy(self.no_parent)
assert_in('Invalid subject hierarchy', e.exception.message)
def test_invalidation_invalid_child_leaf(self):
with assert_raises(ValidationValueError) as e:
validate_subject_hierarchy(self.invalid_child_leaf)
assert_in('Invalid subject hierarchy', e.exception.message)
def test_invalidation_invalid_parent_leaf(self):
with assert_raises(ValidationValueError) as e:
validate_subject_hierarchy(self.invalid_parent_leaf)
assert_in('Invalid subject hierarchy', e.exception.message)
def test_invalidation_invalid_root_leaf(self):
with assert_raises(ValidationValueError) as e:
validate_subject_hierarchy(self.invalid_root_leaf)
assert_in('Invalid subject hierarchy', e.exception.message)
def test_invalidation_invalid_ids(self):
with assert_raises(ValidationValueError) as e:
validate_subject_hierarchy(self.invalid_ids)
assert_in('could not be found', e.exception.message)
