DockerRunner: Enable background container to run commands against

tests/integration/framework/docker_runner.py

@@ -8,49 +8,93 @@
 import sys
 
 class DockerRunner:
-    """Run docker containers for testing"""
+    """Run a docker container in background to execute testing commands"""
 
     def __init__(self, platform, image, verbose):
         """Sets platform and image for all tests ran with this instance"""
         self.platform = platform
         self.image = image
         self.verbose = verbose
+        self.container_id = None
 
-    def construct_docker_command(self, envs, args):
+        # Launch the container
+        self._start()
+
+    def execute(self, envs, args):
+        """Launch `docker exec` commands inside the background container"""
+        command = self._construct_command("exec", envs, args)
+        return self._shell(command)
+
+    def run(self, envs, args):
+        """
+        Launch `docker run` commands to create a new container for each command
+        """
+        command = self._construct_command("run", envs, args)
+        return self._shell(command)
+
+    def __del__(self):
+        """Remove test container"""
+        stop_command = ["docker", "rm", "-f", self.container_id]
+        self._shell(stop_command, silent=True)
+
+    def _start(self):
         """
-        Construct a docker command with env and args
+        Launch a docker container. Done in 2 step using create + start.
+
+        Keep the container running with a shell open thanks to `--interactive`,
+        having stdin open keep the process running.
         """
-        command = ["docker", "run", "--platform", self.platform]
+        create_command = [
+                "docker", "create",
+                "--platform", self.platform,
+                "--interactive",
+                self.image,
+                "/bin/bash",
+                ]
+        self.container_id = self._shell(create_command, silent=True)
+
+        start_command = [
+                "docker", "start", self.container_id
+                ]
+        self._shell(start_command, silent=True)
+
+    def _shell(self, command, silent=False):
+        """Run an arbitrary shell command and return its output"""
+        if self.verbose and not silent:
+            print(f"$ { ' '.join(command) }")
+
+        try:
+            result = subprocess.run(command, capture_output=True, check=True)
+        except subprocess.CalledProcessError as command_err:
+            print(command_err.stdout.decode("utf-8"), file=sys.stdout)
+            print(command_err.stderr.decode("utf-8"), file=sys.stderr)
+            raise command_err
+
+        return result.stdout.decode("utf-8").strip()
+
+    def _construct_command(self, docker_cmd, envs, args):
+        """Construct a docker command with env and args"""
+        command = ["docker", docker_cmd]
 
         for env in envs:
             command.append("-e")
             command.append(env)
 
-        command.append(self.image)
-
-        for arg in args:
-            command.append(arg)
-
-        return command
+        # Use container or image depending on command type
+        if docker_cmd == "exec":
+            tag = self.container_id
+        elif docker_cmd == "run":
+            tag = self.image
 
-    def run_interactive_command(self, envs, args):
-        """
-        Run our target docker image with a list of
-        environment variables and a list of arguments
-        """
-        command = self.construct_docker_command(envs, args)
+        command.append(tag)
 
-        if self.verbose:
-            print(f"Running command: { ' '.join(command) }")
+        # Launch all shell commands using entrypoint.py only
+        command.append("entrypoint.py")
 
-        try:
-            output = subprocess.run(command, capture_output=True, check=True)
-        except subprocess.CalledProcessError as docker_err:
-            print(f"Error while running command: { ' '.join(command) }", file=sys.stderr)
-            print(docker_err, file=sys.stderr)
-            print(docker_err.stderr.decode("utf-8"), file=sys.stderr)
-            print(docker_err.stdout.decode("utf-8"), file=sys.stdout)
+        # Need to add a default executables added by CMD normally
+        if len(args) == 0 or args[0].startswith("-"):
+            command.append("dogecoind")
 
-            raise docker_err
+        command.extend(args)
 
-        return output
+        return command

tests/integration/framework/test_runner.py

@@ -15,8 +15,8 @@ class TestConfigurationError(Exception):
 class TestRunner:
     """Base class to define and run Dogecoin Core Docker tests with"""
     def __init__(self):
-        """Make sure there is an options object"""
         self.options = {}
+        self.container = None
 
     def add_options(self, parser):
         """Allow adding options in tests"""
@@ -25,15 +25,22 @@ def run_test(self):
         """Actual test, must be implemented by the final class"""
         raise NotImplementedError
 
-    def run_command(self, envs, args):
-        """Run a docker command with env and args"""
+    def docker_exec(self, envs, args):
+        """
+        Launch `docker exec` command, run command inside a background container.
+        Let execute mutliple instructions in the same container.
+        """
         assert self.options.platform is not None
         assert self.options.image is not None
 
-        runner = DockerRunner(self.options.platform,
-            self.options.image, self.options.verbose)
+        return self.container.execute(envs, args)
 
-        return runner.run_interactive_command(envs, args)
+    def docker_run(self, envs, args):
+        """Launch `docker run` command, create a new container for each run"""
+        assert self.options.platform is not None
+        assert self.options.image is not None
+
+        return self.container.run(envs, args)
 
     def main(self):
         """main loop"""
@@ -48,6 +55,9 @@ def main(self):
         self.add_options(parser)
         self.options = parser.parse_args()
 
+        self.container = DockerRunner(self.options.platform,
+                self.options.image, self.options.verbose)
+
         self.run_test()
         print("Tests successful")
         sys.exit(0)

tests/integration/version.py

@@ -27,21 +27,21 @@ def run_test(self):
         self.version_expr = re.compile(f".*{ self.options.version }.*")
 
         # check dogecoind with only env
-        dogecoind = self.run_command(["VERSION=1"], [])
-        self.ensure_version_on_first_line(dogecoind.stdout)
+        dogecoind = self.docker_exec(["VERSION=1"], [])
+        self.ensure_version_on_first_line(dogecoind)
 
         # check dogecoin-cli
-        dogecoincli = self.run_command([], ["dogecoin-cli", "-?"])
-        self.ensure_version_on_first_line(dogecoincli.stdout)
+        dogecoincli = self.docker_exec([], ["dogecoin-cli", "-?"])
+        self.ensure_version_on_first_line(dogecoincli)
 
         # check dogecoin-tx
-        dogecointx = self.run_command([], ["dogecoin-tx", "-?"])
-        self.ensure_version_on_first_line(dogecointx.stdout)
+        dogecointx = self.docker_exec([], ["dogecoin-tx", "-?"])
+        self.ensure_version_on_first_line(dogecointx)
 
         # make sure that we find version errors
         caught_error = False
         try:
-            self.ensure_version_on_first_line("no version here".encode('utf-8'))
+            self.ensure_version_on_first_line("no version here")
         except AssertionError:
             caught_error = True
 
@@ -50,7 +50,7 @@ def run_test(self):
 
     def ensure_version_on_first_line(self, cmd_output):
         """Assert that the version is contained in the first line of output string"""
-        first_line = cmd_output.decode("utf-8").split("\n")[0]
+        first_line = cmd_output.split("\n")[0]
 
         if re.match(self.version_expr, first_line) is None:
             text = f"Could not find version { self.options.version } in { first_line }"