def test_jsonification(self):
"""Tests that a jsonified document returns the appropriate values."""
date = datetime.datetime(2013, 04, 20, 12, 0, 0, tzinfo=utc)
document = DocumentFactory(
document_key="FAC09001-FWF-000-HSE-REP-0004",
created_on=date,
current_revision_date=date,
metadata={"title": "HAZOP report"},
revision={"status": "STD", "revision_date": date, "created_on": date, "updated_on": date},
)
self.assertEqual(
document.to_json(),
{
"status": "STD",
"title": "HAZOP report",
"url": document.get_absolute_url(),
"revision": 1,
"is_latest_revision": True,
"pk": document.metadata.latest_revision.pk,
"document_pk": document.pk,
"metadata_pk": document.metadata.pk,
"document_key": "FAC09001-FWF-000-HSE-REP-0004",
"document_number": "FAC09001-FWF-000-HSE-REP-0004",
},
)
def generate_random_documents(nb_of_docs, category):
"""Generate a bunch of random documents.
This function is useful for testing purpose.
"""
if category.category_template.metadata_model.model_class() != DemoMetadata:
error_message = ('This function is only useful for testing purpose. '
'The category you pass as an argument can only host '
'documents of the DemoMetadata type.')
raise Exception(error_message)
for i in range(nb_of_docs):
document = DocumentFactory(
category=category,
)
metadata = document.get_metadata()
max_revision = choice(list(range(1, 5)))
for revision_number in range(2, max_revision):
MetadataRevisionFactory(
revision=revision_number,
revision_date='{year}-{month:0>2}-{day:0>2}'.format(
year=2008 + revision_number,
month=choice(list(range(1, 13))),
day=choice(list(range(1, 29))),
),
metadata=metadata
)
def setUp(self):
self.category = CategoryFactory()
self.user = UserFactory(
email='*****@*****.**',
password='******',
is_superuser=True,
category=self.category
)
self.client.login(email=self.user.email, password='******')
self.doc1 = DocumentFactory(
category=self.category,
revision={
'leader': self.user,
'received_date': datetime.date.today(),
}
)
self.doc2 = DocumentFactory(
category=self.category,
revision={
'leader': self.user,
'received_date': datetime.date.today(),
}
)
self.doc3 = DocumentFactory(
category=self.category,
revision={
'reviewers': [],
'leader': None,
'approver': None,
'received_date': datetime.date.today(),
}
)
self.content_type = ContentType.objects.get_for_model(self.doc3.metadata)
self.ok = 'The review started for the following documents'
self.nok = "We failed to start the review for the following documents"
def setUp(self):
self.tmpdir = tempfile.mkdtemp(prefix='phasetest_', suffix='_trs')
self.incoming = join(self.tmpdir, 'incoming')
self.tobechecked = join(self.tmpdir, 'tobechecked')
self.accepted = join(self.tmpdir, 'accepted')
self.rejected = join(self.tmpdir, 'rejected')
os.mkdir(self.accepted)
os.mkdir(self.rejected)
os.mkdir(self.tobechecked)
doc = DocumentFactory(
document_key='FAC10005-CTR-CLT-TRS-00001',
metadata_factory_class=TransmittalFactory,
revision_factory_class=TransmittalRevisionFactory,
metadata={
'status': 'tobechecked',
'tobechecked_dir': self.tobechecked,
'accepted_dir': self.accepted,
'rejected_dir': self.rejected,
'contractor': 'test'
}
)
self.transmittal = doc.get_metadata()
os.mkdir(self.transmittal.full_tobechecked_name)
def test_edition_updates_document_key(self):
doc = DocumentFactory(
category=self.category,
document_key='FAC09001-FWF-000-HSE-REP-0004',
metadata={
'title': 'HAZOP related 1',
},
revision={
'status': 'STD',
}
)
c = self.client
c.post(doc.get_edit_url(), {
'document_number': 'New Document Number',
'title': 'a new title',
'docclass': 1,
'created_on': '2015-10-10',
'received_date': '2015-10-10',
'save-view': 'View',
}, follow=True)
doc.refresh_from_db()
self.assertEqual(doc.document_number, 'New Document Number')
self.assertEqual(doc.document_key, 'NEW-DOCUMENT-NUMBER')
metadata = doc.get_metadata()
self.assertEqual(metadata.document_number, 'New Document Number')
self.assertEqual(metadata.document_key, 'NEW-DOCUMENT-NUMBER')
def test_jsonification(self):
"""Tests that a jsonified document returns the appropriate values."""
date = datetime.datetime(2013, 04, 20, 12, 0, 0, tzinfo=utc)
document = DocumentFactory(
document_key='FAC09001-FWF-000-HSE-REP-0004',
created_on=date,
current_revision_date=date,
metadata={
'title': 'HAZOP report',
},
revision={
'status': 'STD',
'revision_date': date,
'created_on': date,
'updated_on': date,
}
)
self.assertEqual(
document.to_json(),
{
u'status': u'STD',
u'title': u'HAZOP report',
u'url': document.get_absolute_url(),
u'revision': 1,
u'is_latest_revision': True,
u'pk': document.metadata.latest_revision.pk,
u'document_pk': document.pk,
u'metadata_pk': document.metadata.pk,
u'document_key': 'FAC09001-FWF-000-HSE-REP-0004',
u'document_number': 'FAC09001-FWF-000-HSE-REP-0004',
}
)
def test_new_revision_can_update_document_key(self):
doc = DocumentFactory(
category=self.category,
document_key='FAC09001-FWF-000-HSE-REP-0004',
revision={
'status': 'STD',
}
)
url = reverse('document_revise', args=[
self.category.organisation.slug,
self.category.slug,
doc.document_key
])
self.client.post(url, {
'document_number': 'Another Document Number',
'title': doc.metadata.title,
'status': 'SPD',
'docclass': 1,
'created_on': '2015-10-10',
'revision_date': '2015-10-10',
'received_date': '2015-10-10',
}, follow=True)
doc.refresh_from_db()
self.assertEqual(doc.document_number, 'Another Document Number')
self.assertEqual(doc.document_key, 'ANOTHER-DOCUMENT-NUMBER')
metadata = doc.get_metadata()
self.assertEqual(metadata.document_number, 'Another Document Number')
self.assertEqual(metadata.document_key, 'ANOTHER-DOCUMENT-NUMBER')
def test_edition_success(self):
"""
Tests that a document can be created with required fields.
"""
original_number_of_document = Document.objects.all().count()
doc = DocumentFactory(
category=self.category,
document_key='FAC09001-FWF-000-HSE-REP-0004',
metadata={
'title': 'HAZOP related 1',
},
revision={
'status': 'STD',
}
)
c = self.client
r = c.post(doc.get_edit_url(), {
'document_number': doc.document_key,
'title': 'a new title',
})
if r.status_code == 302:
self.assertEqual(
original_number_of_document + 1,
Document.objects.all().count()
)
else:
# Debug purpose
self.assertEqual(r.context['form'].errors, {})
def test_all_revisions_document_download(self):
"""
Tests that download returns a zip file of all revisions
of a document.
"""
document = DocumentFactory(
category=self.category,
)
sample_path = b'documents/tests/'
native_doc = b'sample_doc_native.docx'
pdf_doc = b'sample_doc_pdf.pdf'
MetadataRevisionFactory(
metadata=document.get_metadata(),
revision=2,
native_file=SimpleUploadedFile(native_doc, sample_path + native_doc),
pdf_file=SimpleUploadedFile(pdf_doc, sample_path + pdf_doc),
)
MetadataRevisionFactory(
metadata=document.get_metadata(),
revision=3,
native_file=SimpleUploadedFile(native_doc, sample_path + native_doc),
pdf_file=SimpleUploadedFile(pdf_doc, sample_path + pdf_doc),
)
r = self.client.post(document.category.get_download_url(), {
'document_ids': document.id,
'revisions': 'all',
'format': 'both',
})
self.assertEqual(r.status_code, 200)
zipfile = BytesIO(r.content)
filelist = ZipFile(zipfile).namelist()
self.assertEqual(len(filelist), 4)
def test_deleted_document_is_unindexed(self, index_mock, unindex_mock):
doc = DocumentFactory(
category=self.category,
document_key='FAC09001-FWF-000-HSE-REP-0004',
)
doc.delete()
self.assertEqual(unindex_mock.call_count, 1)
def test_edition_errors(self):
"""
Tests that a document can't be edited without required fields.
"""
required_error = 'This field is required.'
doc = DocumentFactory(
category=self.category,
document_key='FAC09001-FWF-000-HSE-REP-0004',
metadata={
'title': 'HAZOP related 1',
},
revision={
'status': 'STD',
}
)
c = self.client
edit_url = doc.get_edit_url()
r = c.get(edit_url)
self.assertEqual(r.status_code, 200)
r = c.post(edit_url, {'document_number': doc.document_key})
self.assertEqual(r.status_code, 200)
self.assertEqual(r.context['form'].errors, {
'title': [required_error],
})
def test_command(self):
document = DocumentFactory(
category=self.category,
)
native_doc = 'sample_doc_native.docx'
pdf_doc = 'sample_doc_pdf.pdf'
MetadataRevisionFactory(
metadata=document.get_metadata(),
revision=2,
native_file=SimpleUploadedFile(native_doc, b'content'),
pdf_file=SimpleUploadedFile(pdf_doc, b'content'),
)
# Document without files
DocumentFactory(
category=self.category,
)
rev = document.get_latest_revision()
filepath = rev.pdf_file.path
# check file is on disk after doc deletion
document.delete()
self.assertTrue(os.path.exists(filepath))
call_command('clearmedia')
# command has deleted file
self.assertFalse(os.path.exists(filepath))
def test_updated_document_is_indexed(self, index_mock):
doc = DocumentFactory(
category=self.category,
document_key='FAC09001-FWF-000-HSE-REP-0004',
)
doc.title = 'foobar'
doc.save()
self.assertEqual(index_mock.call_count, 2)
def test_revised_document_is_indexed(self, index_mock):
doc = DocumentFactory(
category=self.category,
document_key='FAC09001-FWF-000-HSE-REP-0004',
)
revision = doc.latest_revision
revision.pk = None
revision.save()
doc.save()
self.assertEqual(index_mock.call_count, 2)
class PendingReviewsReminderTests(TestCase):
def setUp(self):
self.category = CategoryFactory()
self.user = UserFactory(
email='*****@*****.**',
password='******',
is_superuser=True,
category=self.category
)
self.client.login(email=self.user.email, password='******')
self.doc1 = DocumentFactory(
category=self.category,
revision={
'leader': self.user,
'received_date': datetime.date.today(),
}
)
self.doc2 = DocumentFactory(
category=self.category,
revision={
'leader': self.user,
'received_date': datetime.date.today(),
}
)
def test_empty_reminder_list(self):
call_command('send_review_reminders')
self.assertEqual(len(mail.outbox), 0)
def test_send_reminders(self):
self.doc1.get_latest_revision().start_review()
self.assertEqual(Review.objects.all().count(), 1)
call_command('send_review_reminders')
self.assertEqual(len(mail.outbox), 1)
def test_finished_reviews(self):
rev = self.doc1.get_latest_revision()
rev.start_review()
rev.end_review()
self.assertEqual(Review.objects.all().count(), 1)
call_command('send_review_reminders')
self.assertEqual(len(mail.outbox), 0)
def test_do_not_send_reminder(self):
"""Reminders are not send to users if their mail config says so."""
self.doc1.get_latest_revision().start_review()
self.assertEqual(Review.objects.all().count(), 1)
self.user.send_pending_reviews_mails = False
self.user.save()
call_command('send_review_reminders')
self.assertEqual(len(mail.outbox), 0)
def create_doc(self, nb_revisions=1):
doc = DocumentFactory(category=self.category)
meta = doc.get_metadata()
for rev in range(2, nb_revisions + 1):
MetadataRevisionFactory(
metadata=meta,
revision=rev
)
url = reverse('document_revision_delete', args=[
self.category.organisation.slug,
self.category.slug,
doc.document_key
])
return doc, url
def test_edition_redirect(self):
"""
Tests that a document edition is redirected to the item
or the list.
"""
doc = DocumentFactory(
category=self.category,
document_key='FAC09001-FWF-000-HSE-REP-0004',
metadata={
'title': u'HAZOP related 1',
},
revision={
'status': 'STD',
}
)
c = self.client
r = c.post(doc.get_edit_url(), {
'document_number': doc.document_key,
'title': u'a new title',
'docclass': 1,
'created_on': '2015-10-10',
'received_date': '2015-10-10',
'save-view': 'View',
}, follow=True)
self.assertEqual(
r.redirect_chain,
[('http://testserver{url}'.format(
url=doc.get_absolute_url(),
), 302)]
)
r = c.post(doc.get_edit_url(), {
'document_number': doc.document_key,
'title': u'a new new title',
'docclass': 1,
'created_on': '2015-10-10',
'received_date': '2015-10-10',
}, follow=True)
self.assertEqual(
r.redirect_chain,
[('http://testserver{url}'.format(
url=self.category.get_absolute_url(),
), 302)]
)
# Check that update was logged in audit trail
activity = Activity.objects.latest('created_on')
self.assertEqual(activity.verb, Activity.VERB_EDITED)
self.assertEqual(activity.target.title, u'a new new title')
self.assertEqual(activity.actor, self.user)
def test_document_related_documents(self):
documents = [
DocumentFactory(document_key=u'HAZOP-related-1'),
DocumentFactory(document_key=u'HAZOP-related-2'),
]
document = DocumentFactory(
document_key=u'HAZOP-report',
category=self.category)
document.metadata.related_documents = documents
document.metadata.save()
url = document.get_absolute_url()
res = self.client.get(url, follow=True)
self.assertContains(res, 'HAZOP-related-1')
self.assertContains(res, 'HAZOP-related-2')
def setUp(self):
super(UpdateDistribListTests, self).setUp()
self.user4 = UserFactory(
email='*****@*****.**',
password='******',
is_superuser=True,
category=self.category)
self.doc = DocumentFactory(
metadata_factory_class=ContractorDeliverableFactory,
revision_factory_class=ContractorDeliverableRevisionFactory,
category=self.category,
revision={
'reviewers': [self.user],
'leader': self.user2,
'approver': self.user3,
'received_date': datetime.datetime.today(),
})
self.rev = self.doc.get_latest_revision()
self.data.update({
'reviewers': str(self.user.id),
'leader': self.user2.id,
'approver': self.user3.id,
'review_start_date': datetime.datetime.today(),
'review_due_date': datetime.datetime.today() + datetime.timedelta(days=14)
})
def setUp(self):
self.category = CategoryFactory()
user = UserFactory(
email='*****@*****.**',
password='******',
is_superuser=True,
category=self.category)
self.client.login(email=user.email, password='******')
user2 = UserFactory(email='*****@*****.**', category=self.category)
doc = DocumentFactory(
document_key='hazop-report-1',
category=self.category,
revision={
'leader': user,
}
)
doc.latest_revision.start_review()
for _ in range(5):
for u in (user, user2):
NoteFactory(
author=u,
document=doc,
revision=1)
review_url = reverse('review_document', args=[doc.document_key])
self.url = '%s%s' % (self.live_server_url, review_url)
self.test_file = os.path.join(
os.path.dirname(__file__),
'casper_tests',
'tests.js'
)
def setUp(self):
self.category = CategoryFactory()
self.user = UserFactory(
email='*****@*****.**',
password='******',
is_superuser=True,
category=self.category
)
self.other_user = UserFactory(
email='*****@*****.**',
password='******',
)
self.client.login(email=self.user.email, password='******')
doc = DocumentFactory(
document_key='test_key',
category=self.category,
revision={
'reviewers': [],
'leader': self.user,
'received_date': datetime.date.today(),
}
)
revision = doc.latest_revision
revision.start_review()
self.review = revision.get_review(self.user)
self.url = self.review.get_comments_url()
pdf_doc = 'sample_doc_pdf.pdf'
self.sample_pdf = SimpleUploadedFile(pdf_doc, b'content')
def test_delete_document(self):
document = DocumentFactory(category=self.category)
document_str = str(document)
delete_url = reverse('document_delete',
args=[
self.category.organisation.slug,
self.category.slug, document.document_key
])
res = self.client.post(delete_url)
self.assertRedirects(res, self.category.get_absolute_url())
# Check that deletion was logged in audit trail
activity = Activity.objects.latest('created_on')
self.assertEqual(activity.verb, Activity.VERB_DELETED)
self.assertEqual(activity.action_object_str, document_str)
self.assertEqual(activity.actor, self.user)
res = self.client.post(delete_url)
self.assertEqual(res.status_code, 404)
metadata = DemoMetadata.objects.filter(document=document)
self.assertEqual(metadata.count(), 0)
revisions = DemoMetadataRevision.objects.filter(metadata=metadata)
self.assertEqual(revisions.count(), 0)
class PrivateMediaViewTests(TestCase):
def setUp(self):
self.category = CategoryFactory()
user = UserFactory(
email='*****@*****.**',
password='******',
is_superuser=True,
category=self.category)
self.client.login(email=user.email, password='******')
self.doc = DocumentFactory()
self.rev = self.doc.get_latest_revision()
pdf_doc = 'sample_doc_pdf.pdf'
self.sample_pdf = SimpleUploadedFile(pdf_doc, b'content')
def test_serve_wrong_field(self):
with self.assertRaises(Http404):
serve_model_file_field(self.rev, 'i_do_not_exist')
def test_serve_empty_field(self):
with self.assertRaises(Http404):
serve_model_file_field(self.rev, 'pdf_file')
def test_serve_file_field(self):
self.rev.pdf_file = self.sample_pdf
self.rev.save()
res = serve_model_file_field(self.rev, 'pdf_file')
self.assertTrue(isinstance(res, HttpResponse))
self.assertTrue('X-Accel-Redirect' in res)
def test_get_actions(self):
date = datetime.datetime(2013, 04, 20, 12, 0, 0, tzinfo=utc)
document = DocumentFactory(
document_key='FAC09001-FWF-000-HSE-REP-0004',
created_on=date,
current_revision_date=date,
metadata={
'title': 'HAZOP report',
},
revision={
'status': 'STD',
'revision_date': date,
'created_on': date,
'updated_on': date,
})
user = UserFactory()
metadata = document.metadata
metadata_revision = document.latest_revision
actions = metadata_revision.get_actions(metadata, user)
self.assertEqual(len(actions), 0)
change_doc_perm = Permission.objects.get(codename='change_document')
can_control_perm = Permission.objects.get(
codename='can_control_document')
user.user_permissions.add(change_doc_perm)
user.user_permissions.add(can_control_perm)
# Refresh object
user = User.objects.get(pk=user.pk)
actions = metadata_revision.get_actions(metadata, user)
# Actions must contain 4 MenuItem and 2 DividerMenuItem
self.assertEqual(len(actions), 6)
def setUp(self):
delete_index()
create_index()
self.category = CategoryFactory()
put_category_mapping(self.category.id)
user = UserFactory(email='*****@*****.**', password='******',
is_superuser=True,
category=self.category)
connect_signals()
for doc_id in range(20):
doc = DocumentFactory(
document_key='hazop-report-%d' % doc_id,
category=self.category,
)
index_document(doc.id)
# ES needs some time to finish indexing
time.sleep(1)
document_list_url = reverse('category_document_list', args=[
self.category.organisation.slug,
self.category.slug
])
self.url = '%s%s' % (self.live_server_url, document_list_url)
self.client.login(email=user.email, password='******')
self.test_file = os.path.join(
os.path.dirname(__file__),
'casper_tests',
'tests.js'
)
class DistributionListWidgetTests(CasperTestCase):
def setUp(self):
Model = ContentType.objects.get_for_model(ContractorDeliverable)
self.category = CategoryFactory(
category_template__metadata_model=Model)
self.user = UserFactory(email='*****@*****.**',
password='******',
is_superuser=True,
category=self.category)
self.client.login(email=self.user.email, password='******')
self.doc = DocumentFactory(
category=self.category,
metadata_factory_class=ContractorDeliverableFactory,
revision_factory_class=ContractorDeliverableRevisionFactory,
)
url = self.doc.get_edit_url()
self.url = '%s%s' % (self.live_server_url, url)
self.test_file = os.path.join(os.path.dirname(__file__),
'casper_tests', 'tests.js')
def test_select_distribution_list(self):
dl = DistributionListFactory(
categories=[self.category],
name='Team Cassoulet',
)
DistributionListFactory(categories=[self.category],
name='Team Oui Oui et ses potes')
self.assertTrue(
self.casper(
self.test_file,
url=self.url,
leader_id=dl.leader_id,
approver_id=dl.approver_id,
))
class PrivateMediaViewTests(TestCase):
def setUp(self):
self.category = CategoryFactory()
user = UserFactory(email='*****@*****.**',
password='******',
is_superuser=True,
category=self.category)
self.client.login(email=user.email, password='******')
self.doc = DocumentFactory()
self.rev = self.doc.get_latest_revision()
sample_path = b'documents/tests/'
pdf_doc = b'sample_doc_pdf.pdf'
self.sample_pdf = SimpleUploadedFile(pdf_doc, sample_path + pdf_doc)
def test_serve_wrong_field(self):
with self.assertRaises(Http404):
serve_model_file_field(self.rev, 'i_do_not_exist')
def test_serve_empty_field(self):
with self.assertRaises(Http404):
serve_model_file_field(self.rev, 'pdf_file')
def test_serve_file_field(self):
self.rev.pdf_file = self.sample_pdf
self.rev.save()
res = serve_model_file_field(self.rev, 'pdf_file')
self.assertTrue(isinstance(res, HttpResponse))
self.assertTrue('X-Accel-Redirect' in res)
def test_unique_document_download(self):
"""
Tests that a document download returns a zip file of the latest revision.
"""
sample_path = b'documents/tests/'
native_doc = b'sample_doc_native.docx'
pdf_doc = b'sample_doc_pdf.pdf'
document = DocumentFactory(
document_key=u'HAZOP-related',
category=self.category,
revision={
'native_file':
SimpleUploadedFile(native_doc, sample_path + native_doc),
'pdf_file':
SimpleUploadedFile(pdf_doc, sample_path + pdf_doc),
})
c = self.client
r = c.post(self.download_url, {
'document_ids': document.id,
'revisions': 'latest',
'format': 'both',
})
self.assertEqual(r.status_code, 200)
self.assertEqual(r._headers['vary'],
('Vary', 'Cookie, Accept-Encoding'))
self.assertEqual(r._headers['content-type'],
('Content-Type', 'application/zip'))
self.assertEqual(
r._headers['content-disposition'],
('Content-Disposition', 'attachment; filename=download.zip'))
def setUp(self):
self.category = CategoryFactory()
self.user = UserFactory(email='*****@*****.**',
password='******',
is_superuser=True,
category=self.category)
self.doc = DocumentFactory(document_key='HAZOP-related',
category=self.category)
def test_clearable_file_widget(self):
field = RevisionFileField()
doc = DocumentFactory()
file_field = FieldFile(doc, field, 'revisions/toto.pdf')
widget = PhaseClearableFileInput()
rendered = widget.render('toto.pdf', file_field)
self.assertTrue('>toto.pdf<' in rendered)
self.assertTrue('>revisions/toto.pdf<' not in rendered)
def setUp(self):
self.category = CategoryFactory()
self.user = UserFactory(email='*****@*****.**',
password='******',
is_superuser=True,
category=self.category)
self.client.login(email=self.user.email, password='******')
self.doc1 = DocumentFactory(category=self.category,
revision={
'leader': self.user,
'received_date': datetime.date.today(),
})
self.doc2 = DocumentFactory(category=self.category,
revision={
'leader': self.user,
'received_date': datetime.date.today(),
})
def test_many_documents(self):
res = self.client.get(self.url)
self.assertNotContains(res, 'document 2')
self.assertNotContains(res, 'document 3')
DocumentFactory(
title='document 2',
category=self.category,
)
DocumentFactory(
title='document 3',
category=self.category,
)
res = self.client.get(self.url)
self.assertContains(res, 'document 2')
self.assertContains(res, 'document 3')
def test_doc_without_leader_cannot_be_reviewed(self):
doc = DocumentFactory(category=self.category)
revision = doc.latest_revision
revision.approver = self.user
revision.reviewers = [self.user]
revision.save()
self.assertFalse(revision.can_be_reviewed)
def setUp(self):
Model = ContentType.objects.get_for_model(ContractorDeliverable)
self.category = CategoryFactory(
category_template__metadata_model=Model)
self.user = UserFactory(email='*****@*****.**',
password='******',
is_superuser=True,
category=self.category)
self.client.login(email=self.user.email, password='******')
self.doc = DocumentFactory(
category=self.category,
metadata_factory_class=ContractorDeliverableFactory,
revision_factory_class=ContractorDeliverableRevisionFactory,
)
url = self.doc.get_edit_url()
self.url = '%s%s' % (self.live_server_url, url)
self.test_file = os.path.join(os.path.dirname(__file__),
'casper_tests', 'tests.js')
def create_doc(self, **kwargs):
context = {
'category': self.category,
'metadata_factory_class': ContractorDeliverableFactory,
'revision_factory_class': ContractorDeliverableRevisionFactory,
}
context.update(kwargs)
doc = DocumentFactory(**context)
return doc
def create_reviewable_document(self):
doc = DocumentFactory(category=self.category,
revision={
'reviewers': [self.user2],
'leader': self.user,
'approver': self.user3,
'received_date': datetime.datetime.today(),
})
return doc.latest_revision
def test_delete_page_only_post(self):
document = DocumentFactory(category=self.category)
delete_url = reverse('document_delete',
args=[
self.category.organisation.slug,
self.category.slug, document.document_key
])
res = self.client.get(delete_url)
self.assertEqual(res.status_code, 405)
class StartReviewTests(TestCase):
def setUp(self):
self.category = CategoryFactory()
self.user = UserFactory(
email='*****@*****.**',
password='******',
is_superuser=True,
category=self.category
)
self.doc = DocumentFactory(
document_key='test_document',
category=self.category,
revision={
'leader': self.user,
'received_date': datetime.date.today(),
}
)
self.client.login(email=self.user.email, password='******')
self.start_review_url = reverse('document_start_review', args=[
self.category.organisation.slug,
self.category.slug,
'test_document'])
def test_start_review_with_remarks(self):
self.assertEqual(self.doc.note_set.all().count(), 0)
res = self.client.post(
self.start_review_url,
{'body': 'This is a notification!'},
follow=True)
self.assertEqual(res.status_code, 200)
self.assertEqual(self.doc.note_set.all().count(), 1)
activities = Activity.objects.all()
self.assertEqual(activities.count(), 1)
self.assertEqual(activities.get().verb, Activity.VERB_STARTED_REVIEW)
self.assertEqual(activities.get().action_object,
self.doc.get_latest_revision())
def test_start_review_with_empty_remark(self):
self.assertEqual(self.doc.note_set.all().count(), 0)
res = self.client.post(
self.start_review_url,
{'body': ''},
follow=True)
self.assertEqual(res.status_code, 200)
self.assertEqual(self.doc.note_set.all().count(), 0)
def test_start_review_with_no_remark(self):
self.assertEqual(self.doc.note_set.all().count(), 0)
res = self.client.post(self.start_review_url, follow=True)
self.assertEqual(res.status_code, 200)
self.assertEqual(self.doc.note_set.all().count(), 0)
def create_transmittal():
"""Create a test transmittal with a few documents linked."""
# Create documents
entity = EntityFactory()
CDModel = ContentType.objects.get_for_model(ContractorDeliverable)
deliverables_category = CategoryFactory(
category_template__metadata_model=CDModel,
third_parties=[entity])
data = {
'category': deliverables_category,
'revision': {
'return_code': 1
},
'metadata_factory_class': ContractorDeliverableFactory,
'revision_factory_class': ContractorDeliverableRevisionFactory,
}
revisions = []
for _ in range(10):
doc = DocumentFactory(**data)
revisions.append(doc.latest_revision)
# Create the actual transmittal
OutgoingTransmittalModel = ContentType.objects.get_for_model(
OutgoingTransmittal)
transmittal_category = CategoryFactory(
category_template__metadata_model=OutgoingTransmittalModel)
data = {
'category': transmittal_category,
'metadata': {
'revisions_category': deliverables_category,
'originator': 'CTR',
'recipient': entity,
'contract_number': 'FAC10005',
},
'metadata_factory_class': OutgoingTransmittalFactory,
'revision_factory_class': OutgoingTransmittalRevisionFactory,
}
doc = DocumentFactory(**data)
transmittal = doc.metadata
transmittal.link_to_revisions(revisions)
return transmittal
def setUp(self):
self.category = CategoryFactory()
user = UserFactory(
email='*****@*****.**',
password='******',
is_superuser=True,
category=self.category)
self.client.login(email=user.email, password='******')
self.doc = DocumentFactory()
self.rev = self.doc.get_latest_revision()
def test_do_not_resend_documents_at_rerun(mailoutbox, client_task):
region = baker.make_recipe("common.region")
buyer = baker.make_recipe("users.user", region=region)
order = baker.make_recipe("orders.order", region=region, buyer=buyer)
platform_user = baker.make_recipe("users.user", region=region)
baker.make_recipe(
"documents.order_confirmation",
buyer=DocumentFactory.as_dict(order.buyer),
seller=DocumentFactory.as_dict(platform_user),
order=order,
)
DocumentSendLog.objects.create(email=buyer.email, order=order, sent=True)
client_task.post(
reverse(
"mail-documents", kwargs={"order_id": order.id, "email": order.buyer.email}
),
)
assert not mailoutbox
def setUp(self):
Model = ContentType.objects.get_for_model(ContractorDeliverable)
self.category = CategoryFactory(category_template__metadata_model=Model)
self.docs = [
DocumentFactory(
metadata_factory_class=ContractorDeliverableFactory,
revision_factory_class=ContractorDeliverableRevisionFactory,
category=self.category)
for i in range(1, 20)]
self.revisions = [doc.get_latest_revision() for doc in self.docs]
def setUp(self):
self.category = CategoryFactory()
self.user = UserFactory(
email='*****@*****.**',
password='******',
is_superuser=True,
category=self.category
)
self.client.login(email=self.user.email, password='******')
self.url = reverse('batch_start_reviews', args=[
self.category.organisation.slug,
self.category.slug,
])
self.list_url = reverse('category_document_list', args=[
self.category.organisation.slug,
self.category.slug,
])
self.doc1 = DocumentFactory(
category=self.category,
revision={
'leader': self.user,
'received_date': datetime.date.today(),
}
)
self.doc2 = DocumentFactory(
category=self.category,
revision={
'leader': self.user,
'received_date': datetime.date.today(),
}
)
self.doc3 = DocumentFactory(
category=self.category,
revision={
'reviewers': [],
'leader': None,
'approver': None,
'received_date': datetime.date.today(),
}
)
self.ok = 'The review started for the following documents'
self.nok = "We failed to start the review for the following documents"
def setUp(self):
Model = ContentType.objects.get_for_model(ContractorDeliverable)
self.category = CategoryFactory(
category_template__metadata_model=Model)
self.docs = (DocumentFactory(
metadata_factory_class=ContractorDeliverableFactory,
revision_factory_class=ContractorDeliverableRevisionFactory,
category=self.category) for i in range(1, 20))
self.es_mock = MagicMock(
return_value=([doc.latest_revision.pk for doc in self.docs], 20))
def setUp(self):
self.category = CategoryFactory()
self.user1 = UserFactory(username='******', category=self.category)
self.user2 = UserFactory(username='******', category=self.category)
self.user3 = UserFactory(username='******',
category=self.category)
self.doc = DocumentFactory(revision={
'leader': self.user1,
})
self.revision = self.doc.latest_revision
self.revision.start_review()
def test_previous_step(self):
doc = DocumentFactory(
revision={
'reviewers': [self.other_user],
'leader': self.user,
'received_date': datetime.date.today(),
}
)
doc.latest_revision.start_review()
res = self.client.get(self.url)
self.assertContains(res, '<td class="columndocument_key"')
def setUp(self):
self.category = CategoryFactory()
self.user = UserFactory(email='*****@*****.**',
password='******',
is_superuser=True,
category=self.category)
self.client.login(email=self.user.email, password='******')
self.doc = DocumentFactory(category=self.category)
self.rev = self.doc.get_latest_revision()
pdf_doc = 'sample_doc_pdf.pdf'
self.sample_pdf = SimpleUploadedFile(pdf_doc, b'content')
self.url = reverse('revision_file_download',
args=[
self.category.organisation.slug,
self.category.slug,
self.doc.document_key,
self.rev.revision,
'pdf_file',
])
def test_cancel_review_count(self):
doc = DocumentFactory(revision={
'leader': self.user,
'received_date': datetime.date.today(),
})
doc.latest_revision.start_review()
doc = DocumentFactory(
revision={
'leader': self.other_user,
'approver': self.user,
'received_date': datetime.date.today(),
})
doc.latest_revision.start_review()
doc.latest_revision.cancel_review()
res = self.client.get(self.url)
self.assertContains(res, 'Reviewer (0)')
self.assertContains(res, 'Leader (1)')
self.assertContains(res, 'Approver (0)')
def test_edition_redirect(self):
"""
Tests that a document edition is redirected to the item
or the list.
"""
doc = DocumentFactory(category=self.category,
document_key='FAC09001-FWF-000-HSE-REP-0004',
metadata={
'title': u'HAZOP related 1',
},
revision={
'status': 'STD',
})
c = self.client
r = c.post(doc.get_edit_url(), {
'document_number': doc.document_key,
'title': u'a new title',
'docclass': 1,
'created_on': '2015-10-10',
'received_date': '2015-10-10',
'save-view': 'View',
},
follow=True)
self.assertEqual(r.redirect_chain, [('http://testserver{url}'.format(
url=doc.get_absolute_url(), ), 302)])
r = c.post(doc.get_edit_url(), {
'document_number': doc.document_key,
'title': u'a new new title',
'docclass': 1,
'created_on': '2015-10-10',
'received_date': '2015-10-10',
},
follow=True)
self.assertEqual(r.redirect_chain, [('http://testserver{url}'.format(
url=self.category.get_absolute_url(), ), 302)])
# Check that update was logged in audit trail
activity = Activity.objects.latest('created_on')
self.assertEqual(activity.verb, Activity.VERB_EDITED)
self.assertEqual(activity.target.title, u'a new new title')
self.assertEqual(activity.actor, self.user)
def test_signal(self):
doc = DocumentFactory()
user = UserFactory()
self.assertEqual(Activity.objects.count(), 0)
activity_log.send(verb=Activity.VERB_EDITED, target=doc, sender='self', actor=user)
latest_activity = Activity.objects.all().get()
self.assertEqual(latest_activity.verb, 'edited')
self.assertEqual(latest_activity.actor, user)
self.assertEqual(latest_activity.actor_object_str, str(user))
self.assertEqual(latest_activity.target, doc)
self.assertEqual(latest_activity.target_object_str, str(doc))
def setUp(self):
self.category = CategoryFactory()
self.user1 = UserFactory(email='*****@*****.**',
password='******',
is_superuser=True,
category=self.category)
self.client.login(email=self.user1.email, password='******')
self.doc = DocumentFactory(revision={
'leader': self.user1,
})
self.revision = self.doc.latest_revision
self.revision.start_review()
def setUp(self):
self.category = CategoryFactory()
user = UserFactory(
email='*****@*****.**',
password='******',
is_superuser=True,
category=self.category)
self.client.login(email=user.email, password='******')
self.doc = DocumentFactory()
self.rev = self.doc.get_latest_revision()
pdf_doc = 'sample_doc_pdf.pdf'
self.sample_pdf = SimpleUploadedFile(pdf_doc, b'content')
def create_lines(self, nb_existing=1, nb_new=1, **kwargs):
"""Create `nb_existing` + `nb_new` lines in the transmittal."""
doc = DocumentFactory(
metadata_factory_class=ContractorDeliverableFactory,
revision_factory_class=ContractorDeliverableRevisionFactory,
category=self.category)
rev = doc.get_latest_revision()
metadata = doc.metadata
arguments = {
'transmittal': self.transmittal,
'document': doc,
'document_key': doc.document_key,
'title': doc.title,
'is_new_revision': False,
'category': self.category,
'revision': rev.revision,
}
arguments.update(kwargs)
# Existing revisions
for i in range(nb_existing):
rev = ContractorDeliverableRevisionFactory(
metadata=metadata)
arguments.update({'revision': rev.revision})
TrsRevisionFactory(**arguments)
metadata.latest_revision = rev
metadata.save()
arguments.update({'is_new_revision': True})
# New revisions
for i in range(nb_new):
arguments.update({'revision': rev.revision + i + 1})
TrsRevisionFactory(**arguments)
return doc
class PrivateDownloadTests(TestCase):
def setUp(self):
self.category = CategoryFactory()
self.user = UserFactory(
email='*****@*****.**',
password='******',
is_superuser=True,
category=self.category)
self.client.login(email=self.user.email, password='******')
self.doc = DocumentFactory(category=self.category)
self.rev = self.doc.get_latest_revision()
sample_path = b'documents/tests/'
pdf_doc = b'sample_doc_pdf.pdf'
self.sample_pdf = SimpleUploadedFile(pdf_doc, sample_path + pdf_doc)
self.url = reverse('revision_file_download', args=[
self.category.organisation.slug,
self.category.slug,
self.doc.document_key,
self.rev.revision,
'pdf_file',
])
def test_download_empty_file(self):
res = self.client.get(self.url)
self.assertEqual(res.status_code, 404)
def test_download_file(self):
self.rev.pdf_file = self.sample_pdf
self.rev.save()
res = self.client.get(self.url)
self.assertEqual(res.status_code, 200)
def test_download_file_without_permissions(self):
self.user.categories.clear()
self.rev.pdf_file = self.sample_pdf
self.rev.save()
res = self.client.get(self.url)
self.assertEqual(res.status_code, 404)
def setUp(self):
self.category = CategoryFactory()
self.user = UserFactory(
email='*****@*****.**',
password='******',
is_superuser=True,
category=self.category)
self.client.login(email=self.user.email, password='******')
self.doc = DocumentFactory(category=self.category)
self.rev = self.doc.get_latest_revision()
pdf_doc = 'sample_doc_pdf.pdf'
self.sample_pdf = SimpleUploadedFile(pdf_doc, b'content')
self.url = reverse('revision_file_download', args=[
self.category.organisation.slug,
self.category.slug,
self.doc.document_key,
self.rev.revision,
'pdf_file',
])
def setUp(self):
self.category = CategoryFactory()
self.user = UserFactory(
email='*****@*****.**',
password='******',
is_superuser=True,
category=self.category
)
self.doc = DocumentFactory(
document_key='test_document',
category=self.category,
revision={
'leader': self.user,
'received_date': datetime.date.today(),
}
)
self.client.login(email=self.user.email, password='******')
self.start_review_url = reverse('document_start_review', args=[
self.category.organisation.slug,
self.category.slug,
'test_document'])
class CleanMediaTests(TestCase):
def setUp(self):
self.category = CategoryFactory()
user = UserFactory(
email='*****@*****.**',
password='******',
is_superuser=True,
category=self.category)
self.client.login(email=user.email, password='******')
self.doc = DocumentFactory()
self.rev = self.doc.get_latest_revision()
def test_command(self):
document = DocumentFactory(
category=self.category,
)
sample_path = b'documents/tests/'
native_doc = b'sample_doc_native.docx'
pdf_doc = b'sample_doc_pdf.pdf'
MetadataRevisionFactory(
metadata=document.get_metadata(),
revision=2,
native_file=SimpleUploadedFile(native_doc,
sample_path + native_doc),
pdf_file=SimpleUploadedFile(pdf_doc, sample_path + pdf_doc),
)
# Document without files
DocumentFactory(
category=self.category,
)
rev = document.get_latest_revision()
filepath = rev.pdf_file.path
# check file is on disk after doc deletion
document.delete()
self.assertTrue(os.path.exists(filepath))
call_command('clearmedia')
# command has deleted file
self.assertFalse(os.path.exists(filepath))
class DistributionListWidgetTests(CasperTestCase):
def setUp(self):
Model = ContentType.objects.get_for_model(ContractorDeliverable)
self.category = CategoryFactory(
category_template__metadata_model=Model)
self.user = UserFactory(
email='*****@*****.**',
password='******',
is_superuser=True,
category=self.category)
self.client.login(email=self.user.email, password='******')
self.doc = DocumentFactory(
category=self.category,
metadata_factory_class=ContractorDeliverableFactory,
revision_factory_class=ContractorDeliverableRevisionFactory,
)
url = self.doc.get_edit_url()
self.url = '%s%s' % (self.live_server_url, url)
self.test_file = os.path.join(
os.path.dirname(__file__),
'casper_tests',
'tests.js'
)
def test_select_distribution_list(self):
dl = DistributionListFactory(
categories=[self.category],
name='Team Cassoulet',
)
DistributionListFactory(
categories=[self.category],
name='Team Oui Oui et ses potes')
self.assertTrue(self.casper(
self.test_file,
url=self.url,
leader_id=dl.leader_id,
approver_id=dl.approver_id,
))
def setUp(self):
Model = ContentType.objects.get_for_model(ContractorDeliverable)
self.category = CategoryFactory(
category_template__metadata_model=Model)
self.user = UserFactory(
email='*****@*****.**',
password='******',
is_superuser=True,
category=self.category)
self.client.login(email=self.user.email, password='******')
self.doc = DocumentFactory(
category=self.category,
metadata_factory_class=ContractorDeliverableFactory,
revision_factory_class=ContractorDeliverableRevisionFactory,
)
url = self.doc.get_edit_url()
self.url = '%s%s' % (self.live_server_url, url)
self.test_file = os.path.join(
os.path.dirname(__file__),
'casper_tests',
'tests.js'
)
