vault88 0.1.0__tar.gz

vault88-0.1.0/PKG-INFO

@@ -0,0 +1,168 @@
+Metadata-Version: 2.4
+Name: vault88
+Version: 0.1.0
+Summary: Python automated test framework
+Author-email: Brad Murdoch <brad.murdoch@me.ca>
+License: MIT
+Project-URL: Documentation, https://gitlab.glider-eng.com/python-packages/vault88/-/wikis/home
+Project-URL: Issues, https://gitlab.glider-eng.com/python-packages/vault88/-/work_items
+Project-URL: Source, https://gitlab.glider-eng.com/python-packages/vault88
+Classifier: Development Status :: 4 - Beta
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3.12
+Classifier: License :: OSI Approved :: MIT License
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+Requires-Dist: junit-xml==1.9
+Requires-Dist: paramiko<4,>=3.0
+Requires-Dist: selenium<5,>=4.0
+
+# vault88
+
+[![pipeline status](https://gitlab.glider-eng.com/python-packages/vault88/badges/main/pipeline.svg)](https://gitlab.glider-eng.com/python-packages/vault88/-/pipelines)
+[![coverage report](https://gitlab.glider-eng.com/python-packages/vault88/badges/main/coverage.svg)](https://gitlab.glider-eng.com/python-packages/vault88/-/commits/main)
+
+**vault88** is a Python automated test framework designed for structured hardware and software validation in CI/CD pipelines. Tests are written as Python classes, organised into stages, and results can be published through configurable reporters.
+
+## Architecture
+
+| Component | Role |
+|---|---|
+| `Loader` | Discovers test classes from files or directories; supports tag-based include/exclude filtering |
+| `Logger` | Centralised logging with rotating file handler and optional verbose (debug) output |
+| `Runner` | Instantiates and executes a test class through its full lifecycle: `selfCheck` → `setup` → `run` → `teardown` |
+| `Reporter` | Pluggable reporters loaded from the config file; built-in reporters include JUnit XML and log archive |
+
+Test results are grouped into named **stages** within each test, and each result records an action, expected value, actual value, outcome, timestamp, and optional requirement references.
+
+## Installation
+
+```bash
+pip install vault88
+```
+
+Or with [uv](https://docs.astral.sh/uv/):
+
+```bash
+uv add vault88
+```
+
+## Writing a test
+
+Subclass `Test` and implement the four lifecycle methods:
+
+```python
+from vault88 import Test
+
+class MyTest(Test):
+    name = "My Test"
+    tags = ["smoke"]
+
+    def selfCheck(self) -> bool:
+        # Return False to skip the test entirely
+        return True
+
+    def setup(self) -> bool:
+        # Prepare resources; return False to abort
+        return True
+
+    def run(self) -> None:
+        self.newStage("Basic checks")
+        self.assertEqual("Verify result", expected=42, actual=compute())
+
+    def teardown(self) -> None:
+        pass
+```
+
+Available assertion helpers: `assertEqual`, `assertNotEqual`, `assertTrue`, `assertFalse`, `assertGreaterThan`, `assertLessThan`, `assertGreaterThanOrEqual`, `assertLessThanOrEqual`, `assertIn`, `assertNotIn`, `assertIsNone`, `assertIsNotNone`.
+
+## Running tests
+
+```bash
+vault88 <testpath> [options]
+```
+
+| Option | Description |
+|---|---|
+| `testpath` | Path to a test file or directory |
+| `-t TAG [TAG ...]` | Only run tests that have **at least one** of these tags |
+| `-nt TAG [TAG ...]` | Exclude tests that have any of these tags |
+| `-r` | Recursively search directories for tests |
+| `-l FILE` | Log file path (default: `./test_execution.log`) |
+| `-v` | Verbose / debug logging |
+| `--env PATH_OR_URL` | Load an environment from a JSON file or HTTP(S) URL |
+| `--junit` | Generate a `testresults.xml` JUnit report in the current directory |
+
+## Configuration
+
+Reporters are configured in `/etc/vault88.conf` (INI format). Each `[REPORTER<n>]` section loads one reporter:
+
+```ini
+[REPORTER1]
+module = vault88.core.reporters.junit_reporter
+class = JUnitReporter
+enabled = true
+suite_name = My Project Tests
+
+[REPORTER2]
+module = vault88.core.reporters.log_archive_reporter
+class = LogArchiveReporter
+enabled = true
+output_dir = ./logs
+```
+
+## Development
+
+Dependencies are managed with [uv](https://docs.astral.sh/uv/). Install the project with test dependencies:
+
+```bash
+uv sync
+```
+
+### Running the test suite
+
+```bash
+uv run pytest
+```
+
+Run with coverage:
+
+```bash
+uv run pytest --cov=vault88 --cov-report=term-missing
+```
+
+Run tests in parallel:
+
+```bash
+uv run pytest -n auto
+```
+
+### Linting with ruff
+
+Check for issues:
+
+```bash
+uv run ruff check .
+```
+
+Auto-fix fixable issues:
+
+```bash
+uv run ruff check --fix .
+```
+
+Check formatting:
+
+```bash
+uv run ruff format --check .
+```
+
+Apply formatting:
+
+```bash
+uv run ruff format .
+```
+
+## License
+
+MIT

vault88-0.1.0/README.md

@@ -0,0 +1,149 @@
+# vault88
+
+[![pipeline status](https://gitlab.glider-eng.com/python-packages/vault88/badges/main/pipeline.svg)](https://gitlab.glider-eng.com/python-packages/vault88/-/pipelines)
+[![coverage report](https://gitlab.glider-eng.com/python-packages/vault88/badges/main/coverage.svg)](https://gitlab.glider-eng.com/python-packages/vault88/-/commits/main)
+
+**vault88** is a Python automated test framework designed for structured hardware and software validation in CI/CD pipelines. Tests are written as Python classes, organised into stages, and results can be published through configurable reporters.
+
+## Architecture
+
+| Component | Role |
+|---|---|
+| `Loader` | Discovers test classes from files or directories; supports tag-based include/exclude filtering |
+| `Logger` | Centralised logging with rotating file handler and optional verbose (debug) output |
+| `Runner` | Instantiates and executes a test class through its full lifecycle: `selfCheck` → `setup` → `run` → `teardown` |
+| `Reporter` | Pluggable reporters loaded from the config file; built-in reporters include JUnit XML and log archive |
+
+Test results are grouped into named **stages** within each test, and each result records an action, expected value, actual value, outcome, timestamp, and optional requirement references.
+
+## Installation
+
+```bash
+pip install vault88
+```
+
+Or with [uv](https://docs.astral.sh/uv/):
+
+```bash
+uv add vault88
+```
+
+## Writing a test
+
+Subclass `Test` and implement the four lifecycle methods:
+
+```python
+from vault88 import Test
+
+class MyTest(Test):
+    name = "My Test"
+    tags = ["smoke"]
+
+    def selfCheck(self) -> bool:
+        # Return False to skip the test entirely
+        return True
+
+    def setup(self) -> bool:
+        # Prepare resources; return False to abort
+        return True
+
+    def run(self) -> None:
+        self.newStage("Basic checks")
+        self.assertEqual("Verify result", expected=42, actual=compute())
+
+    def teardown(self) -> None:
+        pass
+```
+
+Available assertion helpers: `assertEqual`, `assertNotEqual`, `assertTrue`, `assertFalse`, `assertGreaterThan`, `assertLessThan`, `assertGreaterThanOrEqual`, `assertLessThanOrEqual`, `assertIn`, `assertNotIn`, `assertIsNone`, `assertIsNotNone`.
+
+## Running tests
+
+```bash
+vault88 <testpath> [options]
+```
+
+| Option | Description |
+|---|---|
+| `testpath` | Path to a test file or directory |
+| `-t TAG [TAG ...]` | Only run tests that have **at least one** of these tags |
+| `-nt TAG [TAG ...]` | Exclude tests that have any of these tags |
+| `-r` | Recursively search directories for tests |
+| `-l FILE` | Log file path (default: `./test_execution.log`) |
+| `-v` | Verbose / debug logging |
+| `--env PATH_OR_URL` | Load an environment from a JSON file or HTTP(S) URL |
+| `--junit` | Generate a `testresults.xml` JUnit report in the current directory |
+
+## Configuration
+
+Reporters are configured in `/etc/vault88.conf` (INI format). Each `[REPORTER<n>]` section loads one reporter:
+
+```ini
+[REPORTER1]
+module = vault88.core.reporters.junit_reporter
+class = JUnitReporter
+enabled = true
+suite_name = My Project Tests
+
+[REPORTER2]
+module = vault88.core.reporters.log_archive_reporter
+class = LogArchiveReporter
+enabled = true
+output_dir = ./logs
+```
+
+## Development
+
+Dependencies are managed with [uv](https://docs.astral.sh/uv/). Install the project with test dependencies:
+
+```bash
+uv sync
+```
+
+### Running the test suite
+
+```bash
+uv run pytest
+```
+
+Run with coverage:
+
+```bash
+uv run pytest --cov=vault88 --cov-report=term-missing
+```
+
+Run tests in parallel:
+
+```bash
+uv run pytest -n auto
+```
+
+### Linting with ruff
+
+Check for issues:
+
+```bash
+uv run ruff check .
+```
+
+Auto-fix fixable issues:
+
+```bash
+uv run ruff check --fix .
+```
+
+Check formatting:
+
+```bash
+uv run ruff format --check .
+```
+
+Apply formatting:
+
+```bash
+uv run ruff format .
+```
+
+## License
+
+MIT

vault88-0.1.0/pyproject.toml

@@ -0,0 +1,66 @@
+[build-system]
+requires = ["setuptools>=68", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "vault88"
+version = "0.1.0"
+authors = [
+    { name = "Brad Murdoch", email = "brad.murdoch@me.ca" }
+]
+description = "Python automated test framework"
+readme = "README.md"
+requires-python = ">=3.12"
+license = { text = "MIT" }
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Programming Language :: Python",
+    "Programming Language :: Python :: 3.12",
+    "License :: OSI Approved :: MIT License"
+]
+dependencies = [
+    "junit-xml==1.9",
+    "paramiko>=3.0,<4",
+    "selenium>=4.0,<5",
+]
+
+[project.urls]
+Documentation = "https://gitlab.glider-eng.com/python-packages/vault88/-/wikis/home"
+Issues = "https://gitlab.glider-eng.com/python-packages/vault88/-/work_items"
+Source = "https://gitlab.glider-eng.com/python-packages/vault88"
+
+[project.scripts]
+vault88 = "vault88.main:main"
+
+[dependency-groups]
+test = [
+    "coverage[toml]>=7.13.4,<8",
+    "pytest>=9.0.2,<10",
+    "pytest-cov>=7.0.0,<8",
+    "pytest-xdist>=3.8.0,<4",
+    "ruff>=0.15.2,<1"
+]
+
+[tool.uv]
+default-groups = ["test"]
+
+[[tool.uv.index]]
+name = "nexus"
+url = "https://nexus.glider-eng.com/repository/pypi_hosted/simple/"
+publish-url = "https://nexus.glider-eng.com/repository/pypi_hosted/"
+explicit = true
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+
+[tool.coverage.run]
+branch = true
+parallel = true
+omit = []
+
+[tool.ruff]
+line-length = 100
+target-version = "py312"
+
+[tool.ruff.lint]
+select = ["E", "F", "I"]

vault88-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

vault88-0.1.0/tests/test_args.py

@@ -0,0 +1,65 @@
+"""Tests for CLI argument parsing"""
+
+from vault88.args import parseArgs
+
+
+class TestParseArgs:
+    def test_minimal_required_arg(self, monkeypatch):
+        monkeypatch.setattr("sys.argv", ["vault88", "tests/"])
+        args = parseArgs()
+        assert args.testpath == "tests/"
+
+    def test_tags_flag(self, monkeypatch):
+        monkeypatch.setattr("sys.argv", ["vault88", "tests/", "-t", "smoke", "fast"])
+        args = parseArgs()
+        assert args.tags == ["smoke", "fast"]
+
+    def test_nottags_flag(self, monkeypatch):
+        monkeypatch.setattr("sys.argv", ["vault88", "tests/", "-nt", "slow"])
+        args = parseArgs()
+        assert args.nottags == ["slow"]
+
+    def test_recursive_flag(self, monkeypatch):
+        monkeypatch.setattr("sys.argv", ["vault88", "tests/", "-r"])
+        args = parseArgs()
+        assert args.recursive is True
+
+    def test_recursive_default_is_false(self, monkeypatch):
+        monkeypatch.setattr("sys.argv", ["vault88", "tests/"])
+        args = parseArgs()
+        assert args.recursive is False
+
+    def test_log_flag(self, monkeypatch):
+        monkeypatch.setattr("sys.argv", ["vault88", "tests/", "-l", "/tmp/run.log"])
+        args = parseArgs()
+        assert args.log == "/tmp/run.log"
+
+    def test_log_default(self, monkeypatch):
+        monkeypatch.setattr("sys.argv", ["vault88", "tests/"])
+        args = parseArgs()
+        assert args.log == "./test_execution.log"
+
+    def test_junit_flag(self, monkeypatch):
+        monkeypatch.setattr("sys.argv", ["vault88", "tests/", "--junit"])
+        args = parseArgs()
+        assert args.junit is True
+
+    def test_verbose_flag(self, monkeypatch):
+        monkeypatch.setattr("sys.argv", ["vault88", "tests/", "-v"])
+        args = parseArgs()
+        assert args.verbose is True
+
+    def test_env_flag(self, monkeypatch):
+        monkeypatch.setattr("sys.argv", ["vault88", "tests/", "--env", "http://env.local/api"])
+        args = parseArgs()
+        assert args.env == "http://env.local/api"
+
+    def test_tags_default_is_none(self, monkeypatch):
+        monkeypatch.setattr("sys.argv", ["vault88", "tests/"])
+        args = parseArgs()
+        assert args.tags is None
+
+    def test_env_default_is_none(self, monkeypatch):
+        monkeypatch.setattr("sys.argv", ["vault88", "tests/"])
+        args = parseArgs()
+        assert args.env is None

vault88-0.1.0/tests/test_console.py

@@ -0,0 +1,160 @@
+"""Tests for console.py truncation and overflow guards"""
+
+from vault88.constructs.result import Result, ResultOutcome
+from vault88.utils.console import (
+    _box_line,
+    _visible_truncate,
+    result_box_lines,
+    strip_ansi,
+)
+
+_GREEN = "\033[32m"
+_RESET = "\033[0m"
+_WIDTH = 80
+
+
+def _result(
+    action="act", expected="exp", actual="act", outcome=ResultOutcome.PASSED, requirements=None
+):
+    return Result(action, expected, actual, outcome, requirements or [])
+
+
+def _display_width(line: str) -> int:
+    return len(strip_ansi(line))
+
+
+class TestVisibleTruncate:
+    def test_zero_width_returns_empty(self):
+        assert _visible_truncate("hello", 0) == ""
+
+    def test_negative_width_returns_empty(self):
+        assert _visible_truncate("hello", -5) == ""
+
+    def test_text_shorter_than_max_unchanged(self):
+        assert _visible_truncate("hi", 10) == "hi"
+
+    def test_text_exactly_at_max_unchanged(self):
+        assert _visible_truncate("hello", 5) == "hello"
+
+    def test_plain_text_truncated_with_ellipsis(self):
+        result = _visible_truncate("abcdef", 4)
+        assert result == "abc…"
+
+    def test_truncated_visible_length_equals_max_width(self):
+        result = _visible_truncate("abcdefghij", 6)
+        assert len(strip_ansi(result)) == 6
+
+    def test_ansi_codes_not_counted_toward_width(self):
+        colored = f"{_GREEN}hello{_RESET}"
+        result = _visible_truncate(colored, 5)
+        assert strip_ansi(result) == "hello"
+
+    def test_ansi_codes_preserved_before_cut_point(self):
+        colored = f"{_GREEN}abcdef{_RESET}"
+        result = _visible_truncate(colored, 4)
+        assert strip_ansi(result) == "abc…"
+        assert _GREEN in result
+
+    def test_ansi_colored_truncated_visible_length_matches_max_width(self):
+        colored = f"{_GREEN}abcdefghij{_RESET}"
+        result = _visible_truncate(colored, 6)
+        assert len(strip_ansi(result)) == 6
+
+
+class TestBoxLine:
+    def test_short_content_pads_to_box_width(self):
+        assert _display_width(_box_line("hi", 20)) == 20
+
+    def test_empty_content_pads_to_box_width(self):
+        assert _display_width(_box_line("", 20)) == 20
+
+    def test_content_fills_inner_exactly(self):
+        inner = 20 - 4
+        assert _display_width(_box_line("x" * inner, 20)) == 20
+
+    def test_content_exceeding_inner_truncated_to_box_width(self):
+        assert _display_width(_box_line("x" * 200, 20)) == 20
+
+    def test_truncated_line_contains_ellipsis(self):
+        assert "…" in _box_line("x" * 200, 20)
+
+    def test_truncated_line_has_right_border(self):
+        assert _box_line("x" * 200, 20).endswith("│")
+
+    def test_all_lines_start_with_left_border(self):
+        for content in ("", "short", "x" * 200):
+            assert _box_line(content, 40).startswith("│")
+
+    def test_ansi_content_exceeding_inner_truncated_to_box_width(self):
+        content = f"{_GREEN}" + "x" * 100 + f"{_RESET}"
+        assert _display_width(_box_line(content, 20)) == 20
+
+
+class TestResultBoxLinesOverflow:
+    def _badge_in(self, lines, badge="[PASS]"):
+        return any(badge in strip_ansi(line) for line in lines)
+
+    def _all_widths(self, lines):
+        return [_display_width(line) for line in lines]
+
+    def test_normal_result_all_lines_fit_exactly(self):
+        lines = result_box_lines(_result(), _WIDTH)
+        assert all(w == _WIDTH for w in self._all_widths(lines))
+
+    def test_pass_badge_present(self):
+        lines = result_box_lines(_result(outcome=ResultOutcome.PASSED), _WIDTH)
+        assert self._badge_in(lines, "[PASS]")
+
+    def test_fail_badge_present(self):
+        lines = result_box_lines(_result(outcome=ResultOutcome.FAILED), _WIDTH)
+        assert self._badge_in(lines, "[FAIL]")
+
+    def test_long_action_all_lines_fit(self):
+        lines = result_box_lines(_result(action="A" * 300), _WIDTH)
+        assert all(w == _WIDTH for w in self._all_widths(lines))
+
+    def test_long_expected_all_lines_fit(self):
+        lines = result_box_lines(_result(expected="E" * 300), _WIDTH)
+        assert all(w == _WIDTH for w in self._all_widths(lines))
+
+    def test_long_actual_all_lines_fit(self):
+        lines = result_box_lines(_result(actual="A" * 300), _WIDTH)
+        assert all(w == _WIDTH for w in self._all_widths(lines))
+
+    def test_long_requirements_all_lines_fit(self):
+        reqs = ["REQ-" + str(i) for i in range(50)]
+        lines = result_box_lines(_result(requirements=reqs), _WIDTH)
+        assert all(w == _WIDTH for w in self._all_widths(lines))
+
+    def test_badge_present_with_all_fields_long(self):
+        r = _result(
+            action="ACT" * 100,
+            expected="EXP" * 100,
+            actual="ACT" * 100,
+            requirements=["REQ-" + str(i) for i in range(30)],
+        )
+        lines = result_box_lines(r, _WIDTH)
+        assert self._badge_in(lines, "[PASS]")
+        assert all(w == _WIDTH for w in self._all_widths(lines))
+
+    def test_narrow_width_all_lines_fit(self):
+        lines = result_box_lines(_result(), 20)
+        assert all(w == 20 for w in self._all_widths(lines))
+
+    def test_narrow_width_badge_present(self):
+        lines = result_box_lines(_result(outcome=ResultOutcome.PASSED), 20)
+        assert self._badge_in(lines, "[PASS]")
+
+    def test_last_field_line_too_long_badge_still_present(self):
+        # Actual is the last field with no reqs; its last wrapped chunk will be
+        # artificially wide enough to trigger the badge-overflow guard.
+        r = _result(actual="X" * 300)
+        lines = result_box_lines(r, _WIDTH)
+        assert self._badge_in(lines, "[PASS]")
+        assert all(w == _WIDTH for w in self._all_widths(lines))
+
+    def test_long_reqs_last_line_badge_still_present(self):
+        r = _result(requirements=["REQ-" + "X" * 60])
+        lines = result_box_lines(r, _WIDTH)
+        assert self._badge_in(lines, "[PASS]")
+        assert all(w == _WIDTH for w in self._all_widths(lines))

vault88-0.1.0/tests/test_environment.py

@@ -0,0 +1,82 @@
+"""Tests for environment dataclasses and their from_dict constructors"""
+
+from vault88.constructs.environment import Credential, Environment, Host, Service
+
+
+class TestCredential:
+    def test_username_only(self):
+        c = Credential.from_dict({"username": "alice"})
+        assert c.username == "alice"
+        assert c.password is None
+        assert c.key_path is None
+
+    def test_with_password_and_key_path(self):
+        c = Credential.from_dict({"username": "bob", "password": "s3cr3t", "key_path": "/id_rsa"})
+        assert c.password == "s3cr3t"
+        assert c.key_path == "/id_rsa"
+
+
+class TestService:
+    def test_minimal(self):
+        s = Service.from_dict({"name": "http"})
+        assert s.name == "http"
+        assert s.port is None
+        assert s.url is None
+        assert s.credential is None
+
+    def test_with_port_url_and_credential(self):
+        s = Service.from_dict(
+            {
+                "name": "api",
+                "port": 8080,
+                "url": "http://localhost:8080",
+                "credential": {"username": "admin"},
+            }
+        )
+        assert s.port == 8080
+        assert s.url == "http://localhost:8080"
+        assert s.credential is not None
+        assert s.credential.username == "admin"
+
+
+class TestHost:
+    def test_minimal(self):
+        h = Host.from_dict({"name": "server", "address": "10.0.0.1"})
+        assert h.name == "server"
+        assert h.address == "10.0.0.1"
+        assert h.services == []
+        assert h.credential is None
+
+    def test_with_services_and_credential(self):
+        h = Host.from_dict(
+            {
+                "name": "server",
+                "address": "10.0.0.1",
+                "services": [{"name": "ssh", "port": 22}],
+                "credential": {"username": "root"},
+            }
+        )
+        assert len(h.services) == 1
+        assert h.services[0].name == "ssh"
+        assert h.credential.username == "root"
+
+
+class TestEnvironment:
+    def test_minimal(self):
+        e = Environment.from_dict({"name": "staging"})
+        assert e.name == "staging"
+        assert e.hosts == []
+
+    def test_with_hosts(self):
+        e = Environment.from_dict(
+            {
+                "name": "prod",
+                "hosts": [
+                    {"name": "web1", "address": "192.168.0.1"},
+                    {"name": "db1", "address": "192.168.0.2"},
+                ],
+            }
+        )
+        assert len(e.hosts) == 2
+        assert e.hosts[0].name == "web1"
+        assert e.hosts[1].name == "db1"