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 test_create_error(self):
url = reverse('meetings:create',
kwargs={'url': get_current_account(self).url})
agenda = DocumentFactory(user=self.admin, type=Document.AGENDA)
minutes = DocumentFactory(user=self.admin, type=Document.MINUTES)
other_docs = DocumentFactory(user=self.admin, type=Document.OTHER)
docs = '{},{},{}'.format(agenda.id, minutes.id, other_docs.id)
date = timezone.now() + timedelta(days=2)
data = {
'date': date.date().strftime("%b %d, %Y"),
'time_start': date.time().strftime("%I:%M %p"),
'time_end':
(date + timedelta(hours=3)).time().strftime("%I:%M %p"),
'location': '709 Sixth Street, Newark, DE 19711',
'committee': self.membership.committees.all()[0].id,
'account': get_current_account(self),
'uploaded': docs,
'description': 'Any description',
'repeat_end_type': 'never',
'action': 'publish',
}
response = self.client.post(url, data, follow=True)
self.assertEqual(response.status_code, 200)
self.assertEqual(response.context['form'].errors['name'][0],
_('This field is required.'))
self.assertIn('other_docs', response.context)
self.assertIn('doc_agenda', response.context)
self.assertIn('doc_minutes', response.context)
def setUp(self):
super().setUp()
Model = ContentType.objects.get_for_model(ContractorDeliverable)
self.cat1 = CategoryFactory(category_template__metadata_model=Model)
self.cat2 = CategoryFactory(category_template__metadata_model=Model)
self.user1 = UserFactory(
email='*****@*****.**',
password='******',
is_superuser=True,
category=self.cat1,
send_behind_schedule_alert_mails=True)
self.user1.categories.add(self.cat2)
self.user2 = UserFactory(
email='*****@*****.**',
password='******',
is_superuser=True,
category=self.cat2,
send_behind_schedule_alert_mails=True)
self.doc1 = DocumentFactory(
category=self.cat1,
metadata_factory_class=ContractorDeliverableFactory,
revision_factory_class=ContractorDeliverableRevisionFactory)
self.doc2 = DocumentFactory(
category=self.cat2,
metadata_factory_class=ContractorDeliverableFactory,
revision_factory_class=ContractorDeliverableRevisionFactory)
populate_values_list_cache()
def test_dashboard_recent_save_meeting_create_without_notify(self):
self.login_admin()
self.account.send_notification = False
self.account.save()
self.client.get(
reverse('meetings:create', kwargs={'url': self.account.url}))
agenda = DocumentFactory(user=self.admin, type=Document.AGENDA)
minutes = DocumentFactory(user=self.admin, type=Document.MINUTES)
other_docs = DocumentFactory(user=self.admin, type=Document.OTHER)
docs = '{},{},{}'.format(agenda.id, minutes.id, other_docs.id)
date = timezone.now() + timedelta(days=2)
data = {
'name': lorem_ipsum.words(2, False).capitalize()[:50],
'date': date.date().strftime("%b. %d, %Y"),
'time_start': date.time().strftime("%I:%M %p"),
'time_end':
(date + timedelta(hours=3)).time().strftime("%I:%M %p"),
'location': '709 Sixth Street, Newark, DE 19711',
'committee': self.committee.id,
'account': self.account,
'uploaded': docs
}
resp = self.client.post(reverse('meetings:create',
kwargs={'url': self.account.url}),
data,
follow=True)
self.assertContains(resp, 'Meeting was added successfully.')
self.assertTrue(len(RecentActivity.objects.all()) > 0)
for item in RecentActivity.objects.all():
self.assertEqual(item.content_object.name, data['name'])
self.assertEqual(len(mail.outbox), 0)
def test_review_step_count(self):
doc = DocumentFactory(
revision={
'reviewers': [self.user],
'leader': self.other_user,
'received_date': datetime.date.today(),
})
doc.latest_revision.start_review()
doc = DocumentFactory(
revision={
'reviewers': [self.user],
'leader': self.other_user,
'received_date': datetime.date.today(),
})
doc.latest_revision.start_review()
doc = DocumentFactory(revision={
'leader': self.user,
'received_date': datetime.date.today(),
})
doc.latest_revision.start_review()
res = self.client.get(self.url)
self.assertContains(res, 'Reviewer (2)')
self.assertContains(res, 'Leader (1)')
self.assertContains(res, 'Approver (0)')
def test_create(self):
# TODO: Add Board Book testing once
url = reverse('meetings:create',
kwargs={'url': get_current_account(self).url})
agenda = DocumentFactory(user=self.admin, type=Document.AGENDA)
minutes = DocumentFactory(user=self.admin, type=Document.MINUTES)
other_docs = DocumentFactory(user=self.admin, type=Document.OTHER)
docs = '{},{},{}'.format(agenda.id, minutes.id, other_docs.id)
date = timezone.now() + timedelta(days=2)
data = {
'name': lorem_ipsum.words(2, False).capitalize()[:50],
'description': 'Any description',
'date': date.date().strftime("%b. %d, %Y"),
'time_start': date.time().strftime("%I:%M %p"),
'time_end':
(date + timedelta(hours=3)).time().strftime("%I:%M %p"),
'location': '709 Sixth Street, Newark, DE 19711',
'committee': self.membership.committees.all()[0].id,
'account': get_current_account(self),
'uploaded': docs,
'repeat_end_type': 'never',
'action': 'publish',
}
response = self.client.post(url, data, follow=True)
self.assertNoFormErrors(response)
meeting = Meeting.objects.all().order_by('-pk')[0]
self.assertEqual(response.status_code, 200)
self.assertContains(response, 'Meeting was added successfully.')
self.assertEqual(meeting.name, data['name'])
self.assertContains(response, '709 Sixth Street, Newark, DE 19711')
# All Board Members Meeting
data['committee'] = ''
response = self.client.post(url, data, follow=True)
self.assertEqual(response.status_code, 200)
self.assertContains(response, 'All Board Members Meeting')
# No Agenda Available
data['uploaded'] = '{},{}'.format(minutes.id, other_docs.id)
response = self.client.post(url, data, follow=True)
meeting = Meeting.objects.all().order_by('-pk')[0]
self.assertEqual(response.status_code, 200)
self.assertIsNone(meeting.get_agenda())
# No Minutes Available
data['uploaded'] = '{},{}'.format(agenda.id, other_docs.id)
response = self.client.post(url, data, follow=True)
meeting = Meeting.objects.all().order_by('-pk')[0]
self.assertEqual(response.status_code, 200)
self.assertIsNone(meeting.get_minutes())
# No Other Docs Available
data['uploaded'] = '{},{}'.format(agenda.id, minutes.id)
response = self.client.post(url, data, follow=True)
meeting = Meeting.objects.all().order_by('-pk')[0]
self.assertEqual(response.status_code, 200)
self.assertIsNone(meeting.get_other_docs())
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 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)
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_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):
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 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 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_updates_document_key(self):
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
c.post(doc.get_edit_url(), {
'document_number': 'New Document Number',
'title': u'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 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 test_jsonification(self):
"""Tests that a jsonified document returns the appropriate values."""
date = datetime.datetime(2013, 4, 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 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'
)
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 create_leader_only_document(self):
doc = DocumentFactory(category=self.category,
revision={
'leader': self.user,
'received_date': datetime.datetime.today(),
})
return doc.latest_revision
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 test_days_of_delay(self):
doc = DocumentFactory(category=self.category)
revision = doc.latest_revision
revision.leader = self.user
revision.save()
revision.start_review()
review = revision.get_leader_review()
today = timezone.now().date()
tomorrow = today + datetime.timedelta(days=1)
yesterday = today + datetime.timedelta(days=-1)
# Review is ongoing, due date in the future
review.due_date = tomorrow
self.assertEqual(review.days_of_delay(), -1)
# Review is ongoing, due date today
review.due_date = today
self.assertEqual(review.days_of_delay(), 0)
# Review is ongoing, overdue
review.due_date = yesterday
self.assertEqual(review.days_of_delay(), 1)
# Review is over, completed on time
review.due_date = today
review.closed_on = yesterday
self.assertEqual(review.days_of_delay(), -1)
# Review is over, overdue
review.closed_on = tomorrow
self.assertEqual(review.days_of_delay(), 1)
def test_is_overdue(self):
doc = DocumentFactory(category=self.category)
revision = doc.latest_revision
revision.leader = self.user
revision.save()
# Review has not started yet
self.assertFalse(revision.is_overdue())
# Due date is in the future
revision.start_review()
today = timezone.now().date()
revision.review_due_date = today + datetime.timedelta(days=1)
self.assertFalse(revision.is_overdue())
# Due date is today
revision.review_due_date = today
self.assertFalse(revision.is_overdue())
# Due date is in the past
revision.review_due_date = today - datetime.timedelta(days=1)
self.assertTrue(revision.is_overdue())
# Review has ended
revision.review_due_date = today - datetime.timedelta(days=1)
revision.end_review()
self.assertFalse(revision.is_overdue())
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 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_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 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()
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 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
