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])