def setUp(self):
UserRequestFactory(
expiry=date.today(),
)
self.userrequest = UserRequestFactory(
expiry=date.today() + timedelta(days=2),
)
UserRequestFactory(
expiry=date.today() + timedelta(days=3),
)
self.handler_settings = {
'model': 'terracommon.trrequests.models.UserRequest',
'query': {
'expiry': 'date.today() + timedelta(days=2)',
},
'actions': [
{'action': 'USERREQUEST_IMPENDING_EXPIRY',
'kwargs': {
'user': '******',
}, },
{'action': 'FAKE_ACTION',
'kwargs': {
'user': '******',
}, },
]
}
self.executor = ModelValueHandler(
event="EVERY_DAY",
settings=self.handler_settings,
)
def test_has_object_permission_with_permissions(self):
user_request = UserRequestFactory()
user_request.owner = self.user
self.assertTrue(
self.permission.has_object_permission(
self.request,
self.view,
user_request,
)
)
def setUp(self):
self.permission = IsOwnerOrStaff()
self.view = TestView.as_view()
self.request = factory.get('/') # we don't care about the path
self.user = TerraUserFactory()
self.request.user = self.user
self.userrequest = UserRequestFactory()
def setUp(self):
self.user = TerraUserFactory()
self.userrequest = UserRequestFactory()
self.docx_file = os.path.join(os.path.dirname(__file__), 'empty.docx')
with open(self.docx_file, 'rb') as docx:
self.template = DocumentTemplate.objects.create(
name='emptydocx',
documenttemplate=SimpleUploadedFile(
str(uuid4()),
docx.read()
)
)
self.downloadable = DownloadableDocument.objects.create(
user=self.user,
document=self.template,
linked_object=self.userrequest
)
class TimeDeltaHandlerTestCase(TestCase):
def setUp(self):
self.userrequest = UserRequestFactory()
def test_handler(self):
daysdelta = '20'
args = {
'instance': self.userrequest,
'user': self.userrequest.owner,
}
# test with nested values
executor = TimeDeltaHandler(
'USERREQUEST_CREATED',
{'daysdelta': daysdelta, 'field': 'properties.name.attribute'},
**args)
if executor.valid_condition():
executor()
self.userrequest.refresh_from_db()
self.assertEqual(
self.userrequest.properties['name']['attribute'],
str(date.today() + timedelta(days=int(daysdelta)))
)
# test with expiry field
executor = TimeDeltaHandler(
'USERREQUEST_CREATED',
{'daysdelta': daysdelta, 'field': 'expiry'},
**args)
if executor.valid_condition():
executor()
self.userrequest.refresh_from_db()
self.assertEqual(
self.userrequest.expiry,
date.today() + timedelta(days=int(daysdelta))
)
def setUp(self):
template_path = os.path.join('terracommon', 'document_generator',
'tests', 'test_template.odt')
self.documenttemplate = DocumentTemplate.objects.create(
name='test_template', documenttemplate=template_path)
self.user = TerraUserFactory()
self.userrequest = UserRequestFactory()
self.downloadable_document = DownloadableDocument.objects.create(
user=self.user,
document=self.documenttemplate,
linked_object=self.userrequest)
self.serializer = DownloadableDocumentSerializer(
self.downloadable_document)
def test_integration_with_SendEmailHandler(self):
userrequests = []
for i in range(0, 3):
userrequests.append(
UserRequestFactory(expiry=date.today() +
timedelta(days=i + 1), ))
userrequests[-1].reviewers.set([
UserFactory(email=f'reviewer{i*2+1}@makina-corpus.com'),
UserFactory(email=f'reviewer{i*2+2}@makina-corpus.com')
])
signals = [{
'action':
'EVERY_DAY',
'handler': ('terracommon.events.signals.handlers'
'.ModelValueHandler'),
'settings': {
'model': 'terracommon.trrequests.models.UserRequest',
'query': {
'expiry': 'date.today() + timedelta(days=2)',
},
'actions': [
{
'action': 'USERREQUEST_WILL_EXPIRE_SOON',
},
]
}
}, {
'action':
'USERREQUEST_WILL_EXPIRE_SOON',
'handler': ('terracommon.events.signals.handlers'
'.SendEmailHandler'),
'settings': {
'recipients':
"instance['reviewers']",
'subject_tpl':
"A user request will expire",
'body_tpl': ("The user request n°{instance[id]}"
" will expire in 2 days")
}
}]
for signal in signals:
EventHandler.objects.create(**signal)
self.assertEqual(len(mail.outbox), 0)
call_command('execute_action', '--action=EVERY_DAY')
self.assertEqual(len(mail.outbox), 2)
mail_signal = signals[1]
userrequest = userrequests[1]
for reviewer in userrequest.reviewers.all():
reviewer_mails = list(
filter(lambda m: reviewer.email in m.recipients(),
mail.outbox))
self.assertEqual(len(reviewer_mails), 1)
current_mail = reviewer_mails[0]
format_kwargs = {'instance': model_to_dict(userrequest)}
self.assertEqual(
current_mail.subject,
mail_signal.get('settings',
{}).get('subject_tpl',
'').format(**format_kwargs))
self.assertEqual(
current_mail.body,
mail_signal.get('settings',
{}).get('body_tpl',
'').format(**format_kwargs))
def setUp(self):
self.userrequest = UserRequestFactory()
class DocumentGeneratorTestCase(TestCase):
def setUp(self):
self.user = TerraUserFactory()
self.userrequest = UserRequestFactory()
self.docx_file = os.path.join(os.path.dirname(__file__), 'empty.docx')
with open(self.docx_file, 'rb') as docx:
self.template = DocumentTemplate.objects.create(
name='emptydocx',
documenttemplate=SimpleUploadedFile(
str(uuid4()),
docx.read()
)
)
self.downloadable = DownloadableDocument.objects.create(
user=self.user,
document=self.template,
linked_object=self.userrequest
)
@patch('subprocess.run', side_effect=mock_libreoffice)
def test_pdf_is_generated_from_enriched_docx(self, mock_run):
# Patch libroffice call, that should write a pdf file of the same name
# as temporary docx file
# Now patch get_docx to return dumb content
docx_path = os.path.join(os.path.dirname(__file__), 'empty.docx')
with open(docx_path, 'rb') as docx_file:
with patch.object(
DocumentGenerator, 'get_docx',
return_value=io.BytesIO(docx_file.read())
) as mock_docx:
dg = DocumentGenerator(self.downloadable)
pdf_path = dg.get_pdf()
mock_docx.assert_called()
os.remove(pdf_path)
def test_everything_seems_to_work_without_variables(self):
dg = DocumentGenerator(self.downloadable)
dg.get_docx({}) # No exceptions are raised
def test_everything_seems_to_work_with_variables(self):
template_path = os.path.join(os.path.dirname(__file__),
'template_with_img.docx')
with open(template_path, 'rb') as template_fd:
template = DocumentTemplate.objects.create(
name='template_with_img',
documenttemplate=SimpleUploadedFile(template_path,
template_fd.read())
)
downloadable = DownloadableDocument.objects.create(
user=self.user,
document=template,
linked_object=self.userrequest
)
image_path = os.path.join(os.path.dirname(__file__), 'new_img.png')
dg = DocumentGenerator(downloadable)
dg.get_docx({
'name': 'Makina Corpus',
'logo': image_path,
}) # No exceptions are raised
def test_raises_exception_typeerror(self):
with self.assertRaises(TypeError):
DocumentGenerator('')
@patch('terracommon.document_generator.helpers.logger')
def test_raises_exception_when_template_is_not_found(self, mock_logger):
dg = DocumentGenerator(self.downloadable)
dg.get_docx = MagicMock(side_effect=FileNotFoundError)
with self.assertRaises(FileNotFoundError):
dg.get_pdf()
mock_logger.warning.assert_called()
@patch('subprocess.run', side_effect=mock_libreoffice)
def test_cache_is_created(self, mock_run):
dg = DocumentGenerator(self.downloadable)
pdf_path = dg.get_pdf()
self.assertTrue(os.path.isfile(pdf_path))
os.remove(pdf_path)
@patch('terracommon.document_generator.helpers.logger')
def test_raises_templatesyntaxerror_exception(self, mock_logger):
dg = DocumentGenerator(self.downloadable)
dg.get_docx = MagicMock(side_effect=TemplateSyntaxError('', 0))
with self.assertRaises(TemplateSyntaxError):
dg.get_pdf()
mock_logger.warning.assert_called()
@patch('subprocess.run', side_effect=mock_libreoffice)
def test_pdf_is_generated_again_when_data_are_updated(self, mock_run):
dg = DocumentGenerator(self.downloadable)
pdf_path = dg.get_pdf()
pdf_mtime = os.path.getmtime(pdf_path)
self.assertTrue(os.path.isfile(pdf_path))
# Update the updated_at date
self.userrequest.save()
pdf_path_bis = dg.get_pdf()
self.assertTrue(os.path.isfile(pdf_path_bis))
self.assertNotEqual(os.path.getmtime(pdf_path_bis), pdf_mtime)
os.remove(pdf_path_bis)