refactor:rename classes

cunla · cunla · commit 706dfacb483a · 2024-01-10T10:56:26.000-05:00
diff --git a/scheduler/models/__init__.py b/scheduler/models/__init__.py
@@ -1,3 +1,3 @@
-from .args import TaskKwarg, TaskArg, BaseJobArg  # noqa: F401
+from .args import TaskKwarg, TaskArg, BaseTaskArg  # noqa: F401
 from .queue import Queue  # noqa: F401
 from .scheduled_task import BaseTask, ScheduledTask, RepeatableTask, CronTask  # noqa: F401
diff --git a/scheduler/models/args.py b/scheduler/models/args.py
@@ -18,7 +18,7 @@
 }
 
 
-class BaseJobArg(models.Model):
+class BaseTaskArg(models.Model):
     class ArgType(models.TextChoices):
         STR = 'str', _('string')
         INT = 'int', _('int')
@@ -57,11 +57,11 @@ def clean(self):
             })
 
     def save(self, **kwargs):
-        super(BaseJobArg, self).save(**kwargs)
+        super(BaseTaskArg, self).save(**kwargs)
         self.content_object.save()
 
     def delete(self, **kwargs):
-        super(BaseJobArg, self).delete(**kwargs)
+        super(BaseTaskArg, self).delete(**kwargs)
         self.content_object.save()
 
     def value(self):
@@ -80,17 +80,17 @@ class Meta:
         ordering = ['id']
 
 
-class TaskArg(BaseJobArg):
+class TaskArg(BaseTaskArg):
     def __str__(self):
-        return f'JobArg[arg_type={self.arg_type},value={self.value()}]'
+        return f'TaskArg[arg_type={self.arg_type},value={self.value()}]'
 
 
-class TaskKwarg(BaseJobArg):
+class TaskKwarg(BaseTaskArg):
     key = models.CharField(max_length=255)
 
     def __str__(self):
         key, value = self.value()
-        return f'JobKwarg[key={key},arg_type={self.arg_type},value={self.val}]'
+        return f'TaskKwarg[key={key},arg_type={self.arg_type},value={self.val}]'
 
     def value(self):
         return self.key, super(TaskKwarg, self).value()
diff --git a/scheduler/tests/test_cron_task.py b/scheduler/tests/test_cron_task.py
@@ -0,0 +1,71 @@
+from django.core.exceptions import ValidationError
+
+from scheduler import settings
+from scheduler.models import CronTask
+from scheduler.tools import create_worker
+from .test_models import BaseTestCases
+from .testtools import (
+    task_factory, _get_job_from_scheduled_registry)
+from ..queues import get_queue
+
+
+class TestCronTask(BaseTestCases.TestBaseTask):
+    TaskModelClass = CronTask
+
+    def test_clean(self):
+        task = task_factory(CronTask)
+        task.cron_string = '* * * * *'
+        task.queue = list(settings.QUEUES)[0]
+        task.callable = 'scheduler.tests.jobs.test_job'
+        self.assertIsNone(task.clean())
+
+    def test_clean_cron_string_invalid(self):
+        task = task_factory(CronTask)
+        task.cron_string = 'not-a-cron-string'
+        task.queue = list(settings.QUEUES)[0]
+        task.callable = 'scheduler.tests.jobs.test_job'
+        with self.assertRaises(ValidationError):
+            task.clean_cron_string()
+
+    def test_repeat(self):
+        task = task_factory(CronTask, repeat=10)
+        entry = _get_job_from_scheduled_registry(task)
+        self.assertEqual(entry.meta['repeat'], 10)
+
+    def test_check_rescheduled_after_execution(self):
+        task = task_factory(CronTask, )
+        queue = task.rqueue
+        first_run_id = task.job_id
+        entry = queue.fetch_job(first_run_id)
+        queue.run_sync(entry)
+        task.refresh_from_db()
+        self.assertTrue(task.is_scheduled())
+        self.assertNotEqual(task.job_id, first_run_id)
+
+    def test_check_rescheduled_after_failed_execution(self):
+        task = task_factory(CronTask, callable_name="scheduler.tests.jobs.scheduler.tests.jobs.test_job", )
+        queue = task.rqueue
+        first_run_id = task.job_id
+        entry = queue.fetch_job(first_run_id)
+        queue.run_sync(entry)
+        task.refresh_from_db()
+        self.assertTrue(task.is_scheduled())
+        self.assertNotEqual(task.job_id, first_run_id)
+
+    def test_cron_task_enqueuing_jobs(self):
+        queue = get_queue()
+        prev_queued = len(queue.scheduled_job_registry)
+        prev_finished = len(queue.finished_job_registry)
+        task = task_factory(CronTask, callable_name='scheduler.tests.jobs.enqueue_jobs')
+        self.assertEqual(prev_queued + 1, len(queue.scheduled_job_registry))
+        first_run_id = task.job_id
+        entry = queue.fetch_job(first_run_id)
+        queue.run_sync(entry)
+        self.assertEqual(20, len(queue))
+        self.assertEqual(prev_finished + 1, len(queue.finished_job_registry))
+        worker = create_worker('default', fork_job_execution=False, )
+        worker.work(burst=True)
+        self.assertEqual(prev_finished + 21, len(queue.finished_job_registry))
+        worker.refresh()
+        self.assertEqual(20, worker.successful_job_count)
+        self.assertEqual(0, worker.failed_job_count)
diff --git a/scheduler/tests/test_job_arg_models.py b/scheduler/tests/test_job_arg_models.py
@@ -7,142 +7,142 @@
 from .testtools import taskarg_factory
 
 
-class TestAllJobArg(TestCase):
-    JobArgClass = TaskArg
+class TestAllTaskArg(TestCase):
+    TaskArgClass = TaskArg
 
     def test_bad_arg_type(self):
-        arg = taskarg_factory(self.JobArgClass, arg_type='bad_arg_type', val='something')
+        arg = taskarg_factory(self.TaskArgClass, arg_type='bad_arg_type', val='something')
         with self.assertRaises(ValidationError):
             arg.clean()
 
     def test_clean_one_value_invalid_str_int(self):
-        arg = taskarg_factory(self.JobArgClass, arg_type='int', val='not blank', )
+        arg = taskarg_factory(self.TaskArgClass, arg_type='int', val='not blank', )
         with self.assertRaises(ValidationError):
             arg.clean()
 
     def test_clean_callable_invalid(self):
-        arg = taskarg_factory(self.JobArgClass, arg_type='callable', val='bad_callable', )
+        arg = taskarg_factory(self.TaskArgClass, arg_type='callable', val='bad_callable', )
         with self.assertRaises(ValidationError):
             arg.clean()
 
     def test_clean_datetime_invalid(self):
-        arg = taskarg_factory(self.JobArgClass, arg_type='datetime', val='bad datetime', )
+        arg = taskarg_factory(self.TaskArgClass, arg_type='datetime', val='bad datetime', )
         with self.assertRaises(ValidationError):
             arg.clean()
 
     def test_clean_bool_invalid(self):
-        arg = taskarg_factory(self.JobArgClass, arg_type='bool', val='bad bool', )
+        arg = taskarg_factory(self.TaskArgClass, arg_type='bool', val='bad bool', )
         with self.assertRaises(ValidationError):
             arg.clean()
 
     def test_clean_int_invalid(self):
-        arg = taskarg_factory(self.JobArgClass, arg_type='int', val='str')
+        arg = taskarg_factory(self.TaskArgClass, arg_type='int', val='str')
         with self.assertRaises(ValidationError):
             arg.clean()
 
     def test_str_clean(self):
-        arg = taskarg_factory(self.JobArgClass, val='something')
+        arg = taskarg_factory(self.TaskArgClass, val='something')
         self.assertIsNone(arg.clean())
 
 
-class TestJobArg(TestCase):
-    JobArgClass = TaskArg
+class TestTaskArg(TestCase):
+    TaskArgClass = TaskArg
 
     def test_str(self):
-        arg = taskarg_factory(self.JobArgClass)
+        arg = taskarg_factory(self.TaskArgClass)
         self.assertEqual(
-            f'JobArg[arg_type={arg.arg_type},value={arg.value()}]', str(arg))
+            f'TaskArg[arg_type={arg.arg_type},value={arg.value()}]', str(arg))
 
     def test_value(self):
-        arg = taskarg_factory(self.JobArgClass, arg_type='str', val='something')
+        arg = taskarg_factory(self.TaskArgClass, arg_type='str', val='something')
         self.assertEqual(arg.value(), 'something')
 
     def test__str__str_val(self):
-        arg = taskarg_factory(self.JobArgClass, arg_type='str', val='something')
+        arg = taskarg_factory(self.TaskArgClass, arg_type='str', val='something')
         self.assertEqual('something', str(arg.value()))
 
     def test__str__int_val(self):
-        arg = taskarg_factory(self.JobArgClass, arg_type='int', val='1')
+        arg = taskarg_factory(self.TaskArgClass, arg_type='int', val='1')
         self.assertEqual('1', str(arg.value()))
 
     def test__str__datetime_val(self):
         _time = timezone.now()
-        arg = taskarg_factory(self.JobArgClass, arg_type='datetime', val=str(_time))
+        arg = taskarg_factory(self.TaskArgClass, arg_type='datetime', val=str(_time))
         self.assertEqual(str(_time), str(arg.value()))
 
     def test__str__bool_val(self):
-        arg = taskarg_factory(self.JobArgClass, arg_type='bool', val='True')
+        arg = taskarg_factory(self.TaskArgClass, arg_type='bool', val='True')
         self.assertEqual('True', str(arg.value()))
 
     def test__repr__str_val(self):
-        arg = taskarg_factory(self.JobArgClass, arg_type='str', val='something')
+        arg = taskarg_factory(self.TaskArgClass, arg_type='str', val='something')
         self.assertEqual("'something'", repr(arg.value()))
 
     def test__repr__int_val(self):
-        arg = taskarg_factory(self.JobArgClass, arg_type='int', val='1')
+        arg = taskarg_factory(self.TaskArgClass, arg_type='int', val='1')
         self.assertEqual('1', repr(arg.value()))
 
     def test__repr__datetime_val(self):
         _time = timezone.now()
-        arg = taskarg_factory(self.JobArgClass, arg_type='datetime', val=str(_time))
+        arg = taskarg_factory(self.TaskArgClass, arg_type='datetime', val=str(_time))
         self.assertEqual(repr(_time), repr(arg.value()))
 
     def test__repr__bool_val(self):
-        arg = taskarg_factory(self.JobArgClass, arg_type='bool', val='False')
+        arg = taskarg_factory(self.TaskArgClass, arg_type='bool', val='False')
         self.assertEqual('False', repr(arg.value()))
 
     def test_callable_arg_type__clean(self):
         method = arg_callable
         arg = taskarg_factory(
-            self.JobArgClass, arg_type='callable',
+            self.TaskArgClass, arg_type='callable',
             val=f'{method.__module__}.{method.__name__}', )
         self.assertIsNone(arg.clean())
         self.assertEqual(1, arg.value())
         self.assertEqual(2, arg.value())
 
 
-class TestJobKwarg(TestAllJobArg):
-    JobArgClass = TaskKwarg
+class TestTaskKwarg(TestAllTaskArg):
+    TaskArgClass = TaskKwarg
 
     def test_str(self):
-        arg = taskarg_factory(self.JobArgClass)
+        arg = taskarg_factory(self.TaskArgClass)
         self.assertEqual(
-            f'JobKwarg[key={arg.key},arg_type={arg.arg_type},value={arg.val}]', str(arg))
+            f'TaskKwarg[key={arg.key},arg_type={arg.arg_type},value={arg.val}]', str(arg))
 
     def test_value(self):
-        kwarg = taskarg_factory(self.JobArgClass, key='key', arg_type='str', val='value')
+        kwarg = taskarg_factory(self.TaskArgClass, key='key', arg_type='str', val='value')
         self.assertEqual(kwarg.value(), ('key', 'value'))
 
     def test__str__str_val(self):
-        kwarg = taskarg_factory(self.JobArgClass, key='key', arg_type='str', val='something')
-        self.assertEqual('JobKwarg[key=key,arg_type=str,value=something]', str(kwarg))
+        kwarg = taskarg_factory(self.TaskArgClass, key='key', arg_type='str', val='something')
+        self.assertEqual('TaskKwarg[key=key,arg_type=str,value=something]', str(kwarg))
 
     def test__str__int_val(self):
-        kwarg = taskarg_factory(self.JobArgClass, key='key', arg_type='int', val=1)
-        self.assertEqual('JobKwarg[key=key,arg_type=int,value=1]', str(kwarg))
+        kwarg = taskarg_factory(self.TaskArgClass, key='key', arg_type='int', val=1)
+        self.assertEqual('TaskKwarg[key=key,arg_type=int,value=1]', str(kwarg))
 
     def test__str__datetime_val(self):
         _time = timezone.now()
-        kwarg = taskarg_factory(self.JobArgClass, key='key', arg_type='datetime', val=str(_time))
-        self.assertEqual(f'JobKwarg[key=key,arg_type=datetime,value={_time}]', str(kwarg))
+        kwarg = taskarg_factory(self.TaskArgClass, key='key', arg_type='datetime', val=str(_time))
+        self.assertEqual(f'TaskKwarg[key=key,arg_type=datetime,value={_time}]', str(kwarg))
 
     def test__str__bool_val(self):
-        kwarg = taskarg_factory(self.JobArgClass, key='key', arg_type='bool', val='True')
-        self.assertEqual('JobKwarg[key=key,arg_type=bool,value=True]', str(kwarg))
+        kwarg = taskarg_factory(self.TaskArgClass, key='key', arg_type='bool', val='True')
+        self.assertEqual('TaskKwarg[key=key,arg_type=bool,value=True]', str(kwarg))
 
     def test__repr__str_val(self):
-        kwarg = taskarg_factory(self.JobArgClass, key='key', arg_type='str', val='something')
+        kwarg = taskarg_factory(self.TaskArgClass, key='key', arg_type='str', val='something')
         self.assertEqual("('key', 'something')", repr(kwarg.value()))
 
     def test__repr__int_val(self):
-        kwarg = taskarg_factory(self.JobArgClass, key='key', arg_type='int', val='1')
+        kwarg = taskarg_factory(self.TaskArgClass, key='key', arg_type='int', val='1')
         self.assertEqual("('key', 1)", repr(kwarg.value()))
 
     def test__repr__datetime_val(self):
         _time = timezone.now()
-        kwarg = taskarg_factory(self.JobArgClass, key='key', arg_type='datetime', val=str(_time))
+        kwarg = taskarg_factory(self.TaskArgClass, key='key', arg_type='datetime', val=str(_time))
         self.assertEqual("('key', {})".format(repr(_time)), repr(kwarg.value()))
 
     def test__repr__bool_val(self):
-        kwarg = taskarg_factory(self.JobArgClass, key='key', arg_type='bool', val='True')
+        kwarg = taskarg_factory(self.TaskArgClass, key='key', arg_type='bool', val='True')
         self.assertEqual("('key', True)", repr(kwarg.value()))
diff --git a/scheduler/tests/test_models.py b/scheduler/tests/test_models.py
diff --git a/scheduler/tests/test_repeatable_task.py b/scheduler/tests/test_repeatable_task.py
