Refactor CI container deploy wrapper: add modes, rebuild/no-cache flags, and transparent inventory/deploy arg forwarding; update tests accordingly (see ChatGPT conversation: https://chatgpt.com/share/6931e58c-2ddc-800f-88d2-f7887ec13e25)

tests/unit/cli/deploy/test_container.py

@@ -11,22 +11,26 @@ from cli.deploy import container as deploy_container
 class TestEnsureImage(unittest.TestCase):
     @mock.patch("subprocess.run")
     def test_ensure_image_skips_build_when_image_exists(self, mock_run):
-        # docker image inspect → returncode 0 means "image exists"
+        """
+        If the image already exists, ensure_image should only call
+        `docker image inspect` and NOT run `docker build`.
+        """
+        # docker image inspect → rc=0 (image exists)
         mock_run.return_value = subprocess.CompletedProcess(
-            ["docker", "image", "inspect", "infinito:latest"],
-            0,
-            stdout=b"",
-            stderr=b"",
+            args=["docker", "image", "inspect", "infinito:latest"],
+            returncode=0,
+            stdout="",
+            stderr="",
         )
 
         deploy_container.ensure_image("infinito:latest")
 
-        # Only one call: docker image inspect
+        # Exactly one call: docker image inspect
         self.assertEqual(mock_run.call_count, 1)
         cmd = mock_run.call_args_list[0].args[0]
         self.assertEqual(cmd[:3], ["docker", "image", "inspect"])
 
-        # No docker build command
+        # Ensure docker build was never called
         self.assertFalse(
             any(
                 call.args[0][:2] == ["docker", "build"]
@@ -37,17 +41,40 @@ class TestEnsureImage(unittest.TestCase):
 
     @mock.patch("subprocess.run")
     def test_ensure_image_builds_when_missing(self, mock_run):
+        """
+        If the image does not exist, ensure_image should call
+        `docker image inspect` first and then `docker build`.
+        """
         calls: List[List[str]] = []
 
         def _side_effect(cmd, *args, **kwargs):
             calls.append(cmd)
-            # First inspect fails → triggers build
+
+            # First: docker image inspect → rc=1 (missing)
             if cmd[:3] == ["docker", "image", "inspect"]:
-                return subprocess.CompletedProcess(cmd, 1, b"", b"missing")
-            # Build succeeds
+                return subprocess.CompletedProcess(
+                    args=cmd,
+                    returncode=1,
+                    stdout="",
+                    stderr="missing",
+                )
+
+            # Then: docker build → rc=0 (success)
             if cmd[:2] == ["docker", "build"]:
-                return subprocess.CompletedProcess(cmd, 0, b"", b"")
-            return subprocess.CompletedProcess(cmd, 0, b"", b"")
+                return subprocess.CompletedProcess(
+                    args=cmd,
+                    returncode=0,
+                    stdout="",
+                    stderr="",
+                )
+
+            # Any other commands (should not happen here)
+            return subprocess.CompletedProcess(
+                args=cmd,
+                returncode=0,
+                stdout="",
+                stderr="",
+            )
 
         mock_run.side_effect = _side_effect
 
@@ -55,44 +82,53 @@ class TestEnsureImage(unittest.TestCase):
 
         self.assertTrue(
             any(c[:3] == ["docker", "image", "inspect"] for c in calls),
-            "Expected docker image inspect to be called",
+            "Expected 'docker image inspect' to be called",
         )
         self.assertTrue(
             any(c[:2] == ["docker", "build"] for c in calls),
-            "Expected docker build to run when image is missing",
+            "Expected 'docker build' to run when image is missing",
         )
 
+
 class TestRunInContainer(unittest.TestCase):
     @mock.patch("subprocess.run")
     def test_run_in_container_calls_single_docker_run(self, mock_run):
         """
-        Current container.py starts exactly one Docker container via
-        'docker run' to launch the inner dockerd daemon. All further work
-        (inventory creation + dedicated deploy) happens via docker exec.
+        run_in_container should start exactly one 'docker run' CI container,
+        then use docker exec for everything else.
         """
         calls: List[List[str]] = []
 
         def _side_effect(cmd, *args, **kwargs):
             calls.append(cmd)
-            return subprocess.CompletedProcess(cmd, 0, b"", b"")
+            # Always succeed → wait_for_inner_docker stops on first call
+            return subprocess.CompletedProcess(
+                args=cmd,
+                returncode=0,
+                stdout="",
+                stderr="",
+            )
 
         mock_run.side_effect = _side_effect
 
         image = "infinito:latest"
-        exclude = "foo,bar"
-        forwarded = ["-T", "server", "--debug", "--skip-tests"]
+        inventory_args = ["--include", "svc-db-mariadb"]
+        deploy_args = ["-T", "server", "--debug", "--skip-tests"]
 
         deploy_container.run_in_container(
             image=image,
-            exclude=exclude,
-            forwarded_args=forwarded,
             build=False,
+            rebuild=False,
+            no_cache=False,
+            inventory_args=inventory_args,
+            deploy_args=deploy_args,
+            name=None,
         )
 
-        # We expect at least one subprocess.run call
+        # At least one command must have been executed
         self.assertGreaterEqual(len(calls), 1)
 
-        # Only count *docker run* invocations, not docker exec / image / build
+        # Filter all docker run invocations
         docker_run_calls = [
             c
             for c in calls
@@ -105,16 +141,12 @@ class TestRunInContainer(unittest.TestCase):
         self.assertEqual(
             len(docker_run_calls),
             1,
-            "Expected exactly one 'docker run' call",
+            "Expected exactly one 'docker run' call (for the CI container)",
         )
 
         cmd = docker_run_calls[0]
-
-        # Basic structure of the docker run call
         self.assertEqual(cmd[0], "docker")
         self.assertEqual(cmd[1], "run")
-
-        # New behavior: container runs dockerd in detached mode
         self.assertIn("-d", cmd)
         self.assertIn("--name", cmd)
         self.assertIn("--network=host", cmd)
@@ -123,17 +155,23 @@ class TestRunInContainer(unittest.TestCase):
         self.assertIn(image, cmd)
         self.assertIn("dockerd", cmd)
 
-        # We *no longer* expect '--rm', '/bin/sh', or '-lc' here,
-        # because all higher-level logic is executed by docker exec.
-
 
 class TestMain(unittest.TestCase):
     @mock.patch("cli.deploy.container.run_in_container")
     def test_main_requires_forwarded_args(self, mock_run_in_container):
         """
-        If no arguments follow '--', main() must return exit code 1 and not call run_in_container().
+        In 'run' mode, main() must return 1 and not call run_in_container()
+        if no deploy arguments are provided after the first '--'.
         """
-        argv = ["cli.deploy.container"]  # realistic argv from `python -m ...`
+        argv = [
+            "cli.deploy.container",
+            "run",
+            "--image",
+            "myimage:latest",
+            "--build",
+            "--",
+            # no inventory/deploy args here
+        ]
         with mock.patch.object(sys, "argv", argv):
             rc = deploy_container.main()
 
@@ -143,15 +181,21 @@ class TestMain(unittest.TestCase):
     @mock.patch("cli.deploy.container.run_in_container")
     def test_main_passes_arguments_to_run_in_container(self, mock_run_in_container):
         """
-        Ensure CLI args are parsed and forwarded correctly.
+        Ensure that main() correctly splits container args vs inventory/deploy
+        args and passes them to run_in_container().
         """
         argv = [
             "cli.deploy.container",
-            "--image", "myimage:latest",
-            "--exclude", "foo,bar",
+            "run",
+            "--image",
+            "myimage:latest",
             "--build",
             "--",
-            "-T", "server",
+            "--exclude",
+            "foo,bar",
+            "--",
+            "-T",
+            "server",
             "--debug",
         ]
 
@@ -161,14 +205,24 @@ class TestMain(unittest.TestCase):
         self.assertEqual(rc, 0)
         mock_run_in_container.assert_called_once()
 
-        # access kwargs passed to run_in_container
         kwargs = mock_run_in_container.call_args.kwargs
 
+        # Container-level options
         self.assertEqual(kwargs["image"], "myimage:latest")
-        self.assertEqual(kwargs["exclude"], "foo,bar")  # <-- fixed key
         self.assertTrue(kwargs["build"])
+        self.assertFalse(kwargs["rebuild"])
+        self.assertFalse(kwargs["no_cache"])
+        self.assertIsNone(kwargs["name"])
+
+        # Inventory args: first segment after first '--' until second '--'
         self.assertEqual(
-            kwargs["forwarded_args"],
+            kwargs["inventory_args"],
+            ["--exclude", "foo,bar"],
+        )
+
+        # Deploy args: everything after the second '--'
+        self.assertEqual(
+            kwargs["deploy_args"],
             ["-T", "server", "--debug"],
         )