[ADD] queue_job: HttpCase regression tests for /queue_job/runjob

Adds an HttpJobCaseMixin in tests/common.py providing a reusable
run_http_job() helper for tests that exercise /queue_job/runjob.

New test_run_job_controller_http.py covers #922:
- test_runjob_pins_default_env_to_superuser asserts that during
  job.perform() the transaction's default_env.uid is SUPERUSER_ID.
- test_runjob_without_updating_default_env_leaves_uid_none substitutes
  an alternative runjob that only swaps the local env and verifies
  default_env.uid stays None, isolating default_env repointing as the
  load-bearing behavior of the endpoint.

Author: dannyadair

queue_job/tests/__init__.py

@@ -1,3 +1,4 @@
+from . import test_run_job_controller_http
 from . import test_run_rob_controller
 from . import test_runner_channels
 from . import test_runner_runner

queue_job/tests/common.py

@@ -321,6 +321,44 @@ def __repr__(self):
         return repr(self.calls)
 
 
+class HttpJobCaseMixin:
+    """Mixin for tests that exercise the ``/queue_job/runjob`` HTTP endpoint.
+
+    Combine with :class:`odoo.tests.common.HttpCase`. Example::
+
+        @tagged("-at_install", "post_install")
+        class TestSomeJob(HttpJobCaseMixin, HttpCase):
+            def test_something(self):
+                delayable = self.env["queue.job"].with_delay()._test_job()
+                record = self.run_http_job(delayable)
+                self.assertEqual(record.state, "done")
+    """
+
+    def run_http_job(self, job_or_uuid):
+        """Hit ``/queue_job/runjob`` for the given job.
+
+        Commits the current transaction so the HTTP server's cursor can see
+        the enqueued job, performs the request, then commits again to pull
+        in state changes written by the request. Returns the reloaded
+        ``queue.job`` record.
+        """
+        uuid = (
+            job_or_uuid
+            if isinstance(job_or_uuid, str)
+            else job_or_uuid.db_record().uuid
+        )
+        # Commits are required so the HTTP server's cursor (running in a
+        # different thread within the same process) can see the enqueued job
+        # and then the test can observe the state changes it wrote back.
+        self.env.cr.commit()  # pylint: disable=invalid-commit
+        response = self.url_open(
+            f"/queue_job/runjob?db={self.env.cr.dbname}&job_uuid={uuid}"
+        )
+        response.raise_for_status()
+        self.env.cr.commit()  # pylint: disable=invalid-commit
+        return self.env["queue.job"].search([("uuid", "=", uuid)])
+
+
 class JobCounter:
     def __init__(self, env):
         super().__init__()

queue_job/tests/test_run_job_controller_http.py

@@ -0,0 +1,109 @@
+# License AGPL-3.0 or later (https://www.gnu.org/licenses/agpl).
+
+from unittest import mock
+
+from odoo import SUPERUSER_ID, http
+from odoo.tests.common import HttpCase, tagged
+
+from ..controllers.main import RunJobController
+from ..job import Job
+from .common import HttpJobCaseMixin
+
+
+@tagged("-at_install", "post_install")
+class TestRunJobHttp(HttpJobCaseMixin, HttpCase):
+    """End-to-end tests for the ``/queue_job/runjob`` endpoint.
+
+    ``runjob`` is declared ``auth="none"``, so ``_auth_method_none`` pins
+    ``transaction.default_env`` to an env with ``uid=None``. The controller
+    must additionally repoint ``default_env`` to a superuser env, otherwise
+    any flush during ``job.perform()`` that goes through
+    ``Transaction.flush() -> default_env.flush_all()`` recomputes stored
+    fields with ``self.env.user`` as an empty recordset. See #922.
+    """
+
+    def _capture_default_env_uid_during(self, delayable):
+        """Run ``delayable`` via /queue_job/runjob and observe the transaction's
+        ``default_env.uid`` from inside ``job.perform()``.
+
+        Installs a spy around ``Job.perform`` that records
+        ``job.env.transaction.default_env.uid`` before delegating to the real
+        implementation. HttpCase runs the HTTP server in the same process,
+        so the class-level ``mock.patch`` takes effect on the server side too.
+
+        :param delayable: a delayed job (return value of
+            ``with_delay().method()``)
+        :returns: ``(default_env_uid, queue_job_record)`` -- the uid observed
+            during ``perform()`` and the reloaded ``queue.job`` record after
+            the request completes.
+        """
+        captured = {}
+        original_perform = Job.perform
+
+        def spy(job):
+            captured["default_env_uid"] = job.env.transaction.default_env.uid
+            return original_perform(job)
+
+        with mock.patch.object(Job, "perform", spy):
+            record = self.run_http_job(delayable)
+
+        return captured["default_env_uid"], record
+
+    def test_runjob_pins_default_env_to_superuser(self):
+        """``runjob`` must set ``transaction.default_env`` to a superuser env.
+
+        Verifies that during ``job.perform()``,
+        ``env.transaction.default_env.uid`` is ``SUPERUSER_ID``. This is the
+        state that lets flushes triggered by the job recompute stored fields
+        with a real ``self.env.user`` rather than an empty recordset.
+        """
+        delayable = (
+            self.env["queue.job"]
+            .with_delay(description="check default_env uid (superuser)")
+            ._test_job()
+        )
+
+        default_env_uid, record = self._capture_default_env_uid_during(delayable)
+
+        self.assertEqual(record.state, "done")
+        self.assertEqual(default_env_uid, SUPERUSER_ID)
+
+    def test_runjob_without_updating_default_env_leaves_uid_none(self):
+        """Repointing ``default_env`` is the specific mechanism this relies on.
+
+        Substitutes an alternative ``runjob`` that only creates a local
+        superuser env (via ``http.request.env(user=SUPERUSER_ID)``) without
+        touching ``transaction.default_env``, and verifies that the observable
+        ``default_env.uid`` inside ``job.perform()`` is then ``None``. This
+        isolates ``default_env`` repointing as the load-bearing behavior of
+        ``runjob``: any future refactor that drops it will trip this test.
+        """
+
+        def runjob_local_env_only(self_, db, job_uuid, **kw):
+            """Alternative ``runjob`` that swaps only the local ``env``.
+
+            Uses ``http.request.env(user=SUPERUSER_ID)`` to obtain a
+            superuser env for controller bookkeeping (acquire, lock, commit
+            state changes), but does not update ``request.env`` or
+            ``transaction.default_env``, which remain the ``uid=None`` env
+            installed by ``_auth_method_none``.
+            """
+            http.request.session.db = db
+            env = http.request.env(user=SUPERUSER_ID)
+            job = self_._acquire_job(env, job_uuid)
+            if not job:
+                return ""
+            self_._runjob(env, job)
+            return ""
+
+        delayable = (
+            self.env["queue.job"]
+            .with_delay(description="check default_env uid (local env only)")
+            ._test_job()
+        )
+
+        with mock.patch.object(RunJobController, "runjob", runjob_local_env_only):
+            default_env_uid, record = self._capture_default_env_uid_during(delayable)
+
+        self.assertEqual(record.state, "done")
+        self.assertIsNone(default_env_uid)