def test_archiving_nodes_not_added_to_search_on_archive_incomplete(self, mock_send, mock_update_search):
proj = factories.ProjectFactory()
reg = factories.RegistrationFactory(project=proj)
reg.save()
with mock.patch('website.archiver.model.ArchiveJob.archive_tree_finished', mock.Mock(return_value=False)):
listeners.archive_callback(reg)
assert_false(mock_update_search.called)
def setUp(self):
with run_celery_tasks():
super(TestPublicNodes, self).setUp()
self.user = factories.UserFactory(fullname='Doug Bogie')
self.title = 'Red Special'
self.consolidate_auth = Auth(user=self.user)
self.project = factories.ProjectFactory(
title=self.title,
creator=self.user,
is_public=True,
)
self.component = factories.NodeFactory(
parent=self.project,
title=self.title,
creator=self.user,
is_public=True
)
self.registration = factories.RegistrationFactory(
title=self.title,
creator=self.user,
is_public=True,
)
self.registration.archive_job.target_addons = []
self.registration.archive_job.status = 'SUCCESS'
self.registration.archive_job.save()
def test_archive_callback_on_tree_sends_only_one_email(
self, mock_send_success, mock_arhive_success):
proj = factories.NodeFactory()
child = factories.NodeFactory(parent=proj)
factories.NodeFactory(parent=child)
reg = factories.RegistrationFactory(project=proj)
rchild = reg._nodes.first()
rchild2 = rchild._nodes.first()
for node in [reg, rchild, rchild2]:
node.archive_job._set_target('osfstorage')
for node in [reg, rchild, rchild2]:
node.archive_job.update_target('osfstorage', ARCHIVER_INITIATED)
rchild.archive_job.update_target('osfstorage', ARCHIVER_SUCCESS)
rchild.save()
listeners.archive_callback(rchild)
assert_false(mock_send_success.called)
reg.archive_job.update_target('osfstorage', ARCHIVER_SUCCESS)
reg.save()
listeners.archive_callback(reg)
assert_false(mock_send_success.called)
rchild2.archive_job.update_target('osfstorage', ARCHIVER_SUCCESS)
rchild2.save()
listeners.archive_callback(rchild2)
assert_equal(mock_send_success.call_count, 1)
assert_true(mock_send_success.called)
def registration_with_contribs(self, user, user2):
proj = factories.NodeFactory(creator=user)
proj.add_contributor(user2, permissions.ADMIN)
embargo = factories.EmbargoFactory()
embargo.end_date = timezone.now() + datetime.timedelta(days=4)
return factories.RegistrationFactory(project=proj,
creator=user,
embargo=embargo)
def setUp(self):
super(TestNodeSerializerAndRegistrationSerializerDifferences, self).setUp()
self.node = factories.ProjectFactory(is_public=True)
self.registration = factories.RegistrationFactory(project = self.node, is_public=True)
self.url = '/{}nodes/{}/'.format(API_BASE, self.node._id)
self.reg_url = '/{}registrations/{}/'.format(API_BASE, self.registration._id)
def test_on_complete_sets_state_to_approved(self, mock_update_search):
user = factories.UserFactory()
registration = factories.RegistrationFactory(creator=user)
registration.require_approval(user)
assert registration.registration_approval.is_pending_approval is True # sanity check
registration.registration_approval._on_complete(None)
assert registration.registration_approval.is_pending_approval is False
def test_set_targets(self):
proj = factories.ProjectFactory()
reg = factories.RegistrationFactory(project=proj)
job = ArchiveJob(src_node=proj, dst_node=reg, initiator=proj.creator)
job.save()
job.set_targets()
assert_equal(list(job.target_addons.values_list('name', flat=True)), ['osfstorage'])
def test_unmoderated_accept_sets_state_to_approved(self, mock_update_search):
user = factories.UserFactory()
registration = factories.RegistrationFactory(creator=user)
registration.require_approval(user)
assert registration.registration_approval.is_pending_approval is True # sanity check
registration.registration_approval.accept()
assert registration.registration_approval.is_pending_approval is False
def test_get_target(self):
proj = factories.ProjectFactory()
reg = factories.RegistrationFactory(project=proj)
job = ArchiveJob.objects.create(src_node=proj, dst_node=reg, initiator=proj.creator)
job.set_targets()
osfstorage = job.get_target('osfstorage')
assert_false(not osfstorage)
none = job.get_target('fake')
assert_false(none)
def test_archive_callback_updates_archiving_state_when_done(self):
proj = factories.NodeFactory()
factories.NodeFactory(parent=proj)
reg = factories.RegistrationFactory(project=proj)
reg.archive_job.update_target('osfstorage', ARCHIVER_INITIATED)
child = reg.nodes[0]
child.archive_job.update_target('osfstorage', ARCHIVER_SUCCESS)
child.save()
listeners.archive_callback(child)
assert_false(child.archiving)
def test_archiving_nodes_not_added_to_search_on_archive_failure(self, mock_send, mock_delete_index_node):
proj = factories.ProjectFactory()
reg = factories.RegistrationFactory(project=proj)
reg.save()
with nested(
mock.patch('osf.models.archive.ArchiveJob.archive_tree_finished', mock.Mock(return_value=True)),
mock.patch('osf.models.archive.ArchiveJob.success', mock.PropertyMock(return_value=False))
) as (mock_finished, mock_success):
listeners.archive_callback(reg)
assert_true(mock_delete_index_node.called)
def setUp(self):
super(ArchiverTestCase, self).setUp()
handlers.celery_before_request()
self.user = factories.UserFactory()
self.auth = Auth(user=self.user)
self.src = factories.NodeFactory(creator=self.user)
self.dst = factories.RegistrationFactory(user=self.user, project=self.src, send_signals=False)
archiver_utils.before_archive(self.dst, self.user)
self.archive_job = self.dst.archive_job
def test_archiving_nodes_added_to_search_on_archive_success_if_public(self, mock_update_search, mock_send, mock_archive_success):
proj = factories.ProjectFactory()
reg = factories.RegistrationFactory(project=proj)
reg.save()
with nested(
mock.patch('osf.models.ArchiveJob.archive_tree_finished', mock.Mock(return_value=True)),
mock.patch('osf.models.ArchiveJob.success', mock.PropertyMock(return_value=True))
) as (mock_finished, mock_success):
listeners.archive_callback(reg)
assert_equal(mock_update_search.call_count, 1)
def test_after_register_does_not_archive_pointers(self, mock_chain, mock_archive):
proj = factories.ProjectFactory(creator=self.user)
c1 = factories.ProjectFactory(creator=self.user, parent=proj)
other = factories.ProjectFactory(creator=self.user)
reg = factories.RegistrationFactory(project=proj)
r1 = reg._nodes.first()
proj.add_pointer(other, auth=Auth(self.user))
listeners.after_register(c1, r1, self.user)
listeners.after_register(proj, reg, self.user)
for kwargs in [dict(job_pk=n.archive_job._id,) for n in [reg, r1]]:
mock_archive.assert_any_call(**kwargs)
def test_field_with_callable_related_attrs(self):
req = make_drf_request_with_version(version='2.0')
project = factories.ProjectFactory()
node = factories.NodeFactory(parent=project)
data = self.BasicNodeSerializer(node, context={'request': req}).data['data']
assert_not_in('registered_from', data['relationships'])
registration = factories.RegistrationFactory(project=node)
data = self.BasicNodeSerializer(registration, context={'request': req}).data['data']
field = data['relationships']['registered_from']['links']
assert_in('/v2/nodes/{}/'.format(node._id), field['related']['href'])
def setUp(self):
super(TestRegistrationRetractions, self).setUp()
self.user = factories.UserFactory(fullname='Doug Bogie')
self.title = 'Red Special'
self.consolidate_auth = Auth(user=self.user)
self.project = factories.ProjectFactory(
title=self.title,
creator=self.user,
is_public=True,
)
self.registration = factories.RegistrationFactory(project=self.project, is_public=True)
def setUp(self):
super(TestODMTitleSearch, self).setUp()
self.user = factories.AuthUserFactory()
self.user_two = factories.AuthUserFactory()
self.project = factories.ProjectFactory(creator=self.user, title='foo')
self.project_two = factories.ProjectFactory(creator=self.user_two, title='bar')
self.public_project = factories.ProjectFactory(creator=self.user_two, is_public=True, title='baz')
self.registration_project = factories.RegistrationFactory(creator=self.user, title='qux')
self.folder = factories.CollectionFactory(creator=self.user, title='quux')
self.dashboard = find_bookmark_collection(self.user)
self.url = api_url_for('search_projects_by_title')
def test_archive_tree_finished_d3(self):
proj = factories.NodeFactory()
child = factories.NodeFactory(parent=proj)
factories.NodeFactory(parent=child)
reg = factories.RegistrationFactory(project=proj)
rchild = reg._nodes.first()
rchild2 = rchild._nodes.first()
for node in [reg, rchild, rchild2]:
node.archive_job._set_target('osfstorage')
for node in [reg, rchild, rchild2]:
node.archive_job.update_target('osfstorage', ARCHIVER_SUCCESS)
for node in [reg, rchild, rchild2]:
assert_true(node.archive_job.archive_tree_finished())
def test_find_failed_registrations(self):
failures = []
legacy = []
delta = settings.ARCHIVE_TIMEOUT_TIMEDELTA + datetime.timedelta(
hours=1)
for i in range(5):
reg = factories.RegistrationFactory()
archive_job = reg.archive_job
archive_job.datetime_initiated = timezone.now() - delta
archive_job.save()
reg.save()
ArchiveJob.remove_one(archive_job)
legacy.append(reg._id)
for i in range(5):
reg = factories.RegistrationFactory()
datetime_initiated = timezone.now() - delta
archive_job = reg.archive_job
archive_job.datetime_initiated = datetime_initiated
archive_job.status = ARCHIVER_INITIATED
archive_job.save()
reg.save()
archive_job._set_target('osfstorage')
archive_job.update_target('osfstorage', ARCHIVER_INITIATED)
archive_job.sent = False
archive_job.save()
failures.append(reg._id)
pending = []
for i in range(5):
reg = factories.RegistrationFactory()
archive_job = reg.archive_job
archive_job._set_target('osfstorage')
archive_job.update_target('osfstorage', ARCHIVER_INITIATED)
archive_job.save()
pending.append(reg)
failed = scripts.find_failed_registrations()
assert_equal(len(failed), 5)
assert_items_equal([f._id for f in failed], failures)
for pk in legacy:
assert_false(pk in failed)
def test_after_register_archive_runs_only_for_root(self, mock_chain, mock_archive):
proj = factories.ProjectFactory()
c1 = factories.ProjectFactory(parent=proj)
c2 = factories.ProjectFactory(parent=c1)
reg = factories.RegistrationFactory(project=proj)
rc1 = reg.nodes[0]
rc2 = rc1.nodes[0]
mock_chain.reset_mock()
listeners.after_register(c1, rc1, self.user)
assert_false(mock_chain.called)
listeners.after_register(c2, rc2, self.user)
assert_false(mock_chain.called)
listeners.after_register(proj, reg, self.user)
for kwargs in [dict(job_pk=n.archive_job._id,) for n in [reg, rc1, rc2]]:
mock_archive.assert_any_call(**kwargs)
def test_drafts_for_user_omits_registered(self):
prereg_schema = MetaSchema.find_one(
Q('name', 'eq', 'Prereg Challenge') & Q('schema_version', 'eq', 2))
d1 = factories.DraftRegistrationFactory(
initiator=self.user, registration_schema=prereg_schema)
d2 = factories.DraftRegistrationFactory(
initiator=self.user, registration_schema=prereg_schema)
d3 = factories.DraftRegistrationFactory(
initiator=self.user, registration_schema=prereg_schema)
d1.registered_node = factories.RegistrationFactory()
d1.save()
drafts = drafts_for_user(self.user, 'prereg')
for d in drafts:
assert_in(d._id, (d2._id, d3._id))
assert_not_equal(d._id, d1._id)
def test_drafts_for_user_omits_registered(self):
prereg_schema = RegistrationSchema.objects.get(name='Prereg Challenge',
schema_version=2)
d1 = factories.DraftRegistrationFactory(
initiator=self.user, registration_schema=prereg_schema)
d2 = factories.DraftRegistrationFactory(
initiator=self.user, registration_schema=prereg_schema)
d3 = factories.DraftRegistrationFactory(
initiator=self.user, registration_schema=prereg_schema)
d1.registered_node = factories.RegistrationFactory()
d1.save()
drafts = drafts_for_user(self.user, 'prereg')
for d in drafts:
assert_in(d._id, (d2._id, d3._id))
assert_not_equal(d._id, d1._id)
def test_archive_tree_finished_with_nodes(self):
proj = factories.NodeFactory()
factories.NodeFactory(parent=proj)
comp2 = factories.NodeFactory(parent=proj)
factories.NodeFactory(parent=comp2)
reg = factories.RegistrationFactory(project=proj)
rchild1 = reg._nodes.first()
for node in reg.node_and_primary_descendants():
assert_false(node.archive_job.archive_tree_finished())
for target in rchild1.archive_job.target_addons.all():
rchild1.archive_job.update_target(target.name, ARCHIVER_SUCCESS)
rchild1.archive_job.save()
assert_false(reg.archive_job.archive_tree_finished())
for node in reg.node_and_primary_descendants():
for target in node.archive_job.target_addons.all():
node.archive_job.update_target(target.name, ARCHIVER_SUCCESS)
for node in reg.node_and_primary_descendants():
assert_true(node.archive_job.archive_tree_finished())
def setUp(self):
super(TestShowIfVersion, self).setUp()
self.node = factories.NodeFactory()
self.registration = factories.RegistrationFactory()
def test_archiving_registrations_not_added_to_search_before_archival(self, mock_update_search):
proj = factories.ProjectFactory()
reg = factories.RegistrationFactory(project=proj)
reg.save()
assert_false(mock_update_search.called)
def not_embargoed(self):
return factories.RegistrationFactory()
