docker-stack 0.3.1__tar.gz → 1.0.0__tar.gz

{docker_stack-0.3.1 → docker_stack-1.0.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: docker-stack
-Version: 0.3.1
+Version: 1.0.0
 Summary: CLI for deploying and managing Docker stacks.
 Home-page: https://github.com/mesudip/docker-stack
 Author: Sudip Bhattarai

{docker_stack-0.3.1 → docker_stack-1.0.0}/docker_stack/cli.py

@@ -1,23 +1,196 @@
 #!/usr/bin/env python3
 import argparse
 import base64
+from dataclasses import dataclass
 import re
+import shutil
 import subprocess
 import sys
+import textwrap
 from pathlib import Path
-from typing import Dict, List
+from typing import Dict, List, Optional, Tuple
 import os
 import yaml
 import json
 from docker_stack.docker_objects import DockerConfig, DockerObjectManager, DockerSecret
 from docker_stack.helpers import Command, generate_secret
 from docker_stack.registry import DockerRegistry
-from .envsubst import envsubst, envsubst_load_file
+from .envsubst import LineCheckResult, SubstitutionError, envsubst, envsubst_load_file
+
+
+@dataclass
+class EnvFileEntry:
+    key: str
+    value: str
+    line_no: int
+    line_content: str
+    value_start_index: int
+    value_inner_offset: int
+
+
+class EnvFileResolutionError(Exception):
+    def __init__(self, env_file: str, reason: str, results: List[LineCheckResult], template_lines: List[str]):
+        self.env_file = env_file
+        self.reason = reason
+        self.results = results
+        self.template_lines = template_lines
+        super().__init__(self._format_message())
+
+    def _format_message(self) -> str:
+        formatted_lines = [f"{self.reason} in {self.env_file}:"]
+        errors_by_line = {}
+
+        for result in self.results:
+            if result.line_no not in errors_by_line:
+                errors_by_line[result.line_no] = {"line_content": result.line_content, "variables": []}
+            errors_by_line[result.line_no]["variables"].append({"name": result.variable_name, "start_index": result.start_index})
+
+        for line_no in sorted(errors_by_line):
+            line_chars = list(errors_by_line[line_no]["line_content"])
+            for item in sorted(errors_by_line[line_no]["variables"], key=lambda x: x["start_index"], reverse=True):
+                for idx in range(len(item["name"]) - 1, -1, -1):
+                    line_chars.insert(item["start_index"] + idx + 1, "\u0333")
+            formatted_lines.append(f"{line_no:3d}   {''.join(line_chars)}")
+
+        return "\n".join(formatted_lines)
+
+
+ENV_VAR_PATTERN = re.compile(r"\$\{([^}:\s]+)(?::-(.*?))?\}|\$([a-zA-Z_][a-zA-Z0-9_]*)")
+
+
+def _strip_matching_quotes(value: str) -> Tuple[str, int]:
+    if len(value) >= 2 and value[0] == value[-1] and value[0] in ("'", '"'):
+        return value[1:-1], 1
+    return value, 0
+
+
+def _parse_env_file(env_file: str) -> Tuple[List[EnvFileEntry], List[str]]:
+    entries: List[EnvFileEntry] = []
+    with open(env_file) as f:
+        template_lines = f.read().splitlines(keepends=False)
+
+    for line_no, raw_line in enumerate(template_lines, start=1):
+        stripped = raw_line.strip()
+        if not stripped or stripped.startswith("#"):
+            continue
+
+        key_part, separator, value_part = raw_line.partition("=")
+        if not separator:
+            continue
+
+        key = key_part.strip()
+        leading_ws = len(value_part) - len(value_part.lstrip())
+        value_start_index = len(key_part) + 1 + leading_ws
+        value, value_inner_offset = _strip_matching_quotes(value_part.strip())
+        entries.append(
+            EnvFileEntry(
+                key=key,
+                value=value,
+                line_no=line_no,
+                line_content=raw_line,
+                value_start_index=value_start_index,
+                value_inner_offset=value_inner_offset,
+            )
+        )
+    return entries, template_lines
+
+
+def _extract_refs(value: str) -> List[Tuple[str, int]]:
+    refs = []
+    for match in ENV_VAR_PATTERN.finditer(value):
+        var = match.group(1) if match.group(1) is not None else match.group(3)
+        start = match.start(1) if match.group(1) is not None else match.start(3)
+        refs.append((var, start))
+    return refs
+
+
+def _map_substitution_error(entry: EnvFileEntry, err: SubstitutionError) -> List[LineCheckResult]:
+    mapped_results = []
+    for result in err.results:
+        mapped_results.append(
+            LineCheckResult(
+                line_no=entry.line_no,
+                line_content=entry.line_content,
+                variable_name=result.variable_name,
+                start_index=entry.value_start_index + entry.value_inner_offset + (result.start_index or 0),
+            )
+        )
+    return mapped_results
+
+
+def _resolve_env_entries(entries: List[EnvFileEntry], env_file: str, base_env: Optional[Dict[str, str]] = None, max_cycles: int = 5) -> Dict[str, str]:
+    base_env = dict(base_env or os.environ)
+    current_values = {entry.key: entry.value for entry in entries}
+    local_keys = set(current_values.keys())
+    resolution_passes = max(max_cycles, len(entries))
+
+    for _ in range(resolution_passes):
+        next_values: Dict[str, str] = {}
+        missing_results: List[LineCheckResult] = []
+        changed = False
+
+        resolution_env = {**base_env, **current_values}
+        for entry in entries:
+            try:
+                resolved = envsubst(entry.value, env=resolution_env, on_error="throw")
+            except SubstitutionError as err:
+                missing_results.extend(_map_substitution_error(entry, err))
+                continue
+
+            next_values[entry.key] = resolved
+            if resolved != current_values[entry.key]:
+                changed = True
+
+        if missing_results:
+            missing_results.sort(key=lambda x: (x.line_no, x.start_index or 0))
+            raise EnvFileResolutionError(env_file, "Missing environment variables", missing_results, [])
+
+        current_values = next_values
+        if not changed:
+            break
+
+    cyclic_results: List[LineCheckResult] = []
+    for entry in entries:
+        final_value = current_values[entry.key]
+        for var_name, start_index in _extract_refs(final_value):
+            if var_name in local_keys:
+                original_refs = [(name, idx) for name, idx in _extract_refs(entry.value) if name in local_keys]
+                ref_positions = original_refs or [(var_name, 0)]
+                for original_name, original_index in ref_positions:
+                    cyclic_results.append(
+                        LineCheckResult(
+                            line_no=entry.line_no,
+                            line_content=entry.line_content,
+                            variable_name=original_name,
+                            start_index=entry.value_start_index + entry.value_inner_offset + original_index,
+                        )
+                    )
+                break
+
+    if cyclic_results:
+        deduped = {
+            (result.line_no, result.variable_name, result.start_index): result for result in cyclic_results
+        }
+        ordered_results = sorted(deduped.values(), key=lambda x: (x.line_no, x.start_index or 0))
+        raise EnvFileResolutionError(
+            env_file,
+            f"Cyclic environment variable references detected after {resolution_passes} resolution passes",
+            ordered_results,
+            [],
+        )
+
+    return current_values
+
+
+def load_env_file(env_file: str, base_env: Optional[Dict[str, str]] = None, max_cycles: int = 5) -> Dict[str, str]:
+    entries, _ = _parse_env_file(env_file)
+    return _resolve_env_entries(entries, env_file, base_env=base_env, max_cycles=max_cycles)
 
 
 class Docker:
     def __init__(self, registries: List[str] = []):
         self.stack = DockerStack(self)
+        self.node = DockerNode()
         self.config = DockerConfig()
         self.secret = DockerSecret()
         self.registry = DockerRegistry(registries)
@@ -25,12 +198,7 @@ class Docker:
     @staticmethod
     def load_env(env_file=".env"):
         if Path(env_file).is_file():
-            with open(env_file) as f:
-                for line in f:
-                    line = line.strip()
-                    if line and not line.startswith("#"):
-                        key, _, value = line.partition("=")
-                        os.environ[key.strip()] = value.strip()
+            os.environ.update(load_env_file(env_file))
 
     @staticmethod
     def check_env(example_file=".env.example"):
@@ -113,11 +281,19 @@ class DockerStack:
         """
         processed_objects = {}
 
-        def add_obj(name, data, is_generated_secret=False):
+        def add_obj(name, data, explicit_name=None, is_generated_secret=False):
             labels = []
             if is_generated_secret:
                 labels.append("mesudip.secret.generated=true")
-            (object_name, command) = manager.create(name, data, labels=labels, stack=stack)
+
+            if explicit_name:
+                docker_object_name = explicit_name
+            elif stack:
+                docker_object_name = f"{stack}_{name}"
+            else:
+                docker_object_name = name
+
+            (object_name, command) = manager.create(docker_object_name, data, labels=labels, stack=stack)
             if not command.isNop():
                 self.commands.append(command)
                 # If a new secret was actually created (not just reused), store it
@@ -126,17 +302,18 @@ class DockerStack:
             processed_objects[name] = {"name": object_name, "external": True}
 
         for name, details in objects.items():
+            explicit_name = details.get("name") if isinstance(details, dict) else None
             if isinstance(details, dict) and "x-content" in details:
-                add_obj(name, details["x-content"])
+                add_obj(name, details["x-content"], explicit_name=explicit_name)
             elif isinstance(details, dict) and "x-template" in details:
-                add_obj(name, envsubst(details["x-content"], os.environ))
+                add_obj(name, envsubst(details["x-content"], os.environ), explicit_name=explicit_name)
             elif isinstance(details, dict) and "x-template-file" in details:
                 filename = os.path.join(base_dir, details["x-template-file"])
-                add_obj(name, envsubst_load_file(filename, os.environ))
+                add_obj(name, envsubst_load_file(filename, os.environ), explicit_name=explicit_name)
             elif isinstance(details, dict) and "file" in details:
                 filename = os.path.join(base_dir, details["file"])
                 with open(filename) as file:
-                    add_obj(name, file.read())
+                    add_obj(name, file.read(), explicit_name=explicit_name)
             elif isinstance(details, dict) and "x-generate" in details and manager.object_type == "secret":
                 is_generated_secret = True
                 generate_options = details["x-generate"]
@@ -159,7 +336,7 @@ class DockerStack:
                     raise ValueError(f"Invalid x-generate value for secret {name}: {generate_options}")
 
                 # Call add_obj with the potentially new secret content and the generated flag
-                add_obj(name, secret_content, is_generated_secret=True)
+                add_obj(name, secret_content, explicit_name=explicit_name, is_generated_secret=True)
             else:
                 processed_objects[name] = details
         return processed_objects
@@ -359,6 +536,11 @@ class DockerStack:
 
                 build_command = ["docker", "build", "-t", image]
 
+                dockerfile = build_config.get("dockerfile")
+                context_path = os.path.normpath(os.path.join(base_dir, build_config.get("context", ".")))
+                if dockerfile:
+                    build_command.extend(["-f", os.path.normpath(os.path.join(context_path, dockerfile))])
+
                 args = build_config.get("args", [])
 
                 if isinstance(args, dict):
@@ -368,7 +550,7 @@ class DockerStack:
                     for value in args:
                         build_command.extend(["--build-arg", envsubst(value)])
 
-                build_command.append(os.path.join(base_dir, build_config.get("context", ".")))
+                build_command.append(context_path)
                 self.commands.append(Command(build_command))
 
                 if push:
@@ -388,6 +570,72 @@ class DockerStack:
                 self.commands.append(cmd)
 
 
+class DockerNode:
+    @staticmethod
+    def _format_labels(labels: Dict[str, str]) -> str:
+        if not labels:
+            return "-"
+        parts = []
+        for key, value in sorted(labels.items()):
+            parts.append(key if value == "true" else f"{key}={value}")
+        return ", ".join(parts)
+
+    @staticmethod
+    def ls():
+        nodes_output = subprocess.check_output(["docker", "node", "ls", "--format", "{{json .}}"], text=True).strip()
+        rows = []
+
+        for line in nodes_output.splitlines():
+            if not line:
+                continue
+            node = json.loads(line)
+            inspect = json.loads(
+                subprocess.check_output(["docker", "node", "inspect", node["ID"], "--format", "{{json .}}"], text=True).strip()
+            )
+            labels = inspect.get("Spec", {}).get("Labels", {})
+            manager_status = node.get("ManagerStatus", "").strip()
+            role = inspect.get("Spec", {}).get("Role", "-")
+            role_display = f"{role} ({manager_status})" if manager_status else role
+            rows.append(
+                {
+                    "hostname": node.get("Hostname", "-"),
+                    "role": role_display,
+                    "state": f"{node.get('Status', '-')} / {node.get('Availability', '-')}",
+                    "address": inspect.get("Status", {}).get("Addr", "-"),
+                    "labels": DockerNode._format_labels(labels),
+                }
+            )
+
+        columns = [
+            ("Hostname", "hostname"),
+            ("Role", "role"),
+            ("State", "state"),
+            ("Address", "address"),
+        ]
+
+        widths = {
+            key: max(len(title), max((len(str(row[key])) for row in rows), default=0))
+            for title, key in columns
+        }
+        terminal_width = shutil.get_terminal_size((120, 20)).columns
+        static_width = sum(widths.values()) + (3 * (len(columns) - 1))
+        label_width = max(24, min(60, terminal_width - static_width - 3 - len("Labels")))
+
+        header = " | ".join(title.ljust(widths[key]) for title, key in columns) + " | Labels"
+        separator = "-+-".join("-" * widths[key] for _, key in columns) + "-+-" + ("-" * label_width)
+        print(header)
+        print(separator)
+        for row in rows:
+            wrapped_labels = textwrap.wrap(row["labels"], width=label_width, break_long_words=False, break_on_hyphens=False) or ["-"]
+            first_line = " | ".join(str(row[key]).ljust(widths[key]) for _, key in columns)
+            print(f"{first_line} | {wrapped_labels[0]}")
+            continuation_prefix = " | ".join("".ljust(widths[key]) for _, key in columns)
+            for label_line in wrapped_labels[1:]:
+                print(f"{continuation_prefix} | {label_line}")
+
+        return rows
+
+
 def main(args: List[str] = None):
     parser = argparse.ArgumentParser(description="Deploy and manage Docker stacks.")
     subparsers = parser.add_subparsers(dest="command", required=True)
@@ -419,6 +667,10 @@ def main(args: List[str] = None):
     # Ls command
     subparsers.add_parser("ls", help="List docker-stacks")
 
+    node_parser = subparsers.add_parser("node", help="Inspect Docker Swarm nodes")
+    node_subparsers = node_parser.add_subparsers(dest="node_command", required=True)
+    node_subparsers.add_parser("ls", help="List Docker Swarm nodes and their labels")
+
     cat_parser = subparsers.add_parser(
         "cat", help="Print the docker compose of specific version. Defaults to latest version if not specified."
     )
@@ -458,6 +710,9 @@ def main(args: List[str] = None):
         docker.stack.deploy(args.stack_name, args.compose_file, args.with_registry_auth, tag=args.tag, show_generated=args.show_generated)
     elif args.command == "ls":
         docker.stack.ls()
+    elif args.command == "node":
+        if args.node_command == "ls":
+            docker.node.ls()
 
     elif args.command == "rm":
         docker.stack.rm(args.stack_name)

{docker_stack-0.3.1 → docker_stack-1.0.0}/docker_stack/envsubst.py

@@ -123,16 +123,19 @@ def envsubst(template_str, env=os.environ, replacements: Dict[str, str] = None,
             # Group 1, 2 for ${VAR:-default}
             if match.group(1) is not None:
                 var = match.group(1)
-                default_value = match.group(2) if match.group(2) is not None else None
-                result = env.get(var, default_value)
-                if result is None:
+                has_default = match.group(2) is not None
+                default_value = match.group(2) if has_default else None
+                result = env.get(var, None)
+                if result in (None, "") and has_default:
+                    result = default_value
+                if result in (None, "") and not has_default:
                     line_errors_raw.append((var, match.start(1)))  # Use match.start(1) for ${VAR}
                     return match.group(0)  # Keep original if variable not found
             # Group 3 for $VAR
             else:
                 var = match.group(3)
                 result = env.get(var, None)
-                if result is None:
+                if result in (None, ""):
                     line_errors_raw.append((var, match.start(3)))  # Use match.start(3) for $VAR
                     return match.group(0)  # Keep original if variable not found
 

{docker_stack-0.3.1 → docker_stack-1.0.0}/docker_stack.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: docker-stack
-Version: 0.3.1
+Version: 1.0.0
 Summary: CLI for deploying and managing Docker stacks.
 Home-page: https://github.com/mesudip/docker-stack
 Author: Sudip Bhattarai

{docker_stack-0.3.1 → docker_stack-1.0.0}/docker_stack.egg-info/SOURCES.txt

@@ -19,4 +19,6 @@ docker_stack.egg-info/entry_points.txt
 docker_stack.egg-info/requires.txt
 docker_stack.egg-info/top_level.txt
 tests/test_docker_objects.py
-tests/test_docker_stack.py
+tests/test_docker_stack.py
+tests/test_load_env.py
+tests/test_node_ls.py

{docker_stack-0.3.1 → docker_stack-1.0.0}/setup.py

@@ -2,7 +2,7 @@ from setuptools import setup, find_packages
 
 setup(
     name="docker-stack",
-    version="0.3.1",
+    version="1.0.0",
     description="CLI for deploying and managing Docker stacks.",
     long_description=open("README.md").read(),  # You can include a README file to describe your package
     long_description_content_type="text/markdown",

docker_stack-1.0.0/tests/test_docker_stack.py

@@ -0,0 +1,107 @@
+from docker_stack.cli import Docker
+from docker_stack.docker_objects import DockerConfig, DockerSecret
+from docker_stack.helpers import Command, run_cli_command
+from docker_stack import main
+
+
+class RecordingManager:
+    def __init__(self):
+        self.calls = []
+
+    def create(self, object_name, object_content, labels=None, stack=None):
+        self.calls.append(
+            {
+                "object_name": object_name,
+                "object_content": object_content,
+                "labels": labels or [],
+                "stack": stack,
+            }
+        )
+        return object_name, Command.nop
+
+
+def test_when_create_stack_support_x_content():
+    main(["deploy", "pytest_test_x_content", "./tests/docker-compose-example.yml"])
+
+
+def test_process_x_content_prefixes_stack_name_for_unnamed_objects():
+    docker = Docker()
+    manager = RecordingManager()
+
+    processed = docker.stack._process_x_content(
+        {
+            "config.json": {
+                "x-content": "hello",
+            }
+        },
+        manager,
+        stack="govtool",
+    )
+
+    assert manager.calls == [
+        {
+            "object_name": "govtool_config.json",
+            "object_content": "hello",
+            "labels": [],
+            "stack": "govtool",
+        }
+    ]
+    assert processed == {"config.json": {"name": "govtool_config.json", "external": True}}
+
+
+def test_process_x_content_preserves_explicit_name_override():
+    docker = Docker()
+    manager = RecordingManager()
+
+    processed = docker.stack._process_x_content(
+        {
+            "config.json": {
+                "name": "shared-config",
+                "x-content": "hello",
+            }
+        },
+        manager,
+        stack="govtool",
+    )
+
+    assert manager.calls == [
+        {
+            "object_name": "shared-config",
+            "object_content": "hello",
+            "labels": [],
+            "stack": "govtool",
+        }
+    ]
+    assert processed == {"config.json": {"name": "shared-config", "external": True}}
+
+
+def test_build_uses_service_dockerfile(tmp_path):
+    compose_file = tmp_path / "docker-compose.yml"
+    compose_file.write_text(
+        """
+services:
+  storybook:
+    image: example/storybook:test
+    build:
+      context: ./frontend
+      dockerfile: storybook.Dockerfile
+      args:
+        NPMRC_TOKEN: dummy
+""".strip()
+    )
+
+    docker = Docker()
+    docker.stack.build_and_push(str(compose_file))
+
+    assert len(docker.stack.commands) == 1
+    assert docker.stack.commands[0].command == [
+        "docker",
+        "build",
+        "-t",
+        "example/storybook:test",
+        "-f",
+        str(tmp_path / "frontend" / "storybook.Dockerfile"),
+        "--build-arg",
+        "NPMRC_TOKEN=dummy",
+        str(tmp_path / "frontend"),
+    ]

docker_stack-1.0.0/tests/test_load_env.py

@@ -0,0 +1,154 @@
+import textwrap
+
+import pytest
+
+from docker_stack.cli import EnvFileResolutionError, load_env_file
+
+
+def write_env(tmp_path, content: str):
+    env_file = tmp_path / ".env"
+    env_file.write_text(textwrap.dedent(content).lstrip())
+    return env_file
+
+
+def test_load_env_file_resolves_forward_reference_order_independent(tmp_path):
+    env_file = write_env(
+        tmp_path,
+        """
+        C=${A}_ing
+        A=someth
+        """,
+    )
+
+    values = load_env_file(str(env_file), base_env={})
+
+    assert values["A"] == "someth"
+    assert values["C"] == "someth_ing"
+
+
+def test_load_env_file_strips_matching_quotes_from_values(tmp_path):
+    env_file = write_env(
+        tmp_path,
+        """
+        PINATA_API_JWT="abc.def"
+        IPFS_PROJECT_ID=''
+        """,
+    )
+
+    values = load_env_file(str(env_file), base_env={})
+
+    assert values["PINATA_API_JWT"] == "abc.def"
+    assert values["IPFS_PROJECT_ID"] == ""
+
+
+def test_load_env_file_resolves_references_inside_quoted_values(tmp_path):
+    env_file = write_env(
+        tmp_path,
+        """
+        C="${A}_ing"
+        A="someth"
+        """,
+    )
+
+    values = load_env_file(str(env_file), base_env={})
+
+    assert values["A"] == "someth"
+    assert values["C"] == "someth_ing"
+
+
+def test_load_env_file_resolves_chained_references_within_five_cycles(tmp_path):
+    env_file = write_env(
+        tmp_path,
+        """
+        E=${D}_e
+        D=${C}_d
+        C=${B}_c
+        B=${A}_b
+        A=base
+        """,
+    )
+
+    values = load_env_file(str(env_file), base_env={})
+
+    assert values["E"] == "base_b_c_d_e"
+
+
+def test_load_env_file_resolves_long_acyclic_dependency_chain(tmp_path):
+    chain = "\n".join([f"V{i}=${{V{i+1}}}" for i in range(10)] + ["V10=ok"])
+    env_file = write_env(tmp_path, chain)
+
+    values = load_env_file(str(env_file), base_env={})
+
+    assert values["V0"] == "ok"
+    assert values["V10"] == "ok"
+
+
+def test_load_env_file_reports_missing_variable_with_line_location(tmp_path):
+    env_file = write_env(
+        tmp_path,
+        """
+        A=${MISSING}_suffix
+        """,
+    )
+
+    with pytest.raises(EnvFileResolutionError) as excinfo:
+        load_env_file(str(env_file), base_env={})
+
+    message = str(excinfo.value)
+    assert "Missing environment variables" in message
+    assert str(env_file) in message
+    assert "1   A=${M̳I̳S̳S̳I̳N̳G̳}_suffix" in message
+
+
+def test_load_env_file_reports_missing_variable_inside_quoted_value_with_line_location(tmp_path):
+    env_file = write_env(
+        tmp_path,
+        """
+        A="${MISSING}_suffix"
+        """,
+    )
+
+    with pytest.raises(EnvFileResolutionError) as excinfo:
+        load_env_file(str(env_file), base_env={})
+
+    message = str(excinfo.value)
+    assert "Missing environment variables" in message
+    assert str(env_file) in message
+    assert '1   A="${M̳I̳S̳S̳I̳N̳G̳}_suffix"' in message
+
+
+def test_load_env_file_reports_empty_variable_reference_with_line_location(tmp_path):
+    env_file = write_env(
+        tmp_path,
+        """
+        VAR1=
+        IMAGE=myapp:${VAR1}
+        """,
+    )
+
+    with pytest.raises(EnvFileResolutionError) as excinfo:
+        load_env_file(str(env_file), base_env={})
+
+    message = str(excinfo.value)
+    assert "Missing environment variables" in message
+    assert str(env_file) in message
+    assert "2   IMAGE=myapp:${V̳A̳R̳1̳}" in message
+
+
+def test_load_env_file_reports_cycle_with_line_locations(tmp_path):
+    env_file = write_env(
+        tmp_path,
+        """
+        A=${B}
+        B=${A}
+        """,
+    )
+
+    with pytest.raises(EnvFileResolutionError) as excinfo:
+        load_env_file(str(env_file), base_env={})
+
+    message = str(excinfo.value)
+    assert "Cyclic environment variable references detected after 5 resolution passes" in message
+    assert str(env_file) in message
+    assert "1   A=${B̳}" in message
+    assert "2   B=${A̳}" in message

docker_stack-1.0.0/tests/test_node_ls.py

@@ -0,0 +1,76 @@
+import json
+import os
+
+from docker_stack.cli import main
+
+
+def test_node_ls_prints_nodes_and_labels(monkeypatch, capsys):
+    inspect_payloads = {
+        "node-1": {
+            "Spec": {
+                "Role": "manager",
+                "Labels": {
+                    "blockchain": "true",
+                    "gateway": "true",
+                    "newt.host": "prod1",
+                },
+            },
+            "Status": {"Addr": "10.0.0.1"},
+        },
+        "node-2": {
+            "Spec": {
+                "Role": "worker",
+                "Labels": {
+                    "govtool": "true",
+                },
+            },
+            "Status": {"Addr": "10.0.0.2"},
+        },
+    }
+
+    def fake_check_output(command, text=True):
+        if command[:3] == ["docker", "node", "ls"]:
+            return "\n".join(
+                [
+                    json.dumps(
+                        {
+                            "ID": "node-1",
+                            "Hostname": "swarm-a",
+                            "Status": "Ready",
+                            "Availability": "Active",
+                            "ManagerStatus": "Leader",
+                        }
+                    ),
+                    json.dumps(
+                        {
+                            "ID": "node-2",
+                            "Hostname": "swarm-b",
+                            "Status": "Ready",
+                            "Availability": "Drain",
+                            "ManagerStatus": "",
+                        }
+                    ),
+                ]
+            )
+        if command[:3] == ["docker", "node", "inspect"]:
+            return json.dumps(inspect_payloads[command[3]])
+        raise AssertionError(f"Unexpected command: {command}")
+
+    monkeypatch.setattr("docker_stack.cli.subprocess.check_output", fake_check_output)
+    monkeypatch.setattr("docker_stack.cli.shutil.get_terminal_size", lambda fallback: os.terminal_size((72, 20)))
+
+    main(["node", "ls"])
+
+    output = capsys.readouterr().out
+    assert "Hostname" in output
+    assert "Role" in output
+    assert "State" in output
+    assert "Labels" in output
+    assert "swarm-a" in output
+    assert "manager (Leader)" in output
+    assert "10.0.0.1" in output
+    assert "blockchain, gateway," in output
+    assert "newt.host=prod1" in output
+    assert "swarm-b" in output
+    assert "worker" in output
+    assert "govtool" in output

docker_stack-0.3.1/tests/test_docker_stack.py

@@ -1,7 +0,0 @@
-from docker_stack.docker_objects import DockerConfig, DockerSecret
-from docker_stack.helpers import Command, run_cli_command
-from docker_stack import main
-
-
-def test_when_create_stack_support_x_content():
-    main(["deploy", "pytest_test_x_content", "./tests/docker-compose-example.yml"])