def test_find_failed_registrations(self):
failures = []
legacy = []
delta = datetime.timedelta(days=2)
for i in range(5):
reg = factories.RegistrationFactory()
reg.archive_job._fields['datetime_initiated'].__set__(
reg.archive_job, datetime.datetime.now() - delta, safe=True)
reg.save()
ArchiveJob.remove_one(reg.archive_job)
legacy.append(reg._id)
for i in range(5):
reg = factories.RegistrationFactory()
reg.archive_job._fields['datetime_initiated'].__set__(
reg.archive_job, datetime.datetime.now() - delta, safe=True)
reg.save()
for addon in ['osfstorage', 'dropbox']:
reg.archive_job._set_target(addon)
reg.archive_job.update_target(addon, ARCHIVER_INITIATED)
reg.archive_job.sent = False
reg.archive_job.save()
failures.append(reg._id)
pending = []
for i in range(5):
reg = factories.RegistrationFactory()
for addon in ['osfstorage', 'dropbox']:
reg.archive_job._set_target(addon)
reg.archive_job.update_target(addon, ARCHIVER_INITIATED)
reg.archive_job.save()
pending.append(reg)
failed = scripts.find_failed_registrations()
assert_items_equal([f._id for f in failed], failures)
for pk in legacy:
assert_false(pk in failed)
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'])
registration_registration = factories.RegistrationFactory(
project=registration)
data = self.BasicNodeSerializer(registration_registration,
context={
'request': req
}).data['data']
field = data['relationships']['registered_from']['links']
assert_in('/v2/registrations/{}/'.format(registration._id),
field['related']['href'])
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)
mock_update_search.assert_not_called()
def test_archiving_registrations_not_added_to_search_before_archival(
self, mock_update_search):
proj = factories.ProjectFactory()
reg = factories.RegistrationFactory(project=proj)
ArchiveJob(src_node=proj, dst_node=reg, initiator=proj.creator)
reg.save()
mock_update_search.assert_not_called()
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.set_targets()
assert_equal([t.name for t in job.target_addons],
['osfstorage', 'dropbox'])
def test_archive_success_adds_registered_logs(self, mock_enqueue):
proj = factories.ProjectFactory()
len_logs = len(proj.logs)
reg = factories.RegistrationFactory(project=proj, archive=True)
archiver_utils.archive_success(reg, proj.creator)
assert_equal(len(proj.logs), len_logs + 1)
assert_equal([p for p in proj.logs][-1].action, NodeLog.PROJECT_REGISTERED)
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[0]
rchild2 = rchild.nodes[0]
for node in [reg, rchild, rchild2]:
for addon in ['dropbox', 'osfstorage']:
node.archive_job._set_target(addon)
for node in [reg, rchild, rchild2]:
for addon in ['dropbox', 'osfstorage']:
node.archive_job.update_target(addon, ARCHIVER_INITIATED)
for addon in ['dropbox', 'osfstorage']:
rchild.archive_job.update_target(addon, ARCHIVER_SUCCESS)
rchild.save()
listeners.archive_callback(rchild)
mock_send_success.assert_not_called()
for addon in ['dropbox', 'osfstorage']:
reg.archive_job.update_target(addon, ARCHIVER_SUCCESS)
reg.save()
listeners.archive_callback(reg)
mock_send_success.assert_not_called()
for addon in ['dropbox', 'osfstorage']:
rchild2.archive_job.update_target(addon, ARCHIVER_SUCCESS)
rchild2.save()
listeners.archive_callback(rchild2)
mock_send_success.assert_called()
def test_on_complete_sets_state_to_approved(self):
user = factories.UserFactory()
registration = factories.RegistrationFactory(creator=user)
registration.require_approval(user)
assert_true(registration.registration_approval.is_pending_approval) # sanity check
registration.registration_approval._on_complete(None)
assert_false(registration.registration_approval.is_pending_approval)
def test_delete_registration_tree_deletes_backrefs(self):
proj = factories.NodeFactory()
factories.NodeFactory(parent=proj)
comp2 = factories.NodeFactory(parent=proj)
factories.NodeFactory(parent=comp2)
reg = factories.RegistrationFactory(project=proj)
archiver_utils.delete_registration_tree(reg)
assert_false(proj.node__registrations)
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_delete_registration_tree(self):
proj = factories.NodeFactory()
factories.NodeFactory(parent=proj)
comp2 = factories.NodeFactory(parent=proj)
factories.NodeFactory(parent=comp2)
reg = factories.RegistrationFactory(project=proj)
reg_ids = [reg._id] + [r._id for r in reg.get_descendants_recursive()]
archiver_utils.delete_registration_tree(reg)
assert_false(Node.find(Q('_id', 'in', reg_ids) & Q('is_deleted', 'eq', False)).count())
def setUp(self, *args, **kwargs):
super(TestSanction, self).setUp(*args, **kwargs)
self.user = valid_user()
self.invalid_user = factories.UserFactory()
self.sanction = SanctionTestClass(initiated_by=self.user,
end_date=datetime.datetime.now() +
datetime.timedelta(days=2))
self.registration = factories.RegistrationFactory()
self.sanction.add_authorizer(self.user, self.registration, save=True)
def test_get_target(self):
proj = factories.ProjectFactory()
reg = factories.RegistrationFactory(project=proj)
job = ArchiveJob(src_node=proj, dst_node=reg, initiator=proj.creator)
job.set_targets()
dropbox = job.get_target('dropbox')
assert_false(not dropbox)
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 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 setUp(self):
super(TestNodeEmbargoTerminations, self).setUp()
self.user = factories.AuthUserFactory()
self.node = factories.ProjectFactory(creator=self.user)
with mock_archive(self.node, embargo=True,
autoapprove=True) as registration:
self.registration = registration
self.not_embargoed = factories.RegistrationFactory()
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[0]
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_archiving_nodes_not_added_to_search_on_archive_failure(self, mock_send, mock_update_search):
proj = factories.ProjectFactory()
reg = factories.RegistrationFactory(project=proj)
reg.save()
with nested(
mock.patch('website.archiver.model.ArchiveJob.archive_tree_finished', mock.Mock(return_value=True)),
mock.patch('website.archiver.model.ArchiveJob.sent', mock.PropertyMock(return_value=False)),
mock.patch('website.archiver.model.ArchiveJob.success', mock.PropertyMock(return_value=False))
) as (mock_finished, mock_sent, mock_success):
listeners.archive_callback(reg)
mock_update_search.assert_not_called()
def _make_registration(self, schemas):
if not isinstance(schemas, list):
schemas = [schemas]
reg = factories.RegistrationFactory()
reg.save()
self.db['node'].update({'_id': reg._id}, {
'$set': {
'registered_meta': {
to_mongo(schema.name): json.dumps(OLD_META[schema.name])
for schema in schemas
},
'registered_schema': None
}
})
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]
listeners.after_register(c1, rc1, self.user)
mock_chain.assert_not_called()
listeners.after_register(c2, rc2, self.user)
mock_chain.assert_not_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_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[0]
rchild2 = rchild.nodes[0]
for node in [reg, rchild, rchild2]:
for addon in ['osfstorage', 'dropbox']:
node.archive_job._set_target(addon)
for node in [reg, rchild, rchild2]:
for addon in ['osfstorage', 'dropbox']:
node.archive_job.update_target(addon, ARCHIVER_SUCCESS)
for node in [reg, rchild, rchild2]:
assert_true(node.archive_job.archive_tree_finished())
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(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[0]
rchild2 = reg.nodes[1]
rchild2a = rchild2.nodes[0]
regs = itertools.chain([reg], reg.get_descendants_recursive())
for node in regs:
assert_false(node.archive_job.archive_tree_finished())
for node in regs:
assert_false(node.archive_job.archive_tree_finished())
for node in [reg, rchild2]:
for target in node.archive_job.target_addons:
node.archive_job.update_target(target.name, ARCHIVER_SUCCESS)
for node in regs:
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()
mock_update_search.assert_not_called()
def _get_registration(self):
return factories.RegistrationFactory()
def setUp(self):
super(TestRegistrationApproval, self).setUp()
ensure_schemas()
self.user = factories.AuthUserFactory()
self.registration = factories.RegistrationFactory(creator=self.user, archive=True)
