def setUp(self):
# Clear the values list cache
cache.clear()
try:
document = Document.objects.get(
document_key='FAC10005-CTR-000-EXP-LAY-4891')
self.doc_category = document.category
except Document.DoesNotExist:
self.doc_category = CategoryFactory()
contract = ContractFactory.create(number='FAC10005-CTR-CLT-TRS-00001',
categories=[self.doc_category])
self.contract_number = contract.number
trs_content_type = ContentType.objects.get_for_model(Transmittal)
self.trs_category = CategoryFactory(
category_template__metadata_model=trs_content_type)
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)
self.config = {
'INCOMING_DIR': self.incoming,
'REJECTED_DIR': self.rejected,
'TO_BE_CHECKED_DIR': self.tobechecked,
'ACCEPTED_DIR': self.accepted,
'EMAIL_LIST': ['*****@*****.**'],
}
def test_updating_user_with_category_deletion(self):
"""Validation of required inlines.
When a user is updated, one can require category deletions. We MUST
make sure that there is always one category left.
"""
user = UserFactory()
category = CategoryFactory()
category.users.add(user)
category.save()
url = reverse('admin:accounts_user_change', args=[user.id])
data = {
'email': '*****@*****.**',
'name': 'Test',
'password1': 'password',
'password2': 'password',
'Category_users-INITIAL_FORMS': 1,
'Category_users-MAX_NUM_FORMS': 1000,
'Category_users-TOTAL_FORMS': 1,
'Category_users-0-DELETE': 1,
'Category_users-0-id': category.id,
'Category_users-0-user': user.id,
}
res = self.client.post(url, data)
self.assertContains(res, 'Please select at least one category')
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_updating_user_with_category_deletion(self):
"""Validation of required inlines.
When a user is updated, one can require category deletions. We MUST
make sure that there is always one category left.
"""
user = UserFactory()
category = CategoryFactory()
category.users.add(user)
category.save()
url = reverse('admin:accounts_user_change', args=[user.id])
data = {
'email': '*****@*****.**',
'name': 'Test',
'password1': 'password',
'password2': 'password',
'Category_users-INITIAL_FORMS': 1,
'Category_users-MAX_NUM_FORMS': 1000,
'Category_users-TOTAL_FORMS': 1,
'Category_users-0-DELETE': 1,
'Category_users-0-id': category.id,
'Category_users-0-user': user.id,
}
res = self.client.post(url, data)
self.assertContains(res, 'Please select at least one category')
def setUp(self):
# Login as admin so we won't be bothered by missing permissions
self.category = CategoryFactory()
self.download_url = self.category.get_download_url()
user = UserFactory(email='*****@*****.**',
password='******',
is_superuser=True,
category=self.category)
self.client.login(email=user.email, password='******')
self.maxDiff = None
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_list_url = self.category.get_absolute_url()
def test_get_category_list_from_name():
category_1 = CategoryFactory(name='Category 1')
category_2 = CategoryFactory(name='Category 2')
theme = ThemeFactory(name='Theme 1')
theme.categories.set([category_1, category_2])
category_list = get_category_list_from_name('Category 1')
assert len(category_list) == 1
category_list = get_category_list_from_name('Theme 1')
assert len(category_list) == 2
def setUp(self):
self.category = CategoryFactory()
self.user = UserFactory(
email='*****@*****.**',
password='******',
is_superuser=True,
category=self.category,
)
self.create_url = reverse('document_create',
args=[
self.category.organisation.slug,
self.category.slug,
])
self.client.login(email=self.user.email, password='******')
self.sample_path = join(settings.DJANGO_ROOT, 'documents', 'tests')
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):
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):
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.user2 = UserFactory(
email='*****@*****.**',
password='******',
is_superuser=True,
category=self.category)
self.user3 = UserFactory(
email='*****@*****.**',
password='******',
is_superuser=True,
category=self.category)
self.data = {
'docclass': 3,
'purpose_of_issue': 'FR',
'created_on': '2015-01-01',
'received_date': '2015-01-01'
}
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_create_trs_with_invalid_dest_category(self):
"""Destination category must contain outgoing transmittals."""
invalid_cat = CategoryFactory()
revisions = self.create_docs()
with self.assertRaises(errors.InvalidCategoryError):
create_transmittal(self.category, invalid_cat, revisions,
self.linked_contract.number, self.entity)
def test_create_trs_with_invalid_from_category(self):
"""Source category must contain transmittable documents."""
invalid_cat = CategoryFactory()
revisions = self.create_docs()
with self.assertRaises(errors.InvalidCategoryError):
create_transmittal(invalid_cat, self.dst_category, revisions,
self.linked_contract.number, self.entity)
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):
document = Document.objects.get(
document_key='FAC10005-CTR-000-EXP-LAY-4891')
self.doc_category = document.category
trs_content_type = ContentType.objects.get_for_model(Transmittal)
self.trs_category = CategoryFactory(
category_template__metadata_model=trs_content_type)
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)
self.config = {
'INCOMING_DIR': self.incoming,
'REJECTED_DIR': self.rejected,
'TO_BE_CHECKED_DIR': self.tobechecked,
'ACCEPTED_DIR': self.accepted,
'EMAIL_LIST': ['*****@*****.**'],
}
def setUp(self):
self.trs_import = TrsImport(
trs_dir='/tmp/dummy_dir/FAC10005-CTR-CLT-TRS-00001',
tobechecked_dir='/tmp/dummy_dir',
accepted_dir='/tmp/dummy_dir',
rejected_dir='/tmp/dummy_dir',
email_list=['*****@*****.**', '*****@*****.**'],
contractor='dummy_dir',
doc_category=CategoryFactory(),
trs_category=CategoryFactory(),
)
self.trs_import._errors = {
'error1': 'This is error 1',
'error2': 'This is error 2',
}
self.report = ErrorReport(self.trs_import)
def test_otg_creation(self):
ct = ContentType.objects.get_for_model(OutgoingTransmittal)
cat_template = CategoryTemplateFactory(
metadata_model=ct)
dest_cat = CategoryFactory(category_template=cat_template)
ctr1 = EntityFactory(type='contractor')
ctr2 = EntityFactory(type='contractor')
# We have to link third parties to categories
self.category.third_parties.add(ctr1, ctr2)
dest_cat.third_parties.add(ctr1, ctr2)
recipients_ids = [ctr1.pk, ctr2.pk]
document_ids = [doc.pk for doc in self.docs]
do_create_transmittal.delay(
self.user.id,
self.category.id,
dest_cat.id,
document_ids,
self.contract.number,
recipients_ids
)
# We have 2 docs and 2 recipients, so we expect 2 outgoing trs
# and 2 notifications
self.assertEqual(OutgoingTransmittal.objects.count(), 2)
self.assertEqual(Notification.objects.count(), 2)
# Check each doc revision links to both transmittals
for rev in self.revisions:
self.assertEqual(rev.transmittals.count(), 2)
def test_wrong_category_error(self):
trs_import = self.prepare_fixtures('single_correct_trs',
'FAC10005-CTR-CLT-TRS-00001')
trs_import.doc_category = CategoryFactory()
self.assertTrue(
'wrong_category' in trs_import.errors['csv_content'][2])
def test_log_aid_search_event(perimeters):
theme_1 = ThemeFactory(name='Nature environnement risques')
theme_2 = ThemeFactory(name='Developpement economique')
category_1 = CategoryFactory(name='economie circulaire')
request_get_urlencoded = (
"drafts=True&call_for_projects_only=False"
"&targeted_audiences=department"
f"&perimeter={perimeters['montpellier'].id_slug}"
f"&themes={theme_1.slug}&themes={theme_2.slug}"
f"&categories={category_1.slug}&categories=&apply_before=")
results_count = 15
host = "francemobilites.aides-territoires.beta.gouv.fr"
log_aidsearchevent(
querystring=request_get_urlencoded,
results_count=results_count,
source=host)
event = AidSearchEvent.objects.last()
assert len(event.targeted_audiences) == 1
assert event.targeted_audiences[0] == Aid.AUDIENCES.department
assert event.perimeter == perimeters['montpellier']
assert event.themes.count() == 2
assert event.results_count == results_count
assert event.source == 'francemobilites'
def setUp(self):
self.category = CategoryFactory()
self.user = UserFactory(name='User',
password='******',
is_superuser=True,
category=self.category)
self.client.login(username=self.user.email, password='******')
def category(self, create, extracted, **kwargs):
if not create:
return
if extracted:
extracted.users.add(self)
else:
category = CategoryFactory()
category.users.add(self)
def setUp(self):
self.category = CategoryFactory()
user = UserFactory(email='*****@*****.**',
password='******',
is_superuser=True,
category=self.category)
self.client.login(email=user.email, password='******')
self.url = reverse('transmittal_list')
def test_get(self):
category = CategoryFactory(name="test")
api = reverse(f"{self.api_basename}-list")
response = self.client.get(api)
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(len(response.data["results"]), 1)
self.assertEqual(response.data["results"][0]["name"], category.name)
self.assertEqual(response.data["results"][0]["slug"], category.slug)
def test_retrieve(self):
category = CategoryFactory(name="test")
api = reverse(f"{self.api_basename}-detail",
kwargs={"pk": category.id})
response = self.client.get(api, format="json")
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(response.data['name'], category.name)
self.assertEqual(response.data['slug'], category.slug)
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 setUp(self):
self.category = CategoryFactory()
self.user = UserFactory(email='*****@*****.**',
password='******',
is_superuser=True,
category=self.category)
self.client.login(email=self.user.email, password='******')
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 _ in range(1, 3)
]
self.revisions = [doc.get_latest_revision() for doc in self.docs]
self.contract = ContractFactory.create(categories=[self.category])
def setUp(self):
Model = ContentType.objects.get_for_model(ContractorDeliverable)
self.category = CategoryFactory(
category_template__metadata_model=Model)
self.users = [
UserFactory(email='*****@*****.**' % user,
password='******',
category=self.category) for user in range(1, 5)
]
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 setUp(self):
# Login as admin so we won't be bothered by missing permissions
self.category = CategoryFactory()
self.download_url = self.category.get_download_url()
user = UserFactory(email='*****@*****.**', password='******',
is_superuser=True,
category=self.category)
self.client.login(email=user.email, password='******')
self.maxDiff = None
def setUp(self):
self.category = CategoryFactory()
user = UserFactory(
email='*****@*****.**',
password='******',
is_superuser=True,
category=self.category,
)
self.client.login(email=user.email, password='******')
def test_categories_filter_overriding(client, settings):
categories = [
CategoryFactory(name='Category 1'),
CategoryFactory(name='Category 2'),
CategoryFactory(name='Category 3'),
CategoryFactory(name='Category 4'),
CategoryFactory(name='Category 5'),
]
# We create a minisite with all categories pre-filter
page = MinisiteFactory(title='Gloubiboulga page',
search_querystring='text=fromage')
page.available_categories.set(categories)
page_url = reverse('search_view')
page_host = '{}.aides-territoires'.format(page.slug)
settings.ALLOWED_HOSTS = [page_host]
# All categories appear in the form
res = client.get(page_url, HTTP_HOST=page_host)
assert res.status_code == 200
content = res.content.decode()
assert '<option value="category-1"' in content
assert '<option value="category-2"' in content
assert '<option value="category-3"' in content
assert '<option value="category-4"' in content
assert '<option value="category-5"' in content
# We create a minisite with a category pre-filter
page = MinisiteFactory(title='Gloubiboulga page 2',
search_querystring='text=fromage')
page.available_categories.set(categories[:2])
page_url = reverse('search_view')
page_host = '{}.aides-territoires'.format(page.slug)
settings.ALLOWED_HOSTS = [page_host]
# Only the available categories appear in the form
res = client.get(page_url, HTTP_HOST=page_host)
assert res.status_code == 200
content = res.content.decode()
assert '<option value="category-1"' in content
assert '<option value="category-2"' in content
assert '<option value="category-3"' not in content
assert '<option value="category-4"' not in content
assert '<option value="category-5"' not in content
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_list_url = self.category.get_absolute_url()
def setUp(self):
self.category = CategoryFactory()
self.user = UserFactory(
email='*****@*****.**',
password='******',
is_superuser=True,
category=self.category,
)
self.create_url = reverse('document_create', args=[
self.category.organisation.slug,
self.category.slug,
])
self.client.login(email=self.user.email, password='******')
self.sample_path = join(settings.DJANGO_ROOT, 'documents', 'tests')
class DocumentDeleteTests(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_list_url = self.category.get_absolute_url()
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)
def test_delete_document(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.post(delete_url)
self.assertRedirects(res, self.category.get_absolute_url())
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(document=document)
self.assertEqual(revisions.count(), 0)
def test_cannot_revise_document_in_review(self):
document = DocumentFactory(
category=self.category,
document_key='FAC09001-FWF-000-HSE-REP-0004',
revision={
'status': 'STD',
'review_start_date': '2014-04-04'
}
)
delete_url = reverse('document_delete', args=[
self.category.organisation.slug,
self.category.slug,
document.document_key
])
revision = document.latest_revision
self.assertTrue(revision.is_under_review)
res = self.client.post(delete_url)
self.assertEqual(res.status_code, 403)
try:
document = Document.objects.get(document_key=document.document_key)
except:
self.fail('Document was deleted')
def test_simple_user_cannot_delete_document(self):
user = UserFactory(
email='*****@*****.**',
password='******',
is_superuser=False,
category=self.category,
)
self.client.login(email=user.email, password='******')
document = DocumentFactory(category=self.category)
delete_url = reverse('document_delete', args=[
self.category.organisation.slug,
self.category.slug,
document.document_key
])
res = self.client.post(delete_url)
self.assertEqual(res.status_code, 403)
class DocumentCreateTest(TestCase):
def setUp(self):
self.category = CategoryFactory()
self.user = UserFactory(
email='*****@*****.**',
password='******',
is_superuser=True,
category=self.category,
)
self.create_url = reverse('document_create', args=[
self.category.organisation.slug,
self.category.slug,
])
self.client.login(email=self.user.email, password='******')
self.sample_path = join(settings.DJANGO_ROOT, 'documents', 'tests')
def tearDown(self):
"""Wipe the media root directory after each test."""
media_root = settings.MEDIA_ROOT
if os.path.exists(media_root):
for f in os.listdir(media_root):
file_path = os.path.join(media_root, f)
if os.path.isfile(file_path) and file_path.startswith('/tmp/'):
os.unlink(file_path)
def test_creation_errors(self):
"""
Tests that a document can't be created without required fields.
"""
required_error = 'This field is required.'
c = self.client
r = c.get(self.create_url)
self.assertEqual(r.status_code, 200)
r = c.post(self.create_url, {})
self.assertEqual(r.status_code, 200)
self.assertEqual(r.context['form'].errors, {
'title': [required_error],
})
def test_creation_errors_with_files(self):
"""
Tests that a document can't be created with wrong files.
"""
extension_error = 'A PDF file is not allowed in this field.'
c = self.client
with open(join(self.sample_path, 'sample_doc_native.docx'), mode='rb') as native_file:
with open(join(self.sample_path, 'sample_doc_pdf.pdf'), mode='rb') as pdf_file:
r = c.post(self.create_url, {
'title': 'a title',
'native_file': pdf_file,
'pdf_file': native_file,
'docclass': 1,
'created_on': '2015-10-10',
'received_date': '2015-10-10',
})
self.assertEqual(r.status_code, 200)
self.assertEqual(r.context['revision_form'].errors, {
'native_file': [extension_error],
})
def test_creation_success(self):
"""
Tests that a document can be created with required fields.
"""
original_number_of_document = Document.objects.all().count()
c = self.client
r = c.post(self.create_url, {
'title': 'a 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_creation_with_empty_document_key(self):
"""
Tests that a document can be created with required fields.
"""
c = self.client
doc_title = 'a glorious title'
c.post(self.create_url, {
'title': doc_title,
'docclass': 1,
'created_on': '2015-10-10',
'received_date': '2015-10-10',
}, follow=True)
doc = Document.objects.all().order_by('-id')[0]
self.assertEqual(doc.document_number, 'a-glorious-title')
self.assertEqual(doc.document_key, 'a-glorious-title')
self.assertIsNotNone(doc.created_by)
# Check that creation was logged in audit trail
activity = Activity.objects.latest('created_on')
self.assertEqual(activity.verb, Activity.VERB_CREATED)
self.assertEqual(activity.action_object.title, doc_title)
self.assertEqual(activity.actor, self.user)
def test_create_with_document_key(self):
c = self.client
doc_title = 'another title'
c.post(self.create_url, {
'title': doc_title,
'document_number': 'Gloubi Boulga',
'docclass': 1,
'created_on': '2015-10-10',
'received_date': '2015-10-10',
}, follow=True)
doc = Document.objects.all().order_by('-id')[0]
self.assertEqual(doc.document_number, 'Gloubi Boulga')
self.assertEqual(doc.document_key, 'GLOUBI-BOULGA')
# Check audit trail
activity = Activity.objects.latest('created_on')
self.assertEqual(activity.verb, Activity.VERB_CREATED)
self.assertEqual(activity.action_object.title, doc_title)
self.assertEqual(activity.actor, self.user)
def test_creation_success_with_files(self):
"""
Tests that a document can be created with files.
"""
original_number_of_document = Document.objects.all().count()
c = self.client
with open(join(self.sample_path, 'sample_doc_native.docx'), mode='rb') as native_file:
with open(join(self.sample_path, 'sample_doc_pdf.pdf'), mode='rb') as pdf_file:
r = c.post(self.create_url, {
'title': 'a title',
'native_file': native_file,
'pdf_file': pdf_file,
})
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_creation_redirect(self):
"""
Tests that a document creation is redirected to the item
or another creation form (django-admin like).
"""
c = self.client
r = c.post(self.create_url, {
'title': 'a title',
'docclass': 1,
'created_on': '2015-10-10',
'received_date': '2015-10-10',
'save-create': None,
}, follow=True)
self.assertEqual(r.redirect_chain, [(self.create_url, 302)])
r = c.post(self.create_url, {
'title': 'another title',
'docclass': 1,
'created_on': '2015-10-10',
'received_date': '2015-10-10',
}, follow=True)
self.assertEqual(r.redirect_chain, [
(self.category.get_absolute_url(), 302)]
)
def test_document_related_documents(self):
c = self.client
related = [
DocumentFactory(
category=self.category,
document_key='FAC09001-FWF-000-HSE-REP-0004',
metadata={
'title': 'HAZOP related 1',
},
revision={
'status': 'STD',
}
),
DocumentFactory(
category=self.category,
document_key='FAC09001-FWF-000-HSE-REP-0005',
metadata={
'title': 'HAZOP related 2',
},
revision={
'status': 'STD',
}
)
]
c.post(self.create_url, {
'document_number': 'FAC09001-FWF-000-HSE-REP-0006',
'title': 'HAZOP report',
'docclass': 1,
'created_on': '2015-10-10',
'received_date': '2015-10-10',
'related_documents': [doc.pk for doc in related]
})
document = Document.objects.get(
document_key='FAC09001-FWF-000-HSE-REP-0006')
metadata = document.metadata
related = list(metadata.related_documents.all())
self.assertEqual(len(related), 2)
related_titles = (related[0].metadata.title, related[1].metadata.title)
self.assertTrue("HAZOP related 1" in related_titles)
self.assertTrue("HAZOP related 2" in related_titles)
class DocumentDeleteTests(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_list_url = self.category.get_absolute_url()
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)
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_cannot_revise_document_in_review(self):
document = DocumentFactory(
category=self.category,
document_key='FAC09001-FWF-000-HSE-REP-0004',
revision={
'status': 'STD',
'review_start_date': '2014-04-04'
}
)
delete_url = reverse('document_delete', args=[
self.category.organisation.slug,
self.category.slug,
document.document_key
])
revision = document.latest_revision
self.assertTrue(revision.is_under_review)
res = self.client.post(delete_url)
self.assertEqual(res.status_code, 403)
try:
document = Document.objects.get(document_key=document.document_key)
except:
self.fail('Document was deleted')
def test_simple_user_cannot_delete_document(self):
user = UserFactory(
email='*****@*****.**',
password='******',
is_superuser=False,
category=self.category,
)
self.client.login(email=user.email, password='******')
document = DocumentFactory(category=self.category)
delete_url = reverse('document_delete', args=[
self.category.organisation.slug,
self.category.slug,
document.document_key
])
res = self.client.post(delete_url)
self.assertEqual(res.status_code, 403)
def test_user_with_delete_perms_can_delete_document(self):
user = UserFactory(
email='*****@*****.**',
password='******',
is_superuser=False,
category=self.category,
)
delete_doc_perm = Permission.objects.get(
codename='delete_document')
user.user_permissions.add(delete_doc_perm)
self.client.login(email=user.email, password='******')
document = DocumentFactory(category=self.category)
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())
self.assertFalse(Document.objects.filter(pk=document.pk).exists())
class DocumentEditTest(TestCase):
def setUp(self):
self.category = CategoryFactory()
self.user = UserFactory(
email='*****@*****.**',
password='******',
is_superuser=True,
category=self.category,
)
self.create_url = reverse('document_create', args=[
self.category.organisation.slug,
self.category.slug,
])
self.client.login(email=self.user.email, password='******')
self.sample_path = join(settings.DJANGO_ROOT, 'documents', 'tests')
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_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_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': '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',
'docclass': 1,
'created_on': '2015-10-10',
'received_date': '2015-10-10',
'save-view': 'View',
}, follow=True)
self.assertEqual(r.redirect_chain, [(doc.get_absolute_url(), 302)])
r = c.post(doc.get_edit_url(), {
'document_number': doc.document_key,
'title': 'a new new title',
'docclass': 1,
'created_on': '2015-10-10',
'received_date': '2015-10-10',
}, follow=True)
self.assertEqual(r.redirect_chain, [
(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, 'a new new title')
self.assertEqual(activity.actor, self.user)
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')
class DocumentRevisionDeleteTests(TestCase):
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 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_list_url = self.category.get_absolute_url()
def test_delete_page_only_accepts_post_requests(self):
doc, url = self.create_doc()
res = self.client.get(url)
self.assertEqual(res.status_code, 405)
def test_delete_single_revision_is_not_allowed(self):
"""Latest revision cannot be delete if this is the only revision."""
doc, url = self.create_doc()
res = self.client.post(url)
self.assertEqual(res.status_code, 403)
def test_cannot_delete_revision_in_review(self):
doc, url = self.create_doc(nb_revisions=5)
rev = doc.get_latest_revision()
rev.leader = self.user
rev.start_review()
self.assertTrue(rev.is_under_review)
res = self.client.post(url)
self.assertEqual(res.status_code, 403)
def test_delete_latest_revision(self):
doc, url = self.create_doc(nb_revisions=5)
doc.refresh_from_db()
self.assertEqual(doc.get_all_revisions().count(), 5)
self.assertEqual(doc.current_revision, 5)
self.client.post(url)
doc.refresh_from_db()
self.assertEqual(doc.get_all_revisions().count(), 4)
self.assertEqual(doc.current_revision, 4)
self.client.post(url)
doc.refresh_from_db()
self.assertEqual(doc.get_all_revisions().count(), 3)
self.assertEqual(doc.current_revision, 3)
def test_simple_user_cannot_delete_revision(self):
doc, delete_url = self.create_doc(nb_revisions=2)
self.assertEqual(doc.get_all_revisions().count(), 2)
# User has not delete perms
user = UserFactory(
email='*****@*****.**',
password='******',
is_superuser=False,
category=self.category,
)
self.client.logout()
self.client.login(email=user.email, password='******')
res = self.client.post(delete_url)
self.assertEqual(res.status_code, 403)
doc.refresh_from_db()
self.assertEqual(doc.get_all_revisions().count(), 2)
def test_user_with_delete_perms_can_delete_revision(self):
doc, delete_url = self.create_doc(nb_revisions=2)
self.assertEqual(doc.get_all_revisions().count(), 2)
user = UserFactory(
email='*****@*****.**',
password='******',
is_superuser=False,
category=self.category,
)
delete_doc_perm = Permission.objects.get(
codename='delete_document')
user.user_permissions.add(delete_doc_perm)
self.client.logout()
self.client.login(email=user.email, password='******')
self.client.post(delete_url)
doc.refresh_from_db()
self.assertEqual(doc.get_all_revisions().count(), 1)
class DocumentDownloadTest(TestCase):
def setUp(self):
# Login as admin so we won't be bothered by missing permissions
self.category = CategoryFactory()
self.download_url = self.category.get_download_url()
user = UserFactory(email='*****@*****.**', password='******',
is_superuser=True,
category=self.category)
self.client.login(email=user.email, password='******')
self.maxDiff = None
def tearDown(self):
"""Wipe the media root directory after each test."""
media_root = settings.MEDIA_ROOT
if os.path.exists(media_root):
for f in os.listdir(media_root):
file_path = os.path.join(media_root, f)
if os.path.isfile(file_path) and file_path.startswith('/tmp/'):
os.unlink(file_path)
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_empty_document_download(self):
"""
Tests that a document download returns an empty zip file.
"""
document = DocumentFactory(
document_key=u'HAZOP-related',
category=self.category,
)
r = self.client.post(self.download_url, {
'document_ids': [document.id],
'revisions': 'latest',
'format': 'both',
})
self.assertEqual(r.status_code, 200)
self.assertEqual(r._headers, {
'content-length': ('Content-Length', '22'),
'content-type': ('Content-Type', 'application/zip'),
'vary': ('Vary', 'Cookie'),
'content-disposition': (
'Content-Disposition',
'attachment; filename=download.zip'
)
})
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)
