def test_dt_to_ISO8601(self):
self.assertEqual(
'2015-01-16T15:22:03.357000Z',
dt_to_ISO8601(self.create_datetime(
year=2015, month=1, day=16, hour=15,
minute=22, second=3, microsecond=357000,
utc=True,
)),
)
self.assertEqual(
'2018-02-04T18:41:25.123000Z',
dt_to_ISO8601(make_aware(
datetime(
year=2018, month=2, day=4, hour=19,
minute=41, second=25, microsecond=123000,
),
timezone=timezone('Europe/Paris'), # DST: +1h
)),
)
self.assertEqual(
'2018-03-05T19:41:25.123000Z',
dt_to_ISO8601(datetime(
year=2018, month=3, day=5, hour=19,
minute=41, second=25, microsecond=123000,
)),
)
def test_edition08(self):
"DateTimeField"
create_dt = self.create_datetime
old_start = create_dt(year=2016, month=11, day=22, hour=16, minute=10)
meeting = FakeActivity.objects.create(
user=self.user,
title='Meeting with Seele',
start=old_start,
type=FakeActivityType.objects.all()[0],
)
old_count = HistoryLine.objects.count()
meeting = self.refresh(meeting)
meeting.start = start = create_dt(year=2016,
month=11,
day=22,
hour=16,
minute=15)
meeting.end = end = create_dt(year=2016,
month=11,
day=22,
hour=18,
minute=30)
meeting.save()
hlines = self._get_hlines()
self.assertEqual(old_count + 1, len(hlines))
hline = hlines[-1]
self.assertEqual(meeting.id, hline.entity.id)
self.assertEqual(TYPE_EDITION, hline.type)
self.assertEqual([
['start', dt_to_ISO8601(old_start),
dt_to_ISO8601(start)],
['end', dt_to_ISO8601(end)],
], hline.modifications)
vmodifs = hline.get_verbose_modifications(self.user)
self.assertEqual(2, len(vmodifs))
self.assertEqual(
self.FMT_3_VALUES(
field=_('Start'),
oldvalue=date_format(old_start, 'DATETIME_FORMAT'),
value=date_format(start, 'DATETIME_FORMAT'),
), vmodifs[0])
# Set None -------------------------
meeting.end = None
meeting.save()
hlines = self._get_hlines()
self.assertEqual(old_count + 2, len(hlines))
self.assertEqual(
self.FMT_3_VALUES(
field=_('End'),
oldvalue=date_format(end, 'DATETIME_FORMAT'),
value='',
), hlines[-1].get_verbose_modifications(self.user)[0])
def as_dict(self):
return {
'pk': self.pk,
'url': self.url,
'name': self.name,
'modified': dt_to_ISO8601(self.modified),
}
def test_update05(self):
"Reference run + no change"
job = self.get_object_or_fail(Job, type_id=reminder_type.id)
ref_run = job.reference_run
self.assertFalse(job.update({'reference_run': dt_to_ISO8601(ref_run)}))
self.assertEqual(ref_run, job.reference_run)
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_refresh03(self):
"Reference_run is changed"
queue = JobSchedulerQueue.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_refresh04(self):
"Periodicity is changed"
queue = JobSchedulerQueue.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_refresh01(self):
"No refresh needed"
queue = JobSchedulerQueue.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_editview03(self):
"Periodic: edit periodicity + specific data"
queue = JobSchedulerQueue.get_main_queue()
queue.clear()
self.login()
self.assertListEqual([], 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.assertDictEqual(pdict, job.periodicity.as_dict())
self.assertDictEqual(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')
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.assertListEqual([
(
job,
{
'enabled': True,
'reference_run': dt_to_ISO8601(job.reference_run),
'periodicity': periodicity_dict,
},
),
], queue.refreshed_jobs)
