def test_create01(self):
self.assertFalse(Alert.objects.exists())
queue = JobManagerQueue.get_main_queue()
queue.clear()
entity = self.entity
context = self.assertGET200(self._build_add_url(entity)).context
self.assertEqual(
_('New alert for «{entity}»').format(entity=entity),
context.get('title'))
self.assertEqual(_('Save the alert'), context.get('submit_label'))
title = 'Title'
alert = self._create_alert(title, 'Description', '2010-9-29')
self.assertEqual(1, Alert.objects.count())
self.assertIs(False, alert.is_validated)
self.assertEqual(self.user, alert.user)
self.assertIs(False, alert.reminded)
self.assertEqual(entity.id, alert.entity_id)
self.assertEqual(entity.entity_type_id, alert.entity_content_type_id)
self.assertEqual(self.create_datetime(year=2010, month=9, day=29),
alert.trigger_date)
self.assertEqual(title, str(alert))
jobs = queue.refreshed_jobs
self.assertEqual(1, len(jobs))
self.assertEqual(self.get_reminder_job(), jobs[0][0])
def test_create01(self):
self.assertFalse(ToDo.objects.exists())
queue = JobManagerQueue.get_main_queue()
queue.clear()
entity = self.entity
context = self.assertGET200(self._build_add_url(entity)).context
# self.assertEqual(_('New Todo for «%s»') % entity, context.get('title'))
self.assertEqual(
_('New todo for «{entity}»').format(entity=entity),
context.get('title'))
self.assertEqual(_('Save the todo'), context.get('submit_label'))
with self.assertNoException():
hours = context['form'].fields['deadline_hour'].choices
self.assertIn((0, '0h'), hours)
self.assertIn((23, '23h'), hours)
self.assertEqual(24, len(hours))
# ---
title = 'Title'
todo = self._create_todo(title, 'Description')
self.assertEqual(1, ToDo.objects.count())
self.assertEqual(entity.id, todo.entity_id)
self.assertEqual(entity.entity_type_id, todo.entity_content_type_id)
self.assertDatetimesAlmostEqual(now(), todo.creation_date)
self.assertIsNone(todo.deadline)
self.assertIs(todo.reminded, False)
self.assertFalse(queue.refreshed_jobs) # Because there is no deadline
self.assertEqual(title, str(todo))
def test_editview04(self):
"Periodic: edit reference_run"
queue = JobManagerQueue.get_main_queue()
queue.clear()
self.login()
self.assertEqual([], queue.refreshed_jobs)
job = self.get_object_or_fail(Job, type_id=temp_files_cleaner_type.id)
pdict = {'type': 'days', 'value': 1}
self.assertEqual(pdict, job.periodicity.as_dict())
response = self.client.post(
job.get_edit_absolute_url(),
data={
'reference_run': '26-08-2014 14:00:00',
'periodicity_0': pdict['type'],
'periodicity_1': str(pdict['value']),
'delay_0': 'days',
'delay_1': 2,
},
)
self.assertNoFormError(response)
job = self.refresh(job)
self.assertEqual(pdict, job.periodicity.as_dict())
self.assertEqual(
self.create_datetime(year=2014, month=8, day=26, hour=14),
job.reference_run)
self.assertEqual({'delay': {'type': 'days', 'value': 2}}, job.data)
self.assertTrue(queue.refreshed_jobs)
def test_create02(self):
"Deadline"
queue = JobManagerQueue.get_main_queue()
queue.clear()
url = self._build_add_url(self.entity)
title = 'my Todo'
data = {
'user': self.user.pk,
'title': title,
'description': '',
'deadline': '2013-6-7',
}
response = self.assertPOST200(url, data=data)
self.assertFormError(response, 'form', 'deadline_hour',
_('The hour is required if you set a date.'))
self.assertNoFormError(
self.client.post(url, data=dict(data, deadline_hour=9)))
todo = self.get_object_or_fail(ToDo, title=title)
self.assertEqual(
self.create_datetime(year=2013, month=6, day=7, hour=9),
todo.deadline)
self.assertTrue(queue.refreshed_jobs)
def setUpClass(cls):
super().setUpClass()
cls.queue = queue = JobManagerQueue.get_main_queue()
cls._original_queue_ping = queue.ping
cls.ct_orga_id = ContentType.objects.get_for_model(FakeOrganisation).id
def test_job02(self):
"Default backend + job configuration"
other_user = self.other_user
queue = JobManagerQueue.get_main_queue()
queue.clear()
self.SwallowInput.force_not_handle = True
self._build_test_registry(FAKE_CRUDITY_BACKENDS)
# -----------------------------
job = self.get_object_or_fail(Job, type_id=crudity_synchronize_type.id)
with self.assertNoException():
jdata = job.data
self.assertIsInstance(jdata, dict)
self.assertEqual(1, len(jdata))
user_id = jdata.get('user')
self.assertIsNotNone(user_id)
self.get_object_or_fail(get_user_model(), id=user_id)
url = job.get_edit_absolute_url()
self.assertGET200(url)
pdict = {'type': 'hours', 'value': 12}
response = self.client.post(
url,
data={
'reference_run': '26-06-2016 14:00:00',
'periodicity_0': pdict['type'],
'periodicity_1': str(pdict['value']),
'user': other_user.id,
},
)
self.assertNoFormError(response)
job = self.refresh(job)
self.assertEqual(pdict, job.periodicity.as_dict())
self.assertEqual(
self.create_datetime(year=2016, month=6, day=26, hour=14),
job.reference_run)
self.assertEqual({'user': other_user.id}, job.data)
# -----------------------------
crudity_synchronize_type.execute(job)
jresults = JobResult.objects.filter(job=job)
self.assertEqual(1, len(jresults))
self.assertEqual([
ungettext('There is {count} change', 'There are {count} changes',
1).format(count=1)
], jresults[0].messages)
calls_args = self.FakeContactBackend.calls_args
self.assertEqual(1, len(calls_args))
call_args = calls_args[0]
self.assertIsInstance(call_args[0], Swallow)
self.assertEqual(other_user, call_args[1])
def test_editview01(self):
user = self.user
tpl1 = self._create_ticket_template(title='TicketTemplate #1')
tpl2 = self._create_ticket_template(title='TicketTemplate #2')
gen = RecurrentGenerator.objects.create(
name='Gen1',
user=user,
first_generation=now(),
last_generation=None,
periodicity=date_period_registry.get_period('weeks', 2),
ct=self.ct,
template=tpl1,
)
url = gen.get_edit_absolute_url()
self.assertGET200(url)
queue = JobManagerQueue.get_main_queue()
queue.clear()
name = gen.name.upper()
response = self.client.post(
url,
follow=True,
data={
'user': user.id,
'name': name,
'first_generation': '12-06-2014 10:00',
'periodicity_0': 'months',
'periodicity_1': '1',
# should not be used
'ct': ContentType.objects.get_for_model(Priority).id,
'template': tpl2.id,
})
self.assertNoFormError(response)
self.assertRedirects(response, gen.get_absolute_url())
self.assertTemplateUsed(response, 'recurrents/view_generator.html')
gen = self.refresh(gen)
self.assertEqual(name, gen.name)
self.assertEqual(
self.create_datetime(year=2014, month=6, day=12, hour=10),
gen.first_generation)
self.assertEqual(self.ct, gen.ct)
self.assertEqual(tpl1, gen.template.get_real_entity())
self.assertEqual({
'type': 'months',
'value': 1
}, gen.periodicity.as_dict())
self.assertEqual(1, len(queue.refreshed_jobs))
def test_create01(self):
self.assertFalse(UserMessage.objects.exists())
queue = JobManagerQueue.get_main_queue()
queue.clear()
entity = self.entity
response = self.assertGET200(self._build_add_url(entity))
# self.assertTemplateUsed(response, 'creme_core/generics/blockform/add_popup.html')
self.assertTemplateUsed(
response, 'creme_core/generics/blockform/add-popup.html')
context = response.context
# self.assertEqual(_('New message about «%s»') % entity, context.get('title'))
self.assertEqual(
_('New message about «{entity}»').format(entity=entity),
context.get('title'))
self.assertEqual(_('Save the message'), context.get('submit_label'))
title = 'TITLE'
body = 'BODY'
priority = UserMessagePriority.objects.create(title='Important')
user01 = User.objects.create_user(
'User01',
email='*****@*****.**',
first_name='User01',
last_name='Foo',
)
self._create_usermessage(title, body, priority, [user01], entity)
messages = UserMessage.objects.all()
self.assertEqual(1, len(messages))
message = messages[0]
self.assertEqual(title, message.title)
self.assertEqual(body, message.body)
self.assertEqual(priority, message.priority)
self.assertFalse(message.email_sent)
self.assertEqual(entity.id, message.entity_id)
self.assertEqual(entity.entity_type_id, message.entity_content_type_id)
self.assertEqual(self.user, message.sender)
self.assertEqual(user01, message.recipient)
self.assertDatetimesAlmostEqual(now(), message.creation_date)
self.assertEqual(title, str(message))
jobs = queue.refreshed_jobs
self.assertEqual(1, len(jobs))
self.assertEqual(self._get_usermessages_job(), jobs[0][0])
def test_refresh_job02(self):
"Mail is restored + do not have to be send => do not refresh the job"
self.login()
email = self._create_email(MAIL_STATUS_SENDINGERROR)
email.status = MAIL_STATUS_SENT
email.is_deleted = True
email.save()
email = self.refresh(email)
queue = JobManagerQueue.get_main_queue()
queue.clear()
email.restore()
self.assertFalse(queue.refreshed_jobs)
def test_refresh_job01(self):
"Mail is restored + have to be send => refresh the job"
self.login()
job = self._get_job()
email = self._create_email(MAIL_STATUS_SENDINGERROR)
email.trash()
queue = JobManagerQueue.get_main_queue()
queue.clear()
email.restore()
self.assertFalse(self.refresh(email).is_deleted)
jobs = queue.refreshed_jobs
self.assertEqual(1, len(jobs))
self.assertEqual(job, jobs[0][0])
def test_refresh03(self):
"Reference_run is changed"
queue = JobManagerQueue.get_main_queue()
queue.clear()
job = self.get_object_or_fail(Job, type_id=reminder_type.id)
job.reference_run = now()
self.assertIs(job.refresh(), False)
self.assertEqual([
(
job,
{
'enabled': job.enabled,
'reference_run': dt_to_ISO8601(job.reference_run),
},
),
], queue.refreshed_jobs)
def test_refresh_job02(self):
"Restore campaign with sending which does not have to be sent"
self.login()
camp = EmailCampaign.objects.create(user=self.user,
name='camp01',
is_deleted=True)
EmailSending.objects.create(
campaign=camp,
type=SENDING_TYPE_DEFERRED,
state=SENDING_STATE_DONE,
sending_date=now() - timedelta(hours=1),
)
queue = JobManagerQueue.get_main_queue()
queue.clear()
camp.restore()
self.assertFalse(queue.refreshed_jobs)
def test_job01(self):
"first_generation in the past + (no generation yet (ie last_generation is None)"
self.assertFalse(Ticket.objects.all())
now_value = now()
job = self._get_job()
self.assertIsNone(job.user)
self.assertIsNone(job.type.next_wakeup(job, now_value))
tpl = self._create_ticket_template()
start = now_value - timedelta(days=5)
gen = RecurrentGenerator.objects.create(
name='Gen1',
user=self.user,
periodicity=self._get_weekly(),
ct=self.ct,
template=tpl,
first_generation=start,
last_generation=None,
)
self.assertDatetimesAlmostEqual(now(),
job.type.next_wakeup(job, now_value))
queue = JobManagerQueue.get_main_queue()
queue.clear()
self._generate_docs(job)
new_tickets = Ticket.objects.all()
self.assertEqual(1, len(new_tickets))
ticket = new_tickets[0]
self.assertEqual(
'{} {}'.format(tpl.title,
date_format(now_value.date(), 'DATE_FORMAT')),
ticket.title)
gen = self.refresh(gen)
self.assertEqual(gen.first_generation, gen.last_generation)
self.assertEqual(
[], queue.refreshed_jobs
) # Job which edits generator should not cause REFRESH signal
def test_refresh_job(self):
queue = JobManagerQueue.get_main_queue()
job = self._get_job()
tpl = self._create_ticket_template()
now_value = now()
gen = RecurrentGenerator.objects.create(
name='Generator',
user=self.user,
first_generation=now_value + timedelta(days=2),
last_generation=None,
periodicity=date_period_registry.get_period('weeks', 2),
ct=self.ct,
template=tpl,
)
queue.clear()
gen.name = 'My Generator'
gen.save()
self.assertFalse(queue.refreshed_jobs)
gen.first_generation = now_value + timedelta(hours=3)
gen.save()
refreshed_jobs = queue.refreshed_jobs
self.assertEqual(1, len(refreshed_jobs))
self.assertEqual(job, refreshed_jobs[0][0])
queue.clear()
gen.name = 'My Generator again'
gen.save()
self.assertFalse(
queue.refreshed_jobs
) # The new value of 'first_generation' is cached -> no new refreshing
gen.periodicity = date_period_registry.get_period('weeks', 1)
gen.save()
self.assertEqual(1, len(queue.refreshed_jobs))
queue.clear()
gen.name = 'My Generator again & again'
gen.save()
self.assertFalse(
queue.refreshed_jobs
) # The new value of 'periodicity' is cached -> no new refreshing
def test_createview10(self):
"Mail sending error"
user = self.login()
queue = JobManagerQueue.get_main_queue()
queue.clear()
self.send_messages_called = False
def send_messages(this, messages):
self.send_messages_called = True
raise Exception('Sent error')
EmailBackend.send_messages = send_messages
recipient = '*****@*****.**'
contact = Contact.objects.create(
user=user,
first_name='Vincent',
last_name='Law',
email=recipient,
)
sender = user.linked_contact.email
response = self.client.post(
self._build_create_entitymail_url(contact),
data={
'user': user.id,
'sender': sender,
'c_recipients':
self.formfield_value_multi_creator_entity(contact),
'subject': 'Under arrest',
'body': 'Freeze !',
'body_html': '<p>Freeze !</p>',
})
self.assertNoFormError(response)
email = self.get_object_or_fail(EntityEmail,
sender=sender,
recipient=recipient)
self.assertEqual(MAIL_STATUS_SENDINGERROR, email.status)
self.assertTrue(queue.refreshed_jobs)
def test_disable01(self):
queue = JobManagerQueue.get_main_queue()
queue.clear()
self.login()
self.assertEqual([], queue.refreshed_jobs)
job = Job.objects.create(
type_id=batch_process_type.id) # No user -> system job
self.assertIs(job.enabled, True)
self.assertEqual([], queue.refreshed_jobs)
disable_url = self._build_disable_url(job)
self.assertGET404(disable_url)
self.assertPOST200(disable_url)
self.assertIs(self.refresh(job).enabled, False)
self.assertEqual([
(
job,
{
'enabled': False,
'reference_run': dt_to_ISO8601(job.reference_run),
},
),
], queue.refreshed_jobs)
enable_url = self._build_enable_url(job)
self.assertGET404(enable_url)
queue.clear()
self.assertPOST200(enable_url)
self.assertIs(self.refresh(job).enabled, True)
self.assertEqual([
(
job,
{
'enabled': True,
'reference_run': dt_to_ISO8601(job.reference_run),
},
),
], queue.refreshed_jobs)
def test_refresh01(self):
"No refresh needed"
queue = JobManagerQueue.get_main_queue()
queue.clear()
job = self.get_object_or_fail(Job, type_id=reminder_type.id)
self.assertIs(job.refresh(), False)
self.assertEqual([], queue.refreshed_jobs)
# ---
job.refresh(force=True)
self.assertEqual([
(
job,
{
'enabled': job.enabled,
'reference_run': dt_to_ISO8601(job.reference_run),
},
),
], queue.refreshed_jobs)
def test_refresh04(self):
"Periodicity is changed"
queue = JobManagerQueue.get_main_queue()
queue.clear()
job = self.get_object_or_fail(Job, type_id=reminder_type.id)
job.periodicity = MinutesPeriod(1)
self.assertIs(job.refresh(), False)
self.assertEqual([
(
job,
{
'enabled': job.enabled,
'reference_run': dt_to_ISO8601(job.reference_run),
'periodicity': {
'type': 'minutes',
'value': 1
},
},
),
], queue.refreshed_jobs)
def test_job01(self):
user = self.login()
SwallowFetcher = self.SwallowFetcher
SwallowFetcher.user_id = user.id
last_name = SwallowFetcher.last_name = 'Ayanami'
self.assertFalse(FakeContact.objects.filter(last_name=last_name))
queue = JobManagerQueue.get_main_queue()
queue.clear()
job = self.get_object_or_fail(Job, type_id=crudity_synchronize_type.id)
self.assertIsNone(job.user)
self.assertEqual(0, job.reference_run.minute)
self.assertEqual(0, job.reference_run.second)
self.assertEqual([], queue.started_jobs)
self.assertEqual([], queue.refreshed_jobs)
self._build_test_registry(FAKE_CRUDITY_BACKENDS)
crudity_synchronize_type.execute(job)
self.assertGET200(job.get_absolute_url())
jresults = JobResult.objects.filter(job=job)
self.assertEqual(1, len(jresults))
self.assertEqual([ngettext('There is {count} change',
'There are {count} changes',
1
).format(count=1),
],
jresults[0].messages
)
self.assertEqual([], queue.started_jobs)
self.assertEqual([], queue.refreshed_jobs)
self.get_object_or_fail(FakeContact, last_name=last_name)
def test_editview05(self):
"No change of periodicity/reference_run"
queue = JobManagerQueue.get_main_queue()
queue.clear()
self.login()
job = self.get_object_or_fail(Job, type_id=temp_files_cleaner_type.id)
old_reference_run = job.reference_run
pdict = {'type': 'days', 'value': 1}
self.assertEqual(pdict, job.periodicity.as_dict())
response = self.client.post(
job.get_edit_absolute_url(),
data={
'reference_run':
date_format(
localtime(job.reference_run),
'DATETIME_FORMAT',
),
'periodicity_0':
pdict['type'],
'periodicity_1':
str(pdict['value']),
'delay_0':
'weeks',
'delay_1':
1,
},
)
self.assertNoFormError(response)
job = self.refresh(job)
self.assertEqual(pdict, job.periodicity.as_dict())
self.assertEqual(old_reference_run, job.reference_run)
self.assertEqual({'delay': {'type': 'weeks', 'value': 1}}, job.data)
self.assertEqual([], queue.refreshed_jobs)
def test_refresh_job01(self):
"Restore campaign with sending which has to be sent"
self.login()
job = self._get_job()
camp = EmailCampaign.objects.create(user=self.user,
name='camp01',
is_deleted=True)
EmailSending.objects.create(
campaign=camp,
type=SENDING_TYPE_DEFERRED,
state=SENDING_STATE_PLANNED,
sending_date=now() - timedelta(hours=1),
)
queue = JobManagerQueue.get_main_queue()
queue.clear()
camp.restore()
self.assertFalse(self.refresh(camp).is_deleted)
jobs = queue.refreshed_jobs
self.assertEqual(1, len(jobs))
self.assertEqual(job, jobs[0][0])
def test_editview03(self):
"Periodic: edit periodicity + specific data"
queue = JobManagerQueue.get_main_queue()
queue.clear()
# user = \
self.login()
self.assertEqual([], queue.refreshed_jobs)
job = self.get_object_or_fail(Job, type_id=temp_files_cleaner_type.id)
self.assertEqual(JobType.PERIODIC, job.type.periodic)
self.assertIsNone(job.user)
old_reference_run = job.reference_run
pdict = {'type': 'days', 'value': 1}
self.assertEqual(pdict, job.periodicity.as_dict())
self.assertEqual(pdict, job.real_periodicity.as_dict())
with self.assertNoException():
jdata = job.data
self.assertEqual({'delay': {'type': 'days', 'value': 1}}, jdata)
url = job.get_edit_absolute_url()
response = self.assertGET200(url)
# self.assertTemplateUsed(response, 'creme_core/generics/blockform/edit_popup.html')
self.assertTemplateUsed(
response, 'creme_core/generics/blockform/edit-popup.html')
context = response.context
self.assertEqual(
_('Edit the job «{object}»').format(object=job.type),
context.get('title'))
self.assertEqual(_('Save the modifications'),
context.get('submit_label'))
# ---
response = self.client.post(
url,
data={
'reference_run':
date_format(
localtime(job.reference_run),
'DATETIME_FORMAT',
),
'periodicity_0':
'minutes',
'periodicity_1':
'180',
'delay_0':
'weeks',
'delay_1':
'2',
},
)
self.assertNoFormError(response)
job = self.refresh(job)
periodicity_dict = {'type': 'minutes', 'value': 180}
self.assertEqual(periodicity_dict, job.periodicity.as_dict())
self.assertEqual(old_reference_run, job.reference_run)
self.assertEqual({'delay': {'type': 'weeks', 'value': 2}}, job.data)
self.assertEqual([
(
job,
{
'enabled': True,
'reference_run': dt_to_ISO8601(job.reference_run),
'periodicity': periodicity_dict,
},
),
], queue.refreshed_jobs)
def test_batching_upper01(self):
queue = JobManagerQueue.get_main_queue()
queue.clear()
self.login()
self.assertFalse(Job.objects.filter(type_id=batch_process_type.id))
self.assertEqual([], queue.started_jobs)
self.assertEqual([], queue.refreshed_jobs)
url = self._build_add_url(FakeOrganisation)
response = self.assertGET200(url)
with self.assertNoException():
form = response.context['form']
orga_fields = set(form.fields['actions']._fields)
self.assertEqual({
'content_type': self.orga_ct,
'filter': None,
}, form.initial)
self.assertIn('name', orga_fields)
self.assertIn('capital', orga_fields)
create_orga = partial(FakeOrganisation.objects.create, user=self.user)
orga01 = create_orga(name='Genshiken')
orga02 = create_orga(name='Manga club')
response = self.client.post(url,
follow=True,
data={
'actions':
self.build_formfield_value(
operator='upper',
name='name',
value='',
),
})
self.assertNoFormError(response)
jobs = Job.objects.filter(type_id=batch_process_type.id)
self.assertEqual(1, len(jobs))
job = jobs[0]
self.assertEqual(self.user, job.user)
self.assertDatetimesAlmostEqual(now(), job.reference_run, 1)
self.assertIsInstance(job.data, dict)
self.assertEqual(Job.STATUS_WAIT, job.status)
self.assertIsNone(job.error)
self.assertFalse(EntityJobResult.objects.filter(job=job))
self.assertIsNone(job.last_run)
self.assertEqual(_(u'Core'), job.type.app_config.verbose_name)
# Properties
self.assertIs(batch_process_type, job.type)
self.assertIs(False, job.is_finished)
self.assertEqual([
_(u'Entity type: {}').format('Test Organisation'),
_(u'{field} ➔ {operator}').format(
field=_(u'Name'),
operator=_(u'To upper case'),
)
], job.description)
self.assertRedirects(response, job.get_absolute_url())
self.assertEqual([job], queue.started_jobs)
self.assertEqual([], queue.refreshed_jobs)
batch_process_type.execute(job)
self.assertEqual('GENSHIKEN', self.refresh(orga01).name)
self.assertEqual('MANGA CLUB', self.refresh(orga02).name)
job = self.refresh(job)
self.assertDatetimesAlmostEqual(now(), job.last_run, 10)
self.assertEqual(Job.STATUS_OK, job.status)
self.assertIsNone(job.error)
orga_count = FakeOrganisation.objects.count()
self.assertEqual([
ungettext(u'{count} entity has been successfully modified.',
u'{count} entities have been successfully modified.',
orga_count).format(count=orga_count),
], job.stats)
self.assertEqual([], queue.refreshed_jobs)
def test_createview01(self):
user = self.login()
queue = JobManagerQueue.get_main_queue()
queue.clear()
recipient = '*****@*****.**'
contact = Contact.objects.create(user=user,
first_name='Vincent',
last_name='Law',
email=recipient)
url = self._build_create_entitymail_url(contact)
context = self.assertGET200(url).context
# self.assertEqual(_('Sending an email to «%s»') % contact, context.get('title'))
self.assertEqual(
_('Sending an email to «{}»').format(contact),
context.get('title'))
self.assertEqual(EntityEmail.sending_label,
context.get('submit_label'))
with self.assertNoException():
c_recipients = context['form'].fields['c_recipients']
self.assertEqual([contact.id], c_recipients.initial)
sender = user.linked_contact.email
body = 'Freeze !'
body_html = '<p>Freeze !</p>'
subject = 'Under arrest'
response = self.client.post(
url,
data={
'user': user.id,
'sender': sender,
'c_recipients':
self.formfield_value_multi_creator_entity(contact),
'subject': subject,
'body': body,
'body_html': body_html,
})
self.assertNoFormError(response)
email = self.get_object_or_fail(EntityEmail,
sender=sender,
recipient=recipient)
self.assertEqual(user, email.user)
self.assertEqual(subject, email.subject)
self.assertEqual(body, email.body)
self.assertEqual(body_html, email.body_html)
self.assertEqual(MAIL_STATUS_SENT, email.status)
self.get_object_or_fail(Relation,
subject_entity=email,
type=REL_SUB_MAIL_SENDED,
object_entity=user.linked_contact)
self.get_object_or_fail(Relation,
subject_entity=email,
type=REL_SUB_MAIL_RECEIVED,
object_entity=contact)
response = self.assertGET200(
reverse('emails__view_email', args=(email.id, )))
self.assertTemplateUsed(response, 'emails/view_entity_mail.html')
response = self.assertGET200(
reverse('emails__view_email_popup', args=(email.id, )))
# self.assertTemplateUsed(response, 'emails/view_entity_mail_popup.html')
self.assertTemplateUsed(response,
'creme_core/generics/detail-popup.html')
messages = mail.outbox
self.assertEqual(1, len(messages))
message = messages[0]
self.assertEqual(subject, message.subject)
self.assertEqual(body, message.body)
self.assertEqual([recipient], message.recipients())
self.assertEqual(sender, message.from_email)
self.assertEqual([(body_html, 'text/html')], message.alternatives)
self.assertFalse(message.attachments)
self.assertEqual([], queue.refreshed_jobs)
def test_create03(self):
"Job + outbox"
queue = JobManagerQueue.get_main_queue()
queue.clear()
job = self._get_job()
now_value = now()
self.assertIsNone(job.user)
self.assertIsNone(job.type.next_wakeup(job, now_value))
user = self.login()
camp = EmailCampaign.objects.create(user=user, name='camp01')
template = EmailTemplate.objects.create(user=user,
name='name',
subject='subject',
body='body')
mlist = MailingList.objects.create(user=user, name='ml01')
contact = Contact.objects.create(
user=user,
email='*****@*****.**',
first_name='Spike',
last_name='Spiegel',
)
create_orga = partial(Organisation.objects.create, user=user)
orga1 = create_orga(name='NERV', email='*****@*****.**')
orga2 = create_orga(name='Seele', email='*****@*****.**')
camp.mailing_lists.add(mlist)
mlist.contacts.add(contact)
mlist.organisations.add(orga1, orga2)
sender = '*****@*****.**'
response = self.client.post(
self._build_add_url(camp),
data={
'sender': sender,
'type': SENDING_TYPE_IMMEDIATE,
'template': template.id,
},
)
self.assertNoFormError(response)
self.assertFalse(django_mail.outbox)
self.assertIs(job.type.next_wakeup(job, now_value), now_value)
jobs = queue.refreshed_jobs
self.assertEqual(1, len(jobs))
self.assertEqual(job, jobs[0][0])
queue.clear()
self._send_mails(job)
with self.assertNoException():
sending = camp.sendings_set.all()[0]
self.assertEqual(SENDING_STATE_DONE, sending.state)
messages = django_mail.outbox
self.assertEqual(len(messages), 3)
message = messages[0]
self.assertEqual(template.subject, message.subject)
self.assertEqual(template.body, message.body)
self.assertEqual(sender, message.from_email)
self.assertEqual([('', 'text/html')], message.alternatives)
self.assertFalse(message.attachments)
self.assertEqual({contact.email, orga1.email, orga2.email}, {
recipient
for message in messages for recipient in message.recipients()
})
self.assertIsNone(job.type.next_wakeup(job, now_value))
self.assertFalse(
queue.refreshed_jobs
) # Other save() in job should not send REFRESH signals
def test_createview(self):
user = self.user
url = reverse('recurrents__create_generator')
self.assertGET200(url)
queue = JobManagerQueue.get_main_queue()
queue.clear()
name = 'Recurrent tickets'
response = self.client.post(
url,
data={
'recurrent_generator_wizard-current_step': 0,
'0-user': user.id,
'0-name': name,
'0-ct': self.ct.id,
'0-first_generation': '11-06-2014 09:00',
'0-periodicity_0': 'days',
'0-periodicity_1': '4',
},
)
self.assertNoWizardFormError(response)
with self.assertNoException():
wizard = response.context['wizard']
steps = wizard['steps']
count = steps.count
current = steps.current
# self.assertTemplateUsed(response, 'creme_core/generics/blockform/add_wizard.html')
self.assertTemplateUsed(
response, 'creme_core/generics/blockform/add-wizard.html')
self.assertEqual(2, count)
self.assertEqual('1', current)
title = 'Support ticket'
desc = "blablabla"
status = Status.objects.all()[0]
priority = Priority.objects.all()[0]
criticity = Criticity.objects.all()[0]
response = self.client.post(
url,
follow=True,
data={
'recurrent_generator_wizard-current_step': 1,
'1-user': user.id,
'1-title': title,
'1-description': desc,
'1-status': status.id,
'1-priority': priority.id,
'1-criticity': criticity.id,
},
)
self.assertNoWizardFormError(response)
gen = self.get_object_or_fail(RecurrentGenerator, name=name)
tpl = self.get_object_or_fail(TicketTemplate, title=title)
self.assertRedirects(response, tpl.get_absolute_url())
self.assertEqual(user, gen.user)
self.assertEqual(self.ct, gen.ct)
periodicity = gen.periodicity
self.assertIsInstance(periodicity, DatePeriod)
self.assertEqual({'type': 'days', 'value': 4}, periodicity.as_dict())
self.assertEqual(
self.create_datetime(year=2014, month=6, day=11, hour=9),
gen.first_generation)
self.assertIsNone(gen.last_generation)
self.assertEqual(tpl, gen.template.get_real_entity())
self.assertTrue(gen.is_working)
self.assertEqual(user, tpl.user)
self.assertEqual(desc, tpl.description)
self.assertEqual(status, tpl.status)
self.assertEqual(priority, tpl.priority)
self.assertEqual(criticity, tpl.criticity)
self.assertFalse(tpl.solution)
jobs = queue.refreshed_jobs
self.assertEqual(1, len(jobs))
self.assertEqual(self._get_job(), jobs[0][0])