hector-cli 0.4.0__tar.gz → 0.6.0__tar.gz

{hector_cli-0.4.0 → hector_cli-0.6.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hector-cli
-Version: 0.4.0
+Version: 0.6.0
 Summary: YAML-driven Renode + Verilator simulation orchestrator for embedded hardware CI
 Home-page: https://hector-ci.com
 Author: Nemesis
@@ -206,6 +206,7 @@ the CLI natively with `pip` and let hector launch real per-step containers.
 | `hector run --gather-execution-metrics boardA --gather-execution-metrics boardB` | Enable profiler for selected machines |
 | `hector run --renode-version 1.16.1` | Override the Renode version from `.hector.yaml` |
 | `hector run --renode-image my-renode:dev` | Use a specific (e.g. self-built) Renode Docker image |
+| `hector run --docker-args '-v /opt/tools:/opt/tools'` | Add extra flags (mounts, env, …) to every `docker run` |
 | `hector run --renode-dir /cache/renode` | Use/cache the Renode source checkout at this path (only fetched when needed) |
 | `hector run --renode-integration-dir /cache/integration` | Likewise for the verilator-integration checkout |
 | `hector run --no-docker` | Use locally installed `renode` / `renode-test` instead of Docker |
@@ -482,6 +483,36 @@ hector run --renode-args '--console'
 hector run --renode-args '--hide-log --config my.conf'
 ```
 
+#### Paths and working directory
+
+Everything a hectorfile executes — `build:` steps, `shell` tests, Renode and `renode-test` — runs **in the hectorfile's folder**, and paths written in the file (`firmware:`, `platform:`, module `source:`, test `file:` / `snapshot:`, `file:` mappings, `artifacts:`, paths inside scripts and `commands:`) are **relative to that folder**. So `hector test -f boards/nucleo/.hector.yaml` behaves the same as running `hector test` inside `boards/nucleo/`.
+
+The directory you run hector from is mounted into the container (at the same path), and the container's working directory (`-w`) is the hectorfile's folder. If the hectorfile lives **outside** the directory you run from (`hector test -f ../other/.hector.yaml`), its folder is mounted as well, at its own path. A path like `../shared/board.repl` works as long as it lands inside one of those mounts — for anything else, add a mount with [`docker_args`](#extra-docker-flags---docker-args). Under `--no-docker` the processes simply run with the hectorfile's folder as their cwd.
+
+Paths given on the **command line** (`--output`, `--snapshot`, `--test-file`, `--artifacts`, `--renode-dir`, …) stay relative to where you run hector, and `.hector/` is still created there.
+
+#### Extra Docker flags (`--docker-args`)
+
+Add your own flags to every `docker run` hector starts — Renode, robot tests, `shell` tests, `build:` steps and module builds — e.g. to mount more directories or set environment variables. Declare them in `.hector.yaml` as a string or a list:
+
+```yaml
+docker_args:
+  - -v /opt/toolchains:/opt/toolchains:ro
+  - -e LICENSE_SERVER=10.0.0.5
+```
+
+or pass them on the command line, where they are **appended** to the config's:
+
+```bash
+hector test --docker-args '-v /data/firmware:/data/firmware'
+```
+
+Use absolute host paths for `-v` (Docker treats a bare name as a named volume). Ignored under `--no-docker`.
+
+#### Container networking
+
+Every container hector starts — the Renode emulation (`run`), robot tests, `shell` tests, `build:` steps and module builds — runs with `--net=host`. GDB servers (`--debug`), `tcp:` mappings and anything a step listens on are reachable from the host on the same port, and steps can reach host services on `localhost`. No port publishing is involved.
+
 #### Running without Docker (`--no-docker`)
 
 Call the locally installed `renode` and `renode-test` binaries directly instead of launching a Docker container. `build:` steps and `shell` tests also run on the host (their `image:` is ignored, with a warning), as do module builds.
@@ -621,6 +652,7 @@ The configuration lives in `.hector.yaml`.
 | `version` | No | Schema version (currently `"0.1"`). Warns if unrecognised. |
 | `renode_version` | Yes¹ | Renode version, no leading `v` (e.g. `1.16.1`). Selects both the git tag for cloning and the Docker image tag. |
 | `renode_image` | Yes¹ | Full Renode Docker image to use instead of `antmicro/renode:<renode_version>` (e.g. a self-built `my-renode:dev`). See [custom Renode image](#using-a-custom-renode-image---renode-image). |
+| `docker_args` | No | Extra `docker run` flags (string or list) for every container, e.g. more `-v` mounts. See [extra Docker flags](#extra-docker-flags---docker-args). |
 | `arguments` | No | Scalar defaults, overridable by env var or `--set`. |
 | `build` | No | Pre-sim shell steps run once per job in containers (compile firmware, fetch/generate files, …). Interpolated with the job's arguments/matrix variables. |
 | `matrix` | No | Cross-product job expansion. |

{hector_cli-0.4.0 → hector_cli-0.6.0}/README.md

@@ -176,6 +176,7 @@ the CLI natively with `pip` and let hector launch real per-step containers.
 | `hector run --gather-execution-metrics boardA --gather-execution-metrics boardB` | Enable profiler for selected machines |
 | `hector run --renode-version 1.16.1` | Override the Renode version from `.hector.yaml` |
 | `hector run --renode-image my-renode:dev` | Use a specific (e.g. self-built) Renode Docker image |
+| `hector run --docker-args '-v /opt/tools:/opt/tools'` | Add extra flags (mounts, env, …) to every `docker run` |
 | `hector run --renode-dir /cache/renode` | Use/cache the Renode source checkout at this path (only fetched when needed) |
 | `hector run --renode-integration-dir /cache/integration` | Likewise for the verilator-integration checkout |
 | `hector run --no-docker` | Use locally installed `renode` / `renode-test` instead of Docker |
@@ -452,6 +453,36 @@ hector run --renode-args '--console'
 hector run --renode-args '--hide-log --config my.conf'
 ```
 
+#### Paths and working directory
+
+Everything a hectorfile executes — `build:` steps, `shell` tests, Renode and `renode-test` — runs **in the hectorfile's folder**, and paths written in the file (`firmware:`, `platform:`, module `source:`, test `file:` / `snapshot:`, `file:` mappings, `artifacts:`, paths inside scripts and `commands:`) are **relative to that folder**. So `hector test -f boards/nucleo/.hector.yaml` behaves the same as running `hector test` inside `boards/nucleo/`.
+
+The directory you run hector from is mounted into the container (at the same path), and the container's working directory (`-w`) is the hectorfile's folder. If the hectorfile lives **outside** the directory you run from (`hector test -f ../other/.hector.yaml`), its folder is mounted as well, at its own path. A path like `../shared/board.repl` works as long as it lands inside one of those mounts — for anything else, add a mount with [`docker_args`](#extra-docker-flags---docker-args). Under `--no-docker` the processes simply run with the hectorfile's folder as their cwd.
+
+Paths given on the **command line** (`--output`, `--snapshot`, `--test-file`, `--artifacts`, `--renode-dir`, …) stay relative to where you run hector, and `.hector/` is still created there.
+
+#### Extra Docker flags (`--docker-args`)
+
+Add your own flags to every `docker run` hector starts — Renode, robot tests, `shell` tests, `build:` steps and module builds — e.g. to mount more directories or set environment variables. Declare them in `.hector.yaml` as a string or a list:
+
+```yaml
+docker_args:
+  - -v /opt/toolchains:/opt/toolchains:ro
+  - -e LICENSE_SERVER=10.0.0.5
+```
+
+or pass them on the command line, where they are **appended** to the config's:
+
+```bash
+hector test --docker-args '-v /data/firmware:/data/firmware'
+```
+
+Use absolute host paths for `-v` (Docker treats a bare name as a named volume). Ignored under `--no-docker`.
+
+#### Container networking
+
+Every container hector starts — the Renode emulation (`run`), robot tests, `shell` tests, `build:` steps and module builds — runs with `--net=host`. GDB servers (`--debug`), `tcp:` mappings and anything a step listens on are reachable from the host on the same port, and steps can reach host services on `localhost`. No port publishing is involved.
+
 #### Running without Docker (`--no-docker`)
 
 Call the locally installed `renode` and `renode-test` binaries directly instead of launching a Docker container. `build:` steps and `shell` tests also run on the host (their `image:` is ignored, with a warning), as do module builds.
@@ -591,6 +622,7 @@ The configuration lives in `.hector.yaml`.
 | `version` | No | Schema version (currently `"0.1"`). Warns if unrecognised. |
 | `renode_version` | Yes¹ | Renode version, no leading `v` (e.g. `1.16.1`). Selects both the git tag for cloning and the Docker image tag. |
 | `renode_image` | Yes¹ | Full Renode Docker image to use instead of `antmicro/renode:<renode_version>` (e.g. a self-built `my-renode:dev`). See [custom Renode image](#using-a-custom-renode-image---renode-image). |
+| `docker_args` | No | Extra `docker run` flags (string or list) for every container, e.g. more `-v` mounts. See [extra Docker flags](#extra-docker-flags---docker-args). |
 | `arguments` | No | Scalar defaults, overridable by env var or `--set`. |
 | `build` | No | Pre-sim shell steps run once per job in containers (compile firmware, fetch/generate files, …). Interpolated with the job's arguments/matrix variables. |
 | `matrix` | No | Cross-product job expansion. |

{hector_cli-0.4.0 → hector_cli-0.6.0}/hector/commands/base.py

@@ -59,6 +59,12 @@ def add_common_arguments(parser):
              "image, e.g. a self-built one: my-renode:dev). Overrides renode_image / "
              "renode_version from .hector.yaml.",
     )
+    parser.add_argument(
+        "--docker-args", metavar="ARGS", dest="docker_args", default="",
+        help="Extra flags added to every `docker run` hector starts, e.g. more mounts "
+             "(--docker-args '-v /opt/tools:/opt/tools -e FOO=1'). Appended to "
+             "docker_args from .hector.yaml.",
+    )
     parser.add_argument(
         "--renode-dir", metavar="PATH", dest="renode_dir", default=None,
         help="Location of the Renode source checkout (only fetched when a config builds "

{hector_cli-0.4.0 → hector_cli-0.6.0}/hector/core.py

@@ -67,7 +67,7 @@ class Registry:
 # ==========================================================================
 # CONSTANTS
 # ==========================================================================
-TOOL_VERSION = "0.4.0"
+TOOL_VERSION = "0.6.0"
 SUPPORTED_SCHEMA_VERSIONS = {"0.1"}
 
 RENODE_REPO_URL = "https://github.com/renode/renode.git"
@@ -80,6 +80,11 @@ ARTIFACTS_DIR = ".hector"          # everything we generate/clone lives here (gi
 WORKSPACE_MOUNT = "/workspace" if os.name == "nt" else os.getcwd()
 NO_DOCKER = False                  # when True, call renode/renode-test directly on host
 EXTRA_MOUNTS = []                  # dep dirs outside the workspace, bind-mounted 1:1 into every container
+DOCKER_ARGS = []                   # user flags (docker_args: + --docker-args) added to every `docker run`
+# Host directory of the config file being executed. Paths written in the config resolve
+# against it, and scripts / Renode run with it as their working directory. None = cwd
+# (no config loaded, e.g. `run --snapshot` without one).
+CONFIG_DIR = None
 LIBOPENLIBM_NAME = "libopenlibm-Linux-x86_64.a"
 
 DEFAULT_QUANTUM = "0.00001"        # 10 us; applied when any hub is present
@@ -123,6 +128,11 @@ def to_container_path(host_path):
     abs_path = os.path.realpath(host_path)
     root = os.path.realpath(os.getcwd())
     if os.path.commonpath([abs_path, root]) != root:
+        # Out-of-tree dirs registered in EXTRA_MOUNTS (the config's dir, a shared
+        # Renode cache) are mounted 1:1, so their paths are valid as-is.
+        for m in EXTRA_MOUNTS:
+            if os.path.commonpath([abs_path, m]) == m:
+                return abs_path
         raise ValueError(
             f"Path '{host_path}' resolves outside the project root '{root}'. Everything used "
             f"at runtime must live under the project folder (mounted at '{WORKSPACE_MOUNT}')."
@@ -130,7 +140,7 @@ def to_container_path(host_path):
     # The container is always Linux: build a POSIX path under WORKSPACE_MOUNT (this is a
     # no-op on Linux, where WORKSPACE_MOUNT is the cwd and os.sep is already '/').
     rel = os.path.relpath(abs_path, root).replace(os.sep, "/")
-    return posixpath.join(WORKSPACE_MOUNT, rel)
+    return WORKSPACE_MOUNT if rel == "." else posixpath.join(WORKSPACE_MOUNT, rel)
 
 
 def register_dependency_mount(host_dir):
@@ -173,6 +183,27 @@ def container_to_host(container_path):
     return host
 
 
+def config_dir():
+    """Host directory config-relative paths resolve against (see CONFIG_DIR)."""
+    return CONFIG_DIR or os.getcwd()
+
+
+def from_config(path):
+    """Resolve a path written in the config against the config file's directory.
+    Absolute paths (host or container, e.g. an interpolated ${RENODE_DIR}) and URLs
+    are returned unchanged."""
+    if not path or os.path.isabs(path) or path.startswith("/") or "://" in path:
+        return path
+    return os.path.normpath(os.path.join(config_dir(), path))
+
+
+def execution_dir():
+    """Working directory for everything hector executes (build/shell steps, Renode,
+    renode-test): the config's directory — as a container path under Docker, a host
+    path under --no-docker."""
+    return config_dir() if NO_DOCKER else to_container_path(config_dir())
+
+
 def split_host_container(path):
     if path == WORKSPACE_MOUNT or path.startswith(WORKSPACE_MOUNT + "/"):
         return container_to_host(path), path

{hector_cli-0.4.0 → hector_cli-0.6.0}/hector/docker.py

@@ -48,16 +48,24 @@ def _user_flags():
 
 
 def _workspace_mount():
-    return ["-v", f"{os.getcwd()}:{core.WORKSPACE_MOUNT}", "-w", core.WORKSPACE_MOUNT]
+    return ["-v", f"{os.getcwd()}:{core.WORKSPACE_MOUNT}", "-w", core.execution_dir()]
 
 
 def _extra_mounts():
-    """Bind-mount out-of-tree dependency dirs (e.g. a shared Renode source cache) 1:1, so
-    containers reach them at the same path they have on the host. Empty for the common case."""
+    """Bind-mount out-of-tree dirs (the config's dir, a shared Renode source cache) 1:1,
+    so containers reach them at the same path they have on the host, then append the
+    user's own `docker run` flags (extra -v mounts, --env, ...). Empty for the common case."""
     args = []
     for d in core.EXTRA_MOUNTS:
         args += ["-v", f"{d}:{d}"]
-    return args
+    return args + core.DOCKER_ARGS
+
+
+# Every container shares the host's network stack: GDB servers, tcp: mappings and
+# anything a build/test step listens on are reachable from the host as-is, and steps
+# can reach host services (e.g. a local registry or a TCP-mapped UART) on localhost.
+# No -p publishing is needed (Docker ignores it in this mode anyway).
+_HOST_NETWORK = ["--net=host"]
 
 
 def _runtime_flags(runtime):
@@ -86,10 +94,10 @@ def _runtime_flags(runtime):
 def run_build(script, image):
     """Run a build script in the container as root (for apt-get + cmake)."""
     if core.NO_DOCKER:
-        subprocess.run(["bash", "-c", script], check=True)
+        subprocess.run(["bash", "-c", script], check=True, cwd=core.execution_dir())
         return
     subprocess.run(
-        ["docker", "run", "--rm", "-u", "0:0",
+        ["docker", "run", "--rm", *_HOST_NETWORK, "-u", "0:0",
          *_workspace_mount(), *_extra_mounts(), image, "bash", "-c", script],
         check=True,
     )
@@ -124,14 +132,17 @@ def run_in_container(script, image, live=False):
     fail on the first error.
 
     Backs the `shell` test type and the `build:` steps. Normally a one-off container of
-    `image`; under --no-docker the script runs directly on the host (the image is moot)."""
+    `image`; under --no-docker the script runs directly on the host (the image is moot).
+    Either way it runs in the config's directory (core.execution_dir)."""
+    cwd = None
     if core.NO_DOCKER:
         cmd = ["bash", "-c", f"set -ex\n{script}"]
+        cwd = core.execution_dir()
     else:
-        cmd = ["docker", "run", "--rm", *_workspace_mount(), *_extra_mounts(),
-               *_user_flags(), image, "sh", "-c", f"set -ex\n{script}"]
+        cmd = ["docker", "run", "--rm", *_HOST_NETWORK, *_workspace_mount(),
+               *_extra_mounts(), *_user_flags(), image, "sh", "-c", f"set -ex\n{script}"]
     if live:
-        proc = subprocess.Popen(cmd, stdout=subprocess.PIPE,
+        proc = subprocess.Popen(cmd, stdout=subprocess.PIPE, cwd=cwd,
                                 stderr=subprocess.STDOUT, text=True)
         lines = []
         for line in proc.stdout:
@@ -139,35 +150,36 @@ def run_in_container(script, image, live=False):
             lines.append(line)
         proc.wait()
         return "".join(lines), proc.returncode == 0
-    proc = subprocess.run(cmd, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, text=True)
+    proc = subprocess.run(cmd, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, text=True,
+                          cwd=cwd)
     if proc.stdout:
         print(proc.stdout, end="")
     return proc.stdout, proc.returncode == 0
 
 
-def build_renode_argv(resc_filename, image, ports=None, extra_args=None, runtime=None):
+def build_renode_argv(resc_filename, image, extra_args=None, runtime=None):
     """Build the exact argv that would run an emulation resc — the local `renode`
     invocation under --no-docker, otherwise the full `docker run ... renode` command.
 
     Returning the command (instead of running it) is what lets the `export` command
     print it verbatim and keeps run_renode a one-liner around this builder.
-    runtime: aggregated RuntimeOptions whose docker flags (caps/devices/root) are added."""
+    runtime: aggregated RuntimeOptions whose docker flags (caps/devices/root) are added.
+    The resc path is made absolute: Renode runs in the config's directory, not the cwd."""
     if core.NO_DOCKER:
-        return ["renode", resc_filename] + (extra_args or [])
-    cmd = ["docker", "run", "-it", "--rm", *_xdisplay_args(), "--net=host",
-           *_workspace_mount(), *_extra_mounts(), *_user_flags(), *_runtime_flags(runtime)]
-    for port in (ports or []):
-        cmd += ["-p", f"{port}:{port}"]
-    cmd += [image, "renode", resc_filename] + (extra_args or [])
-    return cmd
+        return ["renode", os.path.abspath(resc_filename)] + (extra_args or [])
+    return ["docker", "run", "-it", "--rm", *_xdisplay_args(), *_HOST_NETWORK,
+            *_workspace_mount(), *_extra_mounts(), *_user_flags(), *_runtime_flags(runtime),
+            image, "renode", to_container_path(resc_filename)] + (extra_args or [])
 
 
-def run_renode(resc_filename, image, ports=None, extra_args=None, output_dir="results", runtime=None):
-    """Run an emulation resc interactively. In debug mode, expose GDB ports.
+def run_renode(resc_filename, image, extra_args=None, output_dir="results", runtime=None):
+    """Run an emulation resc interactively. GDB ports (--debug) are reachable from the
+    host through the host network.
     runtime: aggregated RuntimeOptions whose docker flags (caps/devices/root) are added."""
     if not core.NO_DOCKER:
         os.makedirs(os.path.join(os.getcwd(), output_dir), exist_ok=True)
-    subprocess.run(build_renode_argv(resc_filename, image, ports, extra_args, runtime))
+    subprocess.run(build_renode_argv(resc_filename, image, extra_args, runtime),
+                   cwd=core.execution_dir() if core.NO_DOCKER else None)
 
 
 def run_renode_test(robot_file_host, image, results_dir_host,
@@ -177,22 +189,22 @@ def run_renode_test(robot_file_host, image, results_dir_host,
     resc_host_path: passed as --variable RESC:<path> so .robot files can load
     the generated emulation script via ${RESC}.
     extra_args: optional list of additional flags forwarded verbatim to renode-test.
-    interactive: attach stdin/tty and add --net=host (useful with Pause Execution
-    or when TCP ports need to be reachable from the host during the test).
+    interactive: attach stdin/tty and X display (useful with Pause Execution).
     """
     os.makedirs(results_dir_host, exist_ok=True)
     if core.NO_DOCKER:
-        cmd = ["renode-test", robot_file_host, "-r", results_dir_host]
+        # Absolute paths: renode-test runs in the config's directory, not the cwd.
+        cmd = ["renode-test", os.path.abspath(robot_file_host),
+               "-r", os.path.abspath(results_dir_host)]
         if resc_host_path:
-            cmd += ["--variable", f"RESC:{resc_host_path}"]
+            cmd += ["--variable", f"RESC:{os.path.abspath(resc_host_path)}"]
         if extra_args:
             cmd += extra_args
-        result = subprocess.run(cmd)
+        result = subprocess.run(cmd, cwd=core.execution_dir())
         return result.returncode == 0
     flags = ["-it"] if interactive else []
-    net = ["--net=host"] if interactive else []
     display = _xdisplay_args() if interactive else []
-    cmd = ["docker", "run", "--rm", *flags, *net, *display,
+    cmd = ["docker", "run", "--rm", *flags, *_HOST_NETWORK, *display,
            *_workspace_mount(), *_extra_mounts(), *_user_flags(), *_runtime_flags(runtime),
            image, "renode-test", to_container_path(robot_file_host),
            "-r", to_container_path(results_dir_host)]

{hector_cli-0.4.0 → hector_cli-0.6.0}/hector/generator.py

@@ -262,7 +262,7 @@ def snapshot_resc(snapshot_container_path, debug_config=None, no_start=False):
 # ARTIFACT COLLECTION
 # ==========================================================================
 
-def collect_artifacts(patterns, output_dir, job_index=None):
+def collect_artifacts(patterns, output_dir, job_index=None, base_dir="."):
     """Sweep the global artifact glob patterns and copy matches into
     <output_dir>/artifacts/ so a single directory can be uploaded by CI / read by a
     dashboard.
@@ -270,6 +270,8 @@ def collect_artifacts(patterns, output_dir, job_index=None):
     patterns   : list of glob strings (top-level 'artifacts:' or --artifacts override)
     output_dir : the run output directory (--output)
     job_index  : 1-based job number; prefixes copied filenames to avoid cross-job clashes
+    base_dir   : directory relative patterns resolve against (the config's directory
+                 for 'artifacts:', the cwd for --artifacts)
 
     Returns the list of collected destination paths (relative to cwd).
     """
@@ -283,7 +285,7 @@ def collect_artifacts(patterns, output_dir, job_index=None):
     collected, seen = [], set()
     header_shown = False
     for pattern in patterns:
-        for src in sorted(_match_artifacts(pattern, dest_root)):
+        for src in sorted(_match_artifacts(pattern, dest_root, base_dir)):
             real = os.path.realpath(src)
             if real in seen or not os.path.isfile(real):
                 continue
@@ -308,19 +310,19 @@ def collect_artifacts(patterns, output_dir, job_index=None):
     return collected
 
 
-def _match_artifacts(pattern, dest_root):
-    """Resolve one artifact glob pattern to a list of host paths.
+def _match_artifacts(pattern, dest_root, base_dir="."):
+    """Resolve one artifact glob pattern (relative to base_dir) to a list of host paths.
 
-    A bare filename pattern (no '/', e.g. '*.xml') searches the whole project tree
+    A bare filename pattern (no '/', e.g. '*.xml') searches the whole base_dir tree
     recursively, pruning hidden dirs (.hector, .git, …) and the artifacts output dir —
     so 'results/junit.xml' is found without sweeping the bundled Renode clone.
     A pattern with a path component ('results/*.bin', 'logs/**/*.log') is passed to
     glob as-is, so explicit directories and '**' behave normally.
     """
     if "/" in pattern or os.sep in pattern:
-        return glob.glob(pattern, recursive=True)
+        return glob.glob(os.path.join(base_dir, pattern), recursive=True)
     matches = []
-    for root, dirs, files in os.walk("."):
+    for root, dirs, files in os.walk(base_dir):
         dirs[:] = [d for d in dirs
                    if not d.startswith(".")
                    and os.path.realpath(os.path.join(root, d)) != dest_root]

{hector_cli-0.4.0 → hector_cli-0.6.0}/hector/mappings.py

@@ -33,7 +33,7 @@ YAML then accepts:   mappings: |\n  boardA.eth0 -> tap:tap0
 from dataclasses import dataclass, field
 from typing import List
 
-from .core import Registry, RuntimeOptions, parse_endpoint, to_container_path
+from .core import Registry, RuntimeOptions, from_config, parse_endpoint, to_container_path
 from .generator import queue_command
 
 MAPPING_BACKENDS = Registry("mapping backend")
@@ -55,7 +55,7 @@ def file_backend(_node_name, peripheral, param, _node_config):
     if not param:
         raise ValueError("'file' backend requires a path (file:<path>).")
     return MappingResult(
-        machine_cmd=f"{peripheral} CreateFileBackend @{to_container_path(param)} true",
+        machine_cmd=f"{peripheral} CreateFileBackend @{to_container_path(from_config(param))} true",
     )
 
 

{hector_cli-0.4.0 → hector_cli-0.6.0}/hector/modules.py

@@ -14,7 +14,7 @@ import shutil
 from dataclasses import dataclass
 
 from .core import (ARTIFACTS_DIR, LIBOPENLIBM_NAME, Registry,
-                   container_path_for, host_uid_gid, split_host_container,
+                   container_path_for, from_config, host_uid_gid, split_host_container,
                    to_container_path)
 from .docker import run_build
 
@@ -46,7 +46,7 @@ def build_renode_verilator(module_name, module_config, ctx):
     if not source:
         raise ValueError(f"Module '{module_name}' is missing required 'source'.")
 
-    source_host, source_container = split_host_container(source)
+    source_host, source_container = split_host_container(from_config(source))
     if not os.path.isdir(source_host):
         raise FileNotFoundError(f"Module '{module_name}': source dir not found: {source} ({source_host})")
 
@@ -113,7 +113,7 @@ def build_csharp(module_name, module_config, ctx):
     if not source:
         raise ValueError(f"Module '{module_name}' is missing required 'source'.")
 
-    source_host, _ = split_host_container(source)
+    source_host, _ = split_host_container(from_config(source))
 
     # ---- raw .cs: Renode compiles it at load time (bundled Roslyn) — no SDK, no build ----
     if source_host.endswith(".cs"):

{hector_cli-0.4.0 → hector_cli-0.6.0}/hector/pipeline.py

@@ -104,9 +104,18 @@ def load_config_or_exit():
     if v is not None and str(v) not in SUPPORTED_SCHEMA_VERSIONS:
         print(f"[WARN] .hector.yaml 'version: {v}' is not in supported versions "
               f"({', '.join(sorted(SUPPORTED_SCHEMA_VERSIONS))}). Proceeding anyway.")
+    _set_config_dir(config_path)
     return config
 
 
+def _set_config_dir(config_path):
+    """Make the config's directory the base for its paths and the working directory of
+    everything executed (see core.CONFIG_DIR). The cwd stays the workspace mount; a
+    config outside it gets its directory bind-mounted 1:1 as well, so it's reachable."""
+    _core.CONFIG_DIR = os.path.realpath(os.path.dirname(os.path.abspath(config_path)))
+    _core.register_dependency_mount(_core.CONFIG_DIR)
+
+
 _VERSION_TAG_RE = re.compile(r"^v?\d+\.\d+\.\d+$")
 
 
@@ -138,6 +147,16 @@ def resolve_renode_image(config, args):
     return (f"v{normalized}" if normalized else None), image
 
 
+def apply_docker_args(config, args):
+    """Collect the user's extra `docker run` flags — the config's `docker_args:` (a
+    string or a list of strings) followed by --docker-args — into core.DOCKER_ARGS."""
+    raw = config.get("docker_args") or []
+    flags = []
+    for item in ([raw] if isinstance(raw, str) else raw):
+        flags += shlex.split(str(item))
+    _core.DOCKER_ARGS = flags + shlex.split(getattr(args, "docker_args", "") or "")
+
+
 def _resolve_set_overrides(args):
     overrides = {}
     for kv in (getattr(args, "set_args", None) or []):
@@ -166,6 +185,7 @@ def build_job_config(action, config, args, *, test_mode=False):
     """Assemble a JobConfig from parsed args — the shared run / test / export path:
     pin the image, prepare the framework (lazily), resolve arguments + artifacts."""
     git_tag, docker_image = resolve_renode_image(config, args)
+    apply_docker_args(config, args)
 
     # Clone Renode only when the config actually needs the source; otherwise skip it
     # entirely (a ~200 MB clone) and leave the framework vars empty.
@@ -186,8 +206,14 @@ def build_job_config(action, config, args, *, test_mode=False):
 
     resolved_args = resolve_arguments(config.get("arguments", {}),
                                       overrides=_resolve_set_overrides(args))
-    artifacts_cfg = (args.artifacts if getattr(args, "artifacts", None)
-                     else as_lines(config.get("artifacts", [])))
+    # --artifacts globs are relative to where hector runs; the config's own 'artifacts:'
+    # to the config's directory (like every other path written in the config).
+    if getattr(args, "artifacts", None):
+        artifacts_cfg, artifacts_base = args.artifacts, os.getcwd()
+    else:
+        artifacts_cfg = as_lines(config.get("artifacts", []))
+        artifacts_base = _core.config_dir()
+    test_file = getattr(args, "test_file", None)
     return JobConfig(
         config=config,
         fw_vars=fw_vars,
@@ -196,7 +222,8 @@ def build_job_config(action, config, args, *, test_mode=False):
         action=action,
         test_mode=test_mode,
         debug_args=getattr(args, "debug", None) or [],
-        test_file=getattr(args, "test_file", None),
+        # Absolute so it isn't re-resolved against the config's directory.
+        test_file=os.path.abspath(test_file) if test_file else None,
         reporter_names=_resolve_reporters(getattr(args, "reporters", None)),
         renode_args=shlex.split(getattr(args, "renode_args", "") or ""),
         renode_test_args=shlex.split(getattr(args, "renode_test_args", "") or ""),
@@ -208,6 +235,7 @@ def build_job_config(action, config, args, *, test_mode=False):
         output_dir=getattr(args, "output", "results"),
         gather_metrics=getattr(args, "gather_execution_metrics", None),
         artifacts=artifacts_cfg,
+        artifacts_base=artifacts_base,
     )
 
 
@@ -241,6 +269,7 @@ def snapshot_fastpath(args):
         print(f"[ERROR] Snapshot not found: {args.snapshot}", file=sys.stderr)
         sys.exit(1)
     _, docker_image = resolve_renode_image({}, args)
+    apply_docker_args({}, args)
     resc_root = os.path.join(ARTIFACTS_DIR, "resc")
     os.makedirs(resc_root, exist_ok=True)
     # No .hector.yaml here, so debug machine names come straight from --debug.
@@ -251,8 +280,7 @@ def snapshot_fastpath(args):
                               no_start=getattr(args, "no_start", False)))
     print(f"[SNAP] {args.snapshot}"
           + (f" (+GDB: {debug_config})" if debug_config else ""))
-    run_renode(snap_resc, docker_image, ports=list(debug_config.values()) or None,
-               extra_args=shlex.split(args.renode_args or ""), output_dir=args.output)
+    run_renode(snap_resc, docker_image, extra_args=shlex.split(args.renode_args or ""), output_dir=args.output)
 
 
 def _run_validate():
@@ -486,6 +514,7 @@ class JobConfig:
     output_dir: str = "results"
     gather_metrics: list = None
     artifacts: list = field(default_factory=list)
+    artifacts_base: str = "."           # directory the artifact globs resolve against
 
 
 @dataclass
@@ -524,7 +553,6 @@ def action_simulate(state, cfg, result):
     if not state.resc_filename:
         raise ValueError("`hector run` needs at least one machine in 'machines:'.")
     run_renode(_resolve_active_resc(state, cfg), cfg.docker_image,
-               ports=list(state.debug_config.values()) or None,
                extra_args=cfg.renode_args, output_dir=cfg.output_dir,
                runtime=state.runtime)
 
@@ -536,7 +564,6 @@ def action_export(state, cfg, result):
     if not state.resc_filename:
         raise ValueError("`hector export` needs at least one machine in 'machines:'.")
     argv = build_renode_argv(_resolve_active_resc(state, cfg), cfg.docker_image,
-                             ports=list(state.debug_config.values()) or None,
                              extra_args=cfg.renode_args, runtime=state.runtime)
     line = shlex.join(argv)
     print(line)
@@ -760,7 +787,8 @@ def run_job(i, total_jobs, job_context, cfg):
         # Global glob patterns (top-level 'artifacts:' or --artifacts), interpolated
         # with this job's context so matrix variables resolve.
         artifact_patterns = as_lines(interpolate(list(cfg.artifacts), context))
-        collect_artifacts(artifact_patterns, cfg.output_dir, i + 1)
+        collect_artifacts(artifact_patterns, cfg.output_dir, i + 1,
+                          base_dir=cfg.artifacts_base)
 
     except Exception as exc:
         result["passed"] = False

{hector_cli-0.4.0 → hector_cli-0.6.0}/hector/runners.py

@@ -20,7 +20,7 @@ import time
 from dataclasses import dataclass, field
 
 from . import core as _core
-from .core import ARTIFACTS_DIR, Registry, to_container_path
+from .core import ARTIFACTS_DIR, Registry, from_config, to_container_path
 from .docker import resolve_shell_image, run_in_container, run_renode_test
 from .reporters import StepResult
 
@@ -170,7 +170,7 @@ def generate_robot_file(test_name, steps, resc_host_path, job_index, test_index,
 def _run_robot_test(test, steps, ctx, test_index):
     """Run a robot test. Returns a single StepResult for the whole test."""
     test_name = test.get("name", f"test_{test_index}")
-    effective_snapshot = ctx.snapshot or test.get("snapshot", "")
+    effective_snapshot = ctx.snapshot or from_config(test.get("snapshot", ""))
     if effective_snapshot and not os.path.isfile(effective_snapshot):
         raise FileNotFoundError(f"Snapshot not found: {effective_snapshot}")
 
@@ -190,7 +190,7 @@ def _run_robot_test(test, steps, ctx, test_index):
     if len(steps) == 1 and steps[0].get("file"):
         if effective_snapshot:
             print("  [WARN] snapshot ignored for file-based robot tests.")
-        robot_file = steps[0]["file"]
+        robot_file = from_config(steps[0]["file"])
     else:
         if any(s.get("file") for s in steps):
             raise ValueError(f"Test '{test_name}': mixing file: and script: steps is not supported.")

{hector_cli-0.4.0 → hector_cli-0.6.0}/hector/validator.py

@@ -28,7 +28,7 @@ _TRIGGER_TOP_KEYS = {"when", "cron", "reporters", "jobs", "fail_fast", "timeout"
 
 # Top-level keys defined by this schema version; anything else is flagged.
 _KNOWN_TOP_KEYS = {
-    "version", "renode_version", "renode_image", "arguments", "matrix",
+    "version", "renode_version", "renode_image", "docker_args", "arguments", "matrix",
     "modules", "hubs", "machines", "connections", "mappings", "build", "tests", "quantum",
     "artifacts",
 } | _TRIGGER_TOP_KEYS
@@ -91,6 +91,13 @@ def validate_config(config) -> Tuple[List[Issue], List[Issue]]:
     if ri and not isinstance(ri, str):
         err("renode_image", f"Must be a string like 'my-renode:dev', got {type(ri).__name__}.")
 
+    # ---- docker_args ----
+    da = config.get("docker_args")
+    if da is not None and not (isinstance(da, str) or
+                               (isinstance(da, list) and all(isinstance(x, str) for x in da))):
+        err("docker_args", "Must be a string or a list of strings "
+            "(e.g. ['-v /opt/tools:/opt/tools', '-e FOO=1']).")
+
     # ---- unknown / renamed top-level keys ----
     for k in config:
         if k in _RENAMED_TOP_KEYS:

{hector_cli-0.4.0 → hector_cli-0.6.0}/hector_cli.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hector-cli
-Version: 0.4.0
+Version: 0.6.0
 Summary: YAML-driven Renode + Verilator simulation orchestrator for embedded hardware CI
 Home-page: https://hector-ci.com
 Author: Nemesis
@@ -206,6 +206,7 @@ the CLI natively with `pip` and let hector launch real per-step containers.
 | `hector run --gather-execution-metrics boardA --gather-execution-metrics boardB` | Enable profiler for selected machines |
 | `hector run --renode-version 1.16.1` | Override the Renode version from `.hector.yaml` |
 | `hector run --renode-image my-renode:dev` | Use a specific (e.g. self-built) Renode Docker image |
+| `hector run --docker-args '-v /opt/tools:/opt/tools'` | Add extra flags (mounts, env, …) to every `docker run` |
 | `hector run --renode-dir /cache/renode` | Use/cache the Renode source checkout at this path (only fetched when needed) |
 | `hector run --renode-integration-dir /cache/integration` | Likewise for the verilator-integration checkout |
 | `hector run --no-docker` | Use locally installed `renode` / `renode-test` instead of Docker |
@@ -482,6 +483,36 @@ hector run --renode-args '--console'
 hector run --renode-args '--hide-log --config my.conf'
 ```
 
+#### Paths and working directory
+
+Everything a hectorfile executes — `build:` steps, `shell` tests, Renode and `renode-test` — runs **in the hectorfile's folder**, and paths written in the file (`firmware:`, `platform:`, module `source:`, test `file:` / `snapshot:`, `file:` mappings, `artifacts:`, paths inside scripts and `commands:`) are **relative to that folder**. So `hector test -f boards/nucleo/.hector.yaml` behaves the same as running `hector test` inside `boards/nucleo/`.
+
+The directory you run hector from is mounted into the container (at the same path), and the container's working directory (`-w`) is the hectorfile's folder. If the hectorfile lives **outside** the directory you run from (`hector test -f ../other/.hector.yaml`), its folder is mounted as well, at its own path. A path like `../shared/board.repl` works as long as it lands inside one of those mounts — for anything else, add a mount with [`docker_args`](#extra-docker-flags---docker-args). Under `--no-docker` the processes simply run with the hectorfile's folder as their cwd.
+
+Paths given on the **command line** (`--output`, `--snapshot`, `--test-file`, `--artifacts`, `--renode-dir`, …) stay relative to where you run hector, and `.hector/` is still created there.
+
+#### Extra Docker flags (`--docker-args`)
+
+Add your own flags to every `docker run` hector starts — Renode, robot tests, `shell` tests, `build:` steps and module builds — e.g. to mount more directories or set environment variables. Declare them in `.hector.yaml` as a string or a list:
+
+```yaml
+docker_args:
+  - -v /opt/toolchains:/opt/toolchains:ro
+  - -e LICENSE_SERVER=10.0.0.5
+```
+
+or pass them on the command line, where they are **appended** to the config's:
+
+```bash
+hector test --docker-args '-v /data/firmware:/data/firmware'
+```
+
+Use absolute host paths for `-v` (Docker treats a bare name as a named volume). Ignored under `--no-docker`.
+
+#### Container networking
+
+Every container hector starts — the Renode emulation (`run`), robot tests, `shell` tests, `build:` steps and module builds — runs with `--net=host`. GDB servers (`--debug`), `tcp:` mappings and anything a step listens on are reachable from the host on the same port, and steps can reach host services on `localhost`. No port publishing is involved.
+
 #### Running without Docker (`--no-docker`)
 
 Call the locally installed `renode` and `renode-test` binaries directly instead of launching a Docker container. `build:` steps and `shell` tests also run on the host (their `image:` is ignored, with a warning), as do module builds.
@@ -621,6 +652,7 @@ The configuration lives in `.hector.yaml`.
 | `version` | No | Schema version (currently `"0.1"`). Warns if unrecognised. |
 | `renode_version` | Yes¹ | Renode version, no leading `v` (e.g. `1.16.1`). Selects both the git tag for cloning and the Docker image tag. |
 | `renode_image` | Yes¹ | Full Renode Docker image to use instead of `antmicro/renode:<renode_version>` (e.g. a self-built `my-renode:dev`). See [custom Renode image](#using-a-custom-renode-image---renode-image). |
+| `docker_args` | No | Extra `docker run` flags (string or list) for every container, e.g. more `-v` mounts. See [extra Docker flags](#extra-docker-flags---docker-args). |
 | `arguments` | No | Scalar defaults, overridable by env var or `--set`. |
 | `build` | No | Pre-sim shell steps run once per job in containers (compile firmware, fetch/generate files, …). Interpolated with the job's arguments/matrix variables. |
 | `matrix` | No | Cross-product job expansion. |

{hector_cli-0.4.0 → hector_cli-0.6.0}/tests/test_core_paths.py

@@ -84,6 +84,33 @@ def test_container_path_for_prefers_extra_mount(project, tmp_path_factory):
     assert core.container_path_for(str(inner)) == str((cache / "renode" / "x.so").resolve())
 
 
+def test_from_config_resolves_against_config_dir(project, monkeypatch):
+    monkeypatch.setattr(core, "CONFIG_DIR", str(project / "board"))
+    assert core.from_config("fw/app.elf") == str(project / "board" / "fw" / "app.elf")
+    assert core.from_config("../shared/x.repl") == str(project / "shared" / "x.repl")
+
+
+def test_from_config_leaves_absolute_and_urls(project, monkeypatch):
+    monkeypatch.setattr(core, "CONFIG_DIR", str(project / "board"))
+    for p in ("/opt/renode/x.repl", "https://example.com/fw.elf", "", None):
+        assert core.from_config(p) == p
+
+
+def test_from_config_defaults_to_cwd(project, monkeypatch):
+    monkeypatch.setattr(core, "CONFIG_DIR", None)
+    assert core.from_config("fw.elf") == str(project / "fw.elf")
+
+
+def test_execution_dir_is_container_path_of_config_dir(project, monkeypatch):
+    (project / "board").mkdir()
+    monkeypatch.setattr(core, "NO_DOCKER", False)
+    monkeypatch.setattr(core, "WORKSPACE_MOUNT", "/workspace")
+    monkeypatch.setattr(core, "CONFIG_DIR", str(project / "board"))
+    assert core.execution_dir() == "/workspace/board"
+    monkeypatch.setattr(core, "NO_DOCKER", True)
+    assert core.execution_dir() == str(project / "board")
+
+
 def test_host_uid_gid_on_posix():
     ids = core.host_uid_gid()
     if hasattr(os, "getuid"):

hector_cli-0.6.0/tests/test_docker_argv.py

@@ -0,0 +1,171 @@
+"""Unit tests for hector.docker command construction. We assert on the argv that
+*would* run — never invoking Docker or Renode. build_renode_argv is the seam the
+`export` command prints verbatim."""
+
+import pytest
+
+from hector import core, docker
+from hector.core import RuntimeOptions
+
+
+@pytest.fixture(autouse=True)
+def clean_env(monkeypatch, tmp_path):
+    monkeypatch.chdir(tmp_path)
+    monkeypatch.setattr(core, "WORKSPACE_MOUNT", str(tmp_path))
+    monkeypatch.setattr(core, "EXTRA_MOUNTS", [])
+    monkeypatch.setattr(core, "NO_DOCKER", False)
+    monkeypatch.setattr(core, "CONFIG_DIR", None)
+    monkeypatch.setattr(core, "DOCKER_ARGS", [])
+    # Neutralise X11 forwarding so argv is deterministic across hosts.
+    monkeypatch.delenv("XAUTHORITY", raising=False)
+    monkeypatch.delenv("HOME", raising=False)
+
+
+# ---- build_renode_argv ----
+
+def test_no_docker_is_bare_renode(monkeypatch, tmp_path):
+    monkeypatch.setattr(core, "NO_DOCKER", True)
+    # Absolute: renode runs in the config's directory, not the cwd.
+    assert docker.build_renode_argv("job.resc", "img", extra_args=["--console"]) == [
+        "renode", str(tmp_path / "job.resc"), "--console"]
+
+
+def test_docker_argv_core_tokens(tmp_path):
+    argv = docker.build_renode_argv("job.resc", "antmicro/renode:1.16.1")
+    assert argv[:3] == ["docker", "run", "-it"]
+    assert "--net=host" in argv
+    assert "antmicro/renode:1.16.1" in argv
+    # The image must be immediately followed by the renode invocation.
+    i = argv.index("antmicro/renode:1.16.1")
+    assert argv[i + 1:i + 3] == ["renode", str(tmp_path / "job.resc")]
+
+
+def test_workdir_is_cwd_without_config(tmp_path):
+    argv = docker.build_renode_argv("j.resc", "img")
+    assert argv[argv.index("-w") + 1] == str(tmp_path)
+
+
+def test_workdir_is_config_dir_mount_unchanged(monkeypatch, tmp_path):
+    (tmp_path / "sub").mkdir()
+    monkeypatch.setattr(core, "CONFIG_DIR", str(tmp_path / "sub"))
+    argv = docker.build_renode_argv("j.resc", "img")
+    assert argv[argv.index("-v") + 1] == f"{tmp_path}:{tmp_path}"
+    assert argv[argv.index("-w") + 1] == str(tmp_path / "sub")
+
+
+def test_user_docker_args_reach_every_container(monkeypatch):
+    monkeypatch.setattr(core, "DOCKER_ARGS", ["-v", "/opt/tools:/opt/tools", "-e", "FOO=1"])
+    calls = []
+
+    class _Proc:
+        returncode, stdout = 0, ""
+
+    monkeypatch.setattr(docker.subprocess, "run",
+                        lambda cmd, **kw: calls.append(cmd) or _Proc())
+    monkeypatch.setattr(docker.os, "makedirs", lambda *a, **kw: None)
+    docker.run_build("true", "img")
+    docker.run_in_container("true", "img")
+    docker.run_renode_test("t.robot", "img", "res")
+    docker.run_renode("j.resc", "img")
+    for cmd in calls:
+        i = cmd.index("/opt/tools:/opt/tools")
+        assert cmd[i - 1] == "-v" and cmd[i + 1:i + 3] == ["-e", "FOO=1"]
+        assert i < cmd.index("img")             # flags must precede the image
+
+
+def test_no_docker_steps_run_in_config_dir(monkeypatch, tmp_path):
+    monkeypatch.setattr(core, "NO_DOCKER", True)
+    monkeypatch.setattr(core, "CONFIG_DIR", str(tmp_path / "sub"))
+    cwds = []
+
+    class _Proc:
+        returncode, stdout = 0, ""
+
+    monkeypatch.setattr(docker.subprocess, "run",
+                        lambda cmd, **kw: cwds.append(kw.get("cwd")) or _Proc())
+    docker.run_build("true", "img")
+    docker.run_in_container("true", "img")
+    docker.run_renode_test("t.robot", "img", "res")
+    docker.run_renode("j.resc", "img")
+    assert cwds == [str(tmp_path / "sub")] * 4
+
+
+def test_docker_argv_does_not_publish_ports():
+    # Host networking exposes GDB ports directly; -p would be ignored by Docker.
+    argv = docker.build_renode_argv("j.resc", "img")
+    assert "-p" not in argv
+
+
+def test_every_container_uses_host_network(monkeypatch):
+    calls = []
+
+    class _Proc:
+        returncode, stdout = 0, ""
+
+    monkeypatch.setattr(docker.subprocess, "run",
+                        lambda cmd, **kw: calls.append(cmd) or _Proc())
+    monkeypatch.setattr(docker.os, "makedirs", lambda *a, **kw: None)
+    docker.run_build("true", "img")
+    docker.run_in_container("true", "img")
+    docker.run_renode_test("t.robot", "img", "res")
+    docker.run_renode("j.resc", "img")
+    assert len(calls) == 4
+    assert all("--net=host" in cmd for cmd in calls)
+
+
+def test_docker_argv_appends_extra_args_after_resc(tmp_path):
+    argv = docker.build_renode_argv("j.resc", "img", extra_args=["--console", "--hide-log"])
+    assert argv[-3:] == [str(tmp_path / "j.resc"), "--console", "--hide-log"]
+
+
+# ---- _runtime_flags ----
+
+def test_runtime_flags_none():
+    assert docker._runtime_flags(None) == []
+
+
+def test_runtime_flags_root_and_caps():
+    flags = docker._runtime_flags(RuntimeOptions(root=True, capabilities={"NET_ADMIN"}))
+    assert "-u" in flags and "0:0" in flags
+    assert flags[flags.index("--cap-add") + 1] == "NET_ADMIN"
+
+
+def test_runtime_flags_device_present(monkeypatch):
+    monkeypatch.setattr(docker.os.path, "exists", lambda p: p == "/dev/net/tun")
+    flags = docker._runtime_flags(RuntimeOptions(devices={"/dev/net/tun"}))
+    assert flags[flags.index("--device") + 1] == "/dev/net/tun"
+
+
+def test_runtime_flags_all_devices_absent_yields_nothing(monkeypatch):
+    # A requested device missing on the host must not fail the run, and (per the
+    # docstring) no flags at all are applied so it drops to unprivileged dummy mode.
+    monkeypatch.setattr(docker.os.path, "exists", lambda p: False)
+    assert docker._runtime_flags(
+        RuntimeOptions(devices={"/dev/net/tun"}, root=True)) == []
+
+
+# ---- _user_flags ----
+
+def test_user_flags_maps_host_uid(monkeypatch):
+    monkeypatch.setattr(core, "host_uid_gid", lambda: (1000, 1000))
+    assert docker._user_flags() == ["-u", "1000:1000"]
+
+
+def test_user_flags_empty_without_uid(monkeypatch):
+    monkeypatch.setattr(core, "host_uid_gid", lambda: None)
+    assert docker._user_flags() == []
+
+
+# ---- resolve_shell_image ----
+
+def test_shell_image_explicit_wins():
+    assert docker.resolve_shell_image({"image": "alpine"}, "default:img") == "alpine"
+
+
+def test_shell_image_falls_back_to_default():
+    assert docker.resolve_shell_image({}, "default:img") == "default:img"
+
+
+def test_shell_image_no_docker_uses_default(monkeypatch):
+    monkeypatch.setattr(core, "NO_DOCKER", True)
+    assert docker.resolve_shell_image({"image": "alpine"}, "default:img") == "alpine"

{hector_cli-0.4.0 → hector_cli-0.6.0}/tests/test_generator.py

@@ -6,7 +6,7 @@ import os
 import pytest
 
 from hector.generator import (NodeDescriptor, PeripheralDef, build_repl_fragment,
-                              finalize_commands, generate_emulation_resc,
+                              collect_artifacts, finalize_commands, generate_emulation_resc,
                               generate_node_repl, repl_value, snapshot_resc,
                               write_inline_repl)
 
@@ -194,3 +194,19 @@ def test_snapshot_resc_reopens_gdb_after_load():
     # A GDB server is never part of saved state, so it must be (re)started post-Load.
     assert text.index("Load @") < text.index("StartGdbServer 4444")
     assert 'mach set "mcu"' in text
+
+
+# ---- collect_artifacts ----
+
+def test_collect_artifacts_resolves_against_base_dir(tmp_path, monkeypatch):
+    # Config in board/: its 'artifacts:' globs resolve there, not against the cwd.
+    monkeypatch.chdir(tmp_path)
+    (tmp_path / "board" / "build").mkdir(parents=True)
+    (tmp_path / "board" / "build" / "fw.bin").write_text("x")
+    (tmp_path / "board" / "uart.log").write_text("x")
+    (tmp_path / "other.log").write_text("x")
+    collected = collect_artifacts(["build/*.bin", "*.log"], "results", 1,
+                                  base_dir=str(tmp_path / "board"))
+    assert sorted(collected) == [
+        os.path.join("results", "artifacts", "job_1", "board", "build", "fw.bin"),
+        os.path.join("results", "artifacts", "job_1", "board", "uart.log")]

{hector_cli-0.4.0 → hector_cli-0.6.0}/tests/test_pipeline_helpers.py

@@ -36,6 +36,61 @@ def test_config_path_returns_requested_when_neither_exists(tmp_path, monkeypatch
     assert resolve_config_path("missing.yaml") == "missing.yaml"
 
 
+# ---- load_config_or_exit: the config's directory ----
+
+@pytest.fixture
+def config_in_subdir(tmp_path, monkeypatch):
+    from hector import core, pipeline
+    monkeypatch.chdir(tmp_path)
+    monkeypatch.setattr(core, "WORKSPACE_MOUNT", str(tmp_path))
+    monkeypatch.setattr(core, "NO_DOCKER", False)
+    monkeypatch.setattr(core, "CONFIG_DIR", None)
+    monkeypatch.setattr(core, "EXTRA_MOUNTS", [])
+    (tmp_path / "board").mkdir()
+    (tmp_path / "board" / ".hector.yaml").write_text("renode_version: '1.16.1'\n")
+    return pipeline, core, tmp_path
+
+
+def test_load_config_sets_config_dir(config_in_subdir, monkeypatch):
+    pipeline, core, root = config_in_subdir
+    monkeypatch.setattr(pipeline, "CONFIG_PATH", "board/.hector.yaml")
+    pipeline.load_config_or_exit()
+    assert core.CONFIG_DIR == str(root / "board")
+    assert core.execution_dir() == str(root / "board")
+    assert core.EXTRA_MOUNTS == []            # inside the cwd mount already
+
+
+def test_load_config_outside_cwd_is_mounted_too(config_in_subdir, monkeypatch):
+    # Run from a sibling dir: the cwd stays the workspace mount, and ../board is
+    # bind-mounted 1:1 so the config's paths and working dir are reachable.
+    pipeline, core, root = config_in_subdir
+    (root / "elsewhere").mkdir()
+    monkeypatch.setattr(core, "WORKSPACE_MOUNT", str(root / "elsewhere"))
+    monkeypatch.chdir(root / "elsewhere")
+    monkeypatch.setattr(pipeline, "CONFIG_PATH", "../board/.hector.yaml")
+    pipeline.load_config_or_exit()
+    board = str((root / "board").resolve())
+    assert core.EXTRA_MOUNTS == [board]
+    assert core.execution_dir() == board
+    assert core.to_container_path(core.from_config("fw.elf")) == f"{board}/fw.elf"
+
+
+# ---- apply_docker_args ----
+
+@pytest.mark.parametrize("cfg,flag,expected", [
+    ({}, "", []),
+    ({"docker_args": "-v /a:/a -e X=1"}, "", ["-v", "/a:/a", "-e", "X=1"]),
+    ({"docker_args": ["-v /a:/a", "--env 'Y=two words'"]}, "",
+     ["-v", "/a:/a", "--env", "Y=two words"]),
+    ({"docker_args": "-v /a:/a"}, "-v /b:/b", ["-v", "/a:/a", "-v", "/b:/b"]),  # flag appends
+])
+def test_apply_docker_args(monkeypatch, cfg, flag, expected):
+    from hector import core, pipeline
+    monkeypatch.setattr(core, "DOCKER_ARGS", [])
+    pipeline.apply_docker_args(cfg, SimpleNamespace(docker_args=flag))
+    assert core.DOCKER_ARGS == expected
+
+
 # ---- resolve_renode_image ----
 
 def test_image_from_config():

{hector_cli-0.4.0 → hector_cli-0.6.0}/tests/test_validator.py

@@ -39,6 +39,22 @@ def test_missing_renode_version_is_error():
     assert any(i.path == "renode_version" for i in errors)
 
 
+def test_renode_image_alone_satisfies_requirement():
+    errors, _ = validate_config({"renode_image": "my-renode:dev"})
+    assert errors == []
+
+
+@pytest.mark.parametrize("value", ["-v /a:/a", ["-v /a:/a", "-e X=1"]])
+def test_docker_args_accepts_string_or_list(value):
+    errors, warnings = validate_config({"renode_version": "1.16.1", "docker_args": value})
+    assert errors == [] and not any(w.path == "docker_args" for w in warnings)
+
+
+def test_docker_args_wrong_type_is_error():
+    errors, _ = validate_config({"renode_version": "1.16.1", "docker_args": {"v": "/a"}})
+    assert any(i.path == "docker_args" for i in errors)
+
+
 def test_unknown_module_kind_is_error():
     cfg = {"renode_version": "1.16.1",
            "modules": {"u": {"kind": "bogus", "type": "X", "source": "s"}}}

hector_cli-0.4.0/tests/test_docker_argv.py

@@ -1,101 +0,0 @@
-"""Unit tests for hector.docker command construction. We assert on the argv that
-*would* run — never invoking Docker or Renode. build_renode_argv is the seam the
-`export` command prints verbatim."""
-
-import pytest
-
-from hector import core, docker
-from hector.core import RuntimeOptions
-
-
-@pytest.fixture(autouse=True)
-def clean_env(monkeypatch, tmp_path):
-    monkeypatch.chdir(tmp_path)
-    monkeypatch.setattr(core, "WORKSPACE_MOUNT", str(tmp_path))
-    monkeypatch.setattr(core, "EXTRA_MOUNTS", [])
-    monkeypatch.setattr(core, "NO_DOCKER", False)
-    # Neutralise X11 forwarding so argv is deterministic across hosts.
-    monkeypatch.delenv("XAUTHORITY", raising=False)
-    monkeypatch.delenv("HOME", raising=False)
-
-
-# ---- build_renode_argv ----
-
-def test_no_docker_is_bare_renode(monkeypatch):
-    monkeypatch.setattr(core, "NO_DOCKER", True)
-    assert docker.build_renode_argv("job.resc", "img", extra_args=["--console"]) == [
-        "renode", "job.resc", "--console"]
-
-
-def test_docker_argv_core_tokens():
-    argv = docker.build_renode_argv("job.resc", "antmicro/renode:1.16.1")
-    assert argv[:3] == ["docker", "run", "-it"]
-    assert "--net=host" in argv
-    assert "antmicro/renode:1.16.1" in argv
-    # The image must be immediately followed by the renode invocation.
-    i = argv.index("antmicro/renode:1.16.1")
-    assert argv[i + 1:i + 3] == ["renode", "job.resc"]
-
-
-def test_docker_argv_publishes_ports():
-    argv = docker.build_renode_argv("j.resc", "img", ports=[3333, 3334])
-    joined = " ".join(argv)
-    assert "-p 3333:3333" in joined and "-p 3334:3334" in joined
-
-
-def test_docker_argv_appends_extra_args_after_resc():
-    argv = docker.build_renode_argv("j.resc", "img", extra_args=["--console", "--hide-log"])
-    assert argv[-3:] == ["j.resc", "--console", "--hide-log"]
-
-
-# ---- _runtime_flags ----
-
-def test_runtime_flags_none():
-    assert docker._runtime_flags(None) == []
-
-
-def test_runtime_flags_root_and_caps():
-    flags = docker._runtime_flags(RuntimeOptions(root=True, capabilities={"NET_ADMIN"}))
-    assert "-u" in flags and "0:0" in flags
-    assert flags[flags.index("--cap-add") + 1] == "NET_ADMIN"
-
-
-def test_runtime_flags_device_present(monkeypatch):
-    monkeypatch.setattr(docker.os.path, "exists", lambda p: p == "/dev/net/tun")
-    flags = docker._runtime_flags(RuntimeOptions(devices={"/dev/net/tun"}))
-    assert flags[flags.index("--device") + 1] == "/dev/net/tun"
-
-
-def test_runtime_flags_all_devices_absent_yields_nothing(monkeypatch):
-    # A requested device missing on the host must not fail the run, and (per the
-    # docstring) no flags at all are applied so it drops to unprivileged dummy mode.
-    monkeypatch.setattr(docker.os.path, "exists", lambda p: False)
-    assert docker._runtime_flags(
-        RuntimeOptions(devices={"/dev/net/tun"}, root=True)) == []
-
-
-# ---- _user_flags ----
-
-def test_user_flags_maps_host_uid(monkeypatch):
-    monkeypatch.setattr(core, "host_uid_gid", lambda: (1000, 1000))
-    assert docker._user_flags() == ["-u", "1000:1000"]
-
-
-def test_user_flags_empty_without_uid(monkeypatch):
-    monkeypatch.setattr(core, "host_uid_gid", lambda: None)
-    assert docker._user_flags() == []
-
-
-# ---- resolve_shell_image ----
-
-def test_shell_image_explicit_wins():
-    assert docker.resolve_shell_image({"image": "alpine"}, "default:img") == "alpine"
-
-
-def test_shell_image_falls_back_to_default():
-    assert docker.resolve_shell_image({}, "default:img") == "default:img"
-
-
-def test_shell_image_no_docker_uses_default(monkeypatch):
-    monkeypatch.setattr(core, "NO_DOCKER", True)
-    assert docker.resolve_shell_image({"image": "alpine"}, "default:img") == "alpine"