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

@@ -6,6 +6,7 @@
 
 from lxml import etree
 
+from odoo import Command
 from odoo.tests import common
 
 # pylint: disable=odoo-addons-relative-import
@@ -14,8 +15,23 @@
 
 
 class TestJson(common.TransactionCase):
+    @classmethod
+    def setUpClass(cls):
+        res = super().setUpClass()
+        company = cls.env.ref("base.main_company")
+        cls.demo_user = cls.env["res.users"].create(
+            {
+                "name": "Demo User",
+                "login": "demo_demo_demo",
+                "company_id": company.id,
+                "company_ids": [Command.set(company.ids)],
+                "group_ids": [Command.set(cls.env.ref("base.group_user").ids)],
+            }
+        )
+        return res
+
     def test_encoder_recordset(self):
-        demo_user = self.env.ref("base.user_demo")
+        demo_user = self.demo_user
         context = demo_user.context_get()
         partner = self.env(user=demo_user, context=context).ref("base.main_partner")
         value = partner
@@ -33,7 +49,7 @@ def test_encoder_recordset(self):
         self.assertEqual(json.loads(value_json), expected)
 
     def test_encoder_recordset_list(self):
-        demo_user = self.env.ref("base.user_demo")
+        demo_user = self.demo_user
         context = demo_user.context_get()
         partner = self.env(user=demo_user, context=context).ref("base.main_partner")
         value = ["a", 1, partner]
@@ -55,7 +71,7 @@ def test_encoder_recordset_list(self):
         self.assertEqual(json.loads(value_json), expected)
 
     def test_decoder_recordset(self):
-        demo_user = self.env.ref("base.user_demo")
+        demo_user = self.demo_user
         context = demo_user.context_get()
         partner = self.env(user=demo_user).ref("base.main_partner")
 
@@ -76,7 +92,7 @@ def test_decoder_recordset(self):
         self.assertEqual(demo_user, expected.env.user)
 
     def test_decoder_recordset_list(self):
-        demo_user = self.env.ref("base.user_demo")
+        demo_user = self.demo_user
         context = demo_user.context_get()
         partner = self.env(user=demo_user).ref("base.main_partner")
         value_json = json.dumps(
@@ -100,7 +116,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 +148,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/common.py

@@ -1,6 +1,7 @@
 # Copyright 2016-2019 Camptocamp SA
 # License LGPL-3.0 or later (http://www.gnu.org/licenses/lgpl.html)
 
+from odoo import Command
 from odoo.tests import common
 
 from odoo.addons.queue_job.job import Job
@@ -13,6 +14,16 @@ def setUpClass(cls):
         cls.queue_job = cls.env["queue.job"]
         cls.user = cls.env["res.users"]
         cls.method = cls.env["test.queue.job"].testing_method
+        company = cls.env.ref("base.main_company")
+        cls.demo_user = cls.user.create(
+            {
+                "name": "Demo User",
+                "login": "demo_demo_demo",
+                "company_id": company.id,
+                "company_ids": [Command.set(company.ids)],
+                "group_ids": [Command.set(cls.env.ref("base.group_user").ids)],
+            }
+        )
 
     def _create_job(self):
         test_job = Job(self.method)

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)
@@ -490,24 +491,22 @@ def test_job_with_mutable_arguments(self):
         self.assertEqual({"mutable_kwarg": {"a": 1}}, job_instance.kwargs)
 
     def test_store_env_su_no_sudo(self):
-        demo_user = self.env.ref("base.user_demo")
-        self.env = self.env(user=demo_user)
+        self.env = self.env(user=self.demo_user)
         delayable = self.env["test.queue.job"].with_delay()
         test_job = delayable.testing_method()
         stored = test_job.db_record()
         job_instance = Job.load(self.env, stored.uuid)
         self.assertFalse(job_instance.recordset.env.su)
-        self.assertTrue(job_instance.user_id, demo_user)
+        self.assertTrue(job_instance.user_id, self.demo_user)
 
     def test_store_env_su_sudo(self):
-        demo_user = self.env.ref("base.user_demo")
-        self.env = self.env(user=demo_user)
+        self.env = self.env(user=self.demo_user)
         delayable = self.env["test.queue.job"].sudo().with_delay()
         test_job = delayable.testing_method()
         stored = test_job.db_record()
         job_instance = Job.load(self.env, stored.uuid)
         self.assertTrue(job_instance.recordset.env.su)
-        self.assertTrue(job_instance.user_id, demo_user)
+        self.assertTrue(job_instance.user_id, self.demo_user)
 
 
 class TestJobModel(JobCommonCase):
@@ -604,17 +603,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()
@@ -638,10 +637,9 @@ def test_override_channel(self):
         self.assertEqual("root.sub.sub", test_job.channel)
 
     def test_job_change_user_id(self):
-        demo_user = self.env.ref("base.user_demo")
         stored = self._create_job()
-        stored.user_id = demo_user
-        self.assertEqual(stored.records.env.uid, demo_user.id)
+        stored.user_id = self.demo_user
+        self.assertEqual(stored.records.env.uid, self.demo_user.id)
 
 
 class TestJobStorageMultiCompany(common.TransactionCase):
@@ -663,10 +661,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 +682,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 +702,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 +759,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
         )