various clean ups - tests passing

Author: richard-willdooit

queue_job/controllers/main.py

@@ -280,7 +280,7 @@ def _create_graph_test_jobs(
                         priority=priority,
                         max_retries=max_retries,
                         channel=channel,
-                        description="%s #%d" % (description, current_count),
+                        description=f"{description} #{current_count}",
                     )._test_job(failure_rate=failure_rate)
                 )
 

queue_job/job.py

@@ -505,7 +505,7 @@ def perform(self):
                 # traceback and message:
                 # http://blog.ianbicking.org/2007/09/12/re-raising-exceptions/
                 new_exc = FailedJobError(
-                    "Max. retries (%d) reached: %s" % (self.max_retries, value or type_)
+                    f"Max. retries ({self.max_retries}) reached: {value or type_}"
                 )
                 raise new_exc from err
             raise
@@ -813,7 +813,7 @@ def set_failed(self, **kw):
                 setattr(self, k, v)
 
     def __repr__(self):
-        return "<Job %s, priority:%d>" % (self.uuid, self.priority)
+        return f"<Job {self.uuid}, priority:{self.priority}>"
 
     def _get_retry_seconds(self, seconds=None):
         retry_pattern = self.job_config.retry_pattern
@@ -856,8 +856,7 @@ def related_action(self):
             funcname = record._default_related_action
         if not isinstance(funcname, str):
             raise ValueError(
-                "related_action must be the name of the "
-                "method on queue.job as string"
+                "related_action must be the name of the method on queue.job as string"
             )
         action = getattr(record, funcname)
         action_kwargs = self.job_config.related_action_kwargs

queue_job/jobrunner/channels.py

@@ -455,12 +455,9 @@ def get_subchannel_by_name(self, subchannel_name):
 
     def __str__(self):
         capacity = "∞" if self.capacity is None else str(self.capacity)
-        return "%s(C:%s,Q:%d,R:%d,F:%d)" % (
-            self.fullname,
-            capacity,
-            len(self._queue),
-            len(self._running),
-            len(self._failed),
+        return (
+            f"{self.fullname}(C:{capacity},"
+            f"Q:{self._queue},R:{self._running},F:{self._failed})"
         )
 
     def remove(self, job):
@@ -894,8 +891,7 @@ def parse_simple_config(cls, config_string):
                         )
                     if k in config:
                         raise ValueError(
-                            f"Invalid channel config {config_string}: "
-                            f"duplicate key {k}"
+                            f"Invalid channel config {config_string}: duplicate key {k}"
                         )
                     config[k] = v
             else:

queue_job/models/base.py

@@ -260,11 +260,15 @@ def _job_prepare_context_before_enqueue(self):
             if key in self._job_prepare_context_before_enqueue_keys()
         }
 
+    # Odoo have deprecated _patch_method and api.propagate in v16
     @classmethod
     def _patch_method(cls, name, method):
         origin = getattr(cls, name)
         method.origin = origin
-        # propagate decorators from origin to method, and apply api decorator
-        wrapped = api.propagate(origin, method)
-        wrapped.origin = origin
-        setattr(cls, name, wrapped)
+
+        # propagate appeared to only deal with the returns decorator
+        # which is now, also, deprecated
+        # wrapped = api.propagate(origin, method)
+        # wrapped.origin = origin
+        # setattr(cls, name, wrapped)
+        setattr(cls, name, method)

queue_job/models/queue_job.py

@@ -140,20 +140,18 @@ def init(self):
 
     @api.depends("dependencies")
     def _compute_dependency_graph(self):
-        jobs_groups = self.env["queue.job"].read_group(
+        jobs_groups = self.env["queue.job"]._read_group(
             [
                 (
                     "graph_uuid",
                     "in",
                     [uuid for uuid in self.mapped("graph_uuid") if uuid],
                 )
             ],
-            ["graph_uuid", "ids:array_agg(id)"],
             ["graph_uuid"],
+            ["id:array_agg"],
         )
-        ids_per_graph_uuid = {
-            group["graph_uuid"]: group["ids"] for group in jobs_groups
-        }
+        ids_per_graph_uuid = {group[0]: group[1] for group in jobs_groups}
         for record in self:
             if not record.graph_uuid:
                 record.dependency_graph = {}
@@ -211,7 +209,7 @@ def _dependency_graph_vis_node(self):
         }
 
     def _compute_graph_jobs_count(self):
-        jobs_groups = self.env["queue.job"].read_group(
+        jobs_groups = self.env["queue.job"]._read_group(
             [
                 (
                     "graph_uuid",
@@ -351,7 +349,7 @@ def _subscribe_users_domain(self):
         if not group:
             return None
         companies = self.mapped("company_id")
-        domain = [("groups_id", "=", group.id)]
+        domain = [("group_ids", "=", group.id)]
         if companies:
             domain.append(("company_id", "in", companies.ids))
         return domain

queue_job/tests/common.py

@@ -211,7 +211,7 @@ def assert_enqueued_job(self, method, args=None, kwargs=None, properties=None):
 
         if expected_call not in actual_calls:
             raise AssertionError(
-                "Job {} was not enqueued.\n" "Actual enqueued jobs:\n{}".format(
+                "Job {} was not enqueued.\nActual enqueued jobs:\n{}".format(
                     self._format_job_call(expected_call),
                     "\n".join(
                         f" * {self._format_job_call(call)}" for call in actual_calls

queue_job/tests/test_json_field.py

@@ -100,7 +100,7 @@ def test_decoder_recordset_list(self):
 
     def test_decoder_recordset_list_without_user(self):
         value_json = (
-            '["a", 1, {"_type": "odoo_recordset",' '"model": "res.users", "ids": [1]}]'
+            '["a", 1, {"_type": "odoo_recordset","model": "res.users", "ids": [1]}]'
         )
         expected = ["a", 1, self.env.ref("base.user_root")]
         value = json.loads(value_json, cls=JobDecoder, env=self.env)
@@ -132,7 +132,7 @@ def test_encoder_date(self):
         self.assertEqual(json.loads(value_json), expected)
 
     def test_decoder_date(self):
-        value_json = '["a", 1, {"_type": "date_isoformat",' '"value": "2017-04-19"}]'
+        value_json = '["a", 1, {"_type": "date_isoformat","value": "2017-04-19"}]'
         expected = ["a", 1, date(2017, 4, 19)]
         value = json.loads(value_json, cls=JobDecoder, env=self.env)
         self.assertEqual(value, expected)

test_queue_job/tests/test_autovacuum.py

@@ -19,7 +19,8 @@ def test_old_jobs_are_deleted_by_cron_job(self):
         )
         stored = self._create_job()
         stored.write({"date_done": date_done})
-        self.cron_job.method_direct_trigger()
+        with self.enter_registry_test_mode():
+            self.cron_job.method_direct_trigger()
         self.assertFalse(stored.exists())
 
     def test_autovacuum(self):

test_queue_job/tests/test_job.py

@@ -6,6 +6,7 @@
 from unittest import mock
 
 import odoo.tests.common as common
+from odoo import Command
 
 from odoo.addons.queue_job import identity_exact
 from odoo.addons.queue_job.delay import DelayableGraph
@@ -208,7 +209,7 @@ def test_company_complex(self):
         company1 = self.env.ref("base.main_company")
         company2 = company1.create({"name": "Queue job company"})
         companies = company1 | company2
-        self.env.user.write({"company_ids": [(6, False, companies.ids)]})
+        self.env.user.write({"company_ids": [Command.set(companies.ids)]})
         # Ensure the main company still the first
         self.assertEqual(self.env.user.company_id, company1)
         eta = datetime.now() + timedelta(hours=5)
@@ -604,17 +605,17 @@ def test_follower_when_write_fail(self):
         vals = {
             "name": "xx",
             "login": "xx",
-            "groups_id": [(6, 0, [group.id])],
+            "group_ids": [Command.set(group.ids)],
             "active": False,
         }
         inactiveusr = self.user.create(vals)
         inactiveusr.partner_id.active = True
-        self.assertFalse(inactiveusr in group.users)
+        self.assertFalse(inactiveusr in group.user_ids)
         stored = self._create_job()
         stored.write({"state": "failed"})
         followers = stored.message_follower_ids.mapped("partner_id")
         self.assertFalse(inactiveusr.partner_id in followers)
-        self.assertFalse({u.partner_id for u in group.users} - set(followers))
+        self.assertFalse({u.partner_id for u in group.user_ids} - set(followers))
 
     def test_wizard_requeue(self):
         stored = self._create_job()
@@ -663,10 +664,10 @@ def setUp(self):
         self.simple_user = User.create(
             {
                 "partner_id": self.partner_user.id,
-                "company_ids": [(4, main_company.id)],
+                "company_ids": [Command.link(main_company.id)],
                 "login": "simple_user",
                 "name": "simple user",
-                "groups_id": [],
+                "group_ids": [],
             }
         )
 
@@ -684,10 +685,10 @@ def setUp(self):
             {
                 "partner_id": self.other_partner_a.id,
                 "company_id": self.other_company_a.id,
-                "company_ids": [(4, self.other_company_a.id)],
+                "company_ids": [Command.link(self.other_company_a.id)],
                 "login": "my_login a",
                 "name": "my user A",
-                "groups_id": [(4, grp_queue_job_manager)],
+                "group_ids": [Command.link(grp_queue_job_manager)],
             }
         )
         self.other_partner_b = Partner.create(
@@ -704,10 +705,10 @@ def setUp(self):
             {
                 "partner_id": self.other_partner_b.id,
                 "company_id": self.other_company_b.id,
-                "company_ids": [(4, self.other_company_b.id)],
+                "company_ids": [Command.link(self.other_company_b.id)],
                 "login": "my_login_b",
                 "name": "my user B",
-                "groups_id": [(4, grp_queue_job_manager)],
+                "group_ids": [Command.link(grp_queue_job_manager)],
             }
         )
 
@@ -761,7 +762,7 @@ def test_job_subscription(self):
         stored._message_post_on_failure()
         users = (
             User.search(
-                [("groups_id", "=", self.ref("queue_job.group_queue_job_manager"))]
+                [("group_ids", "=", self.ref("queue_job.group_queue_job_manager"))]
             )
             + stored.user_id
         )