pytest-embedded-wireskein 0.0.1__tar.gz

pytest_embedded_wireskein-0.0.1/.gitignore

@@ -0,0 +1,36 @@
+# Python
+__pycache__/
+*.py[cod]
+*.so
+.Python
+
+# Build / packaging
+build/
+dist/
+*.egg-info/
+.eggs/
+pip-wheel-metadata/
+
+# Virtual environments
+.venv/
+venv/
+env/
+.env
+
+# Test / tooling caches
+.pytest_cache/
+.coverage
+.coverage.*
+htmlcov/
+.mypy_cache/
+.ruff_cache/
+report.html
+
+# IDE / OS
+.DS_Store
+.idea/
+.vscode/
+
+# Local dependency locks
+uv.lock
+

pytest_embedded_wireskein-0.0.1/CHANGELOG.md

@@ -0,0 +1,7 @@
+# Changelog / 変更履歴
+
+## Unreleased
+
+## 0.0.1
+- (EN) First beta. The `ws_run` fixture gives each test a `wireskein.runlog.Recorder` writing into `<test_case_tempdir>/wireskein/`, next to `dut.log`. When the test body ends the run is verified: a failing check fails the test in its call phase (FAILED), `report.json` and `report.xml` are written, and the result lines are attached to the test report. `--wireskein-verify` / `wireskein_verify` = `fail` (default), `report` or `off`.
+- (JA) 最初のβ版。`ws_run` fixture が test ごとに `wireskein.runlog.Recorder` を渡し、`dut.log` の隣の `<test_case_tempdir>/wireskein/` に記録する。test の本体が終わると照合する。検査が NG なら call の段で test を失敗（FAILED）にし、`report.json` と `report.xml` を書き、結果の行を test の報告に付ける。`--wireskein-verify` / `wireskein_verify` は `fail`（既定）、`report`、`off`。

pytest_embedded_wireskein-0.0.1/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Open Embedded Probe
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

pytest_embedded_wireskein-0.0.1/PKG-INFO

@@ -0,0 +1,111 @@
+Metadata-Version: 2.5
+Name: pytest-embedded-wireskein
+Version: 0.0.1
+Summary: pytest-embedded plugin: record logic-analyzer captures per test with WireSkein and fail the test when a waveform check fails
+Project-URL: Homepage, https://github.com/Open-Embedded-Probe/pytest-embedded-wireskein
+Project-URL: Repository, https://github.com/Open-Embedded-Probe/pytest-embedded-wireskein
+Author: TANAKA Masayuki
+License-Expression: MIT
+License-File: LICENSE
+Classifier: Development Status :: 4 - Beta
+Classifier: Framework :: Pytest
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Software Development :: Testing
+Requires-Python: >=3.13
+Requires-Dist: pytest-embedded>=2.0
+Requires-Dist: pytest>=8
+Requires-Dist: wireskein>=0.0.1
+Description-Content-Type: text/markdown
+
+# pytest-embedded-wireskein
+
+[日本語 README](https://github.com/Open-Embedded-Probe/pytest-embedded-wireskein/blob/main/README.ja.md)
+
+A [pytest-embedded](https://github.com/espressif/pytest-embedded) plugin that gives each test a [WireSkein](https://github.com/Open-Embedded-Probe/wireskein) recorder, `ws_run`. The test records the commands it sent, the logic-analyzer captures, and what each step should look like on the wire. When the test body ends, the plugin checks the captures against these expectations and fails the test if a check fails.
+
+Status: **beta**.
+
+## Install
+
+```sh
+pip install pytest-embedded-wireskein
+```
+
+Python 3.13 or newer. This installs `wireskein` and `pytest-embedded`.
+
+## Use
+
+```python
+from wireskein.runlog import square, level, only_moving
+
+def test_pwm(dut, ws_run, probe):              # `probe` is whatever drives your logic analyzer
+    with ws_run.section(1, "pwm"):
+        for duty in (64, 128, 0):
+            want = [square("PA1", 1000, duty / 255), only_moving(["PA1"])] if duty else [level("PA1", 0)]
+            with ws_run.section(2, f"duty={duty}", expect=want):
+                ws_run.command(f"PWM {duty}")
+                dut.write(f"PWM {duty}")
+                ws_run.reply(dut.expect(r"PWM duty=\d+").group(0).decode())
+                t = ws_run.armed()               # right after arming the capture
+                data, rate = probe.capture()     # bytes, one sample per byte, bit k = pin k
+                ws_run.capture(data, rate, ["PA1", "PA0"], t)
+```
+
+When `test_pwm` returns, the plugin closes the run and verifies it. If a check fails, the test fails in its call phase (FAILED, not ERROR):
+
+```text
+FAILED test_pwm.py::test_pwm - wireskein: 1 NG (5 ok, 1 ng, 0 unchecked (4 segments, 3 captures))
+NG  pwm/duty=128  square  c0002.bin  duty 0.6999 vs 0.5020
+report: /tmp/pytest-embedded/2026-09-29_12-00-00-000000/test_pwm/wireskein/report.json
+```
+
+The checks (`square`, `level`, `starts`, `ends`, `only_moving`, `pulses`, `i2c`, `spi`, `uart`) and the heading rules are described in the [WireSkein README](https://github.com/Open-Embedded-Probe/wireskein#checking-a-test-run).
+
+### Where the run is written
+
+`ws_run` writes to `<test_case_tempdir>/wireskein/`, next to pytest-embedded's `dut.log`: `<root-logdir>/pytest-embedded/<time>/<test name>/wireskein/`.
+
+| File | Content |
+| --- | --- |
+| `run.json` | Headings, commands, replies, notes, captures and expectations (WireSkein run format) |
+| `c0001.bin`, ... | The captures |
+| `report.json` | Every result with measured values, and the log |
+| `report.xml` | The results as JUnit XML |
+
+The same directory can be checked again later with `wireskein verify <dir>`. The test's `user_properties` carry `wireskein_report` (the path of `report.json`), and the result lines are added to the test report as a `wireskein` section (shown with `-rA` or on failure).
+
+### When the plugin verifies
+
+- The run is verified after the test body, only if the test recorded a capture or an expectation.
+- A check that fails makes the test fail.
+- A check whose pins were not captured is unchecked and does not fail the test.
+- If the test body already failed, the run is still recorded and verified, but the test's own failure is kept.
+
+### Options
+
+| Option | ini | Default | Meaning |
+| --- | --- | --- | --- |
+| `--wireskein-verify=fail\|report\|off` | `wireskein_verify` | `fail` | `fail`: verify and fail on NG. `report`: verify and write the reports, never fail. `off`: record only |
+
+### Connecting a probe
+
+This plugin knows nothing about probes or targets. A fixture that drives the logic analyzer (for example the one of a board-family plugin) connects to `ws_run` when both are installed:
+
+- right after arming a capture: `t = ws_run.armed()`
+- when the samples are read: `ws_run.capture(data, rate, bits, t, start_us=..., time_base_slipped=True)`. `bits` lists the target's pin names in bit order. Pass `time_base_slipped` only when the probe reports it.
+- the console traffic: `ws_run.command(text)`, `ws_run.reply(text)`
+
+## Development
+
+```sh
+uv sync
+uv run pytest
+```
+
+## Release
+
+The release works the same way as in [pytest-embedded-arduino-cli](https://github.com/tanakamasayuki/pytest-embedded-arduino-cli#release). Update `## Unreleased` in `CHANGELOG.md`, then run the `Release` workflow with the version (for example `0.0.2`). PyPI publishing uses Trusted Publishing.
+
+## License
+
+MIT

pytest_embedded_wireskein-0.0.1/README.ja.md

@@ -0,0 +1,101 @@
+# pytest-embedded-wireskein
+
+[English README](https://github.com/Open-Embedded-Probe/pytest-embedded-wireskein/blob/main/README.md)
+
+[pytest-embedded](https://github.com/espressif/pytest-embedded) のプラグインです。test ごとに、[WireSkein](https://github.com/Open-Embedded-Probe/wireskein) の記録器 `ws_run` を渡します。
+
+- test は、送ったコマンド、ロジックアナライザのキャプチャ、各ステップの線の上であるべき姿を記録します。
+- test の本体が終わると、プラグインがキャプチャを期待と照らし合わせます。
+- 検査が NG なら、その test を失敗にします。
+
+状態: **β 版**です。
+
+## 入れ方
+
+```sh
+pip install pytest-embedded-wireskein
+```
+
+Python 3.13 以上が要ります。`wireskein` と `pytest-embedded` も一緒に入ります。
+
+## 使い方
+
+```python
+from wireskein.runlog import square, level, only_moving
+
+def test_pwm(dut, ws_run, probe):              # probe は、ロジックアナライザを動かす何かの fixture
+    with ws_run.section(1, "pwm"):
+        for duty in (64, 128, 0):
+            want = [square("PA1", 1000, duty / 255), only_moving(["PA1"])] if duty else [level("PA1", 0)]
+            with ws_run.section(2, f"duty={duty}", expect=want):
+                ws_run.command(f"PWM {duty}")
+                dut.write(f"PWM {duty}")
+                ws_run.reply(dut.expect(r"PWM duty=\d+").group(0).decode())
+                t = ws_run.armed()               # キャプチャを開始した直後
+                data, rate = probe.capture()     # bytes。1 サンプル 1 バイト、ビット k がピン k
+                ws_run.capture(data, rate, ["PA1", "PA0"], t)
+```
+
+`test_pwm` が戻ると、プラグインは記録を閉じて照合します。NG があれば、test は call の段で失敗します（ERROR ではなく FAILED）。
+
+```text
+FAILED test_pwm.py::test_pwm - wireskein: 1 NG (5 ok, 1 ng, 0 unchecked (4 segments, 3 captures))
+NG  pwm/duty=128  square  c0002.bin  duty 0.6999 vs 0.5020
+report: /tmp/pytest-embedded/2026-09-29_12-00-00-000000/test_pwm/wireskein/report.json
+```
+
+検査の一覧（`square`、`level`、`starts`、`ends`、`only_moving`、`pulses`、`i2c`、`spi`、`uart`）と見出しの規則は、[WireSkein の README](https://github.com/Open-Embedded-Probe/wireskein/blob/main/README.ja.md) にあります。
+
+### 記録の置き場所
+
+`ws_run` は、pytest-embedded の `dut.log` の隣の `<test_case_tempdir>/wireskein/` に書きます。フルパスは `<root-logdir>/pytest-embedded/<時刻>/<test 名>/wireskein/` です。
+
+| ファイル | 中身 |
+| --- | --- |
+| `run.json` | 見出し、コマンド、応答、メモ、キャプチャ、期待（WireSkein の記録の形式） |
+| `c0001.bin` など | キャプチャ |
+| `report.json` | すべての結果と測定値、ログ |
+| `report.xml` | 結果の JUnit XML |
+
+同じディレクトリは、後から `wireskein verify <ディレクトリ>` で照合し直せます。
+
+- test の `user_properties` には、`wireskein_report`（`report.json` のパス）が入ります。
+- 結果の行は、test の報告に `wireskein` の節として付きます（`-rA` や失敗のときに表示されます）。
+
+### 照合する条件
+
+- test が、キャプチャか期待を 1 つでも記録したときだけ照合します。
+- NG の検査があれば、test を失敗にします。
+- ピンがキャプチャにない検査は未検査で、失敗にはしません。
+- test の本体がすでに失敗していた場合も、記録と照合は行います。ただし、test 自身の失敗の内容はそのまま残します。
+
+### 設定
+
+| オプション | ini | 既定 | 意味 |
+| --- | --- | --- | --- |
+| `--wireskein-verify=fail\|report\|off` | `wireskein_verify` | `fail` | `fail`: 照合して、NG なら失敗。`report`: 照合して報告だけ残す（失敗にしない）。`off`: 記録だけ |
+
+### プローブとのつなぎ方
+
+このプラグインは、プローブもターゲットも知りません。ロジックアナライザを動かす fixture（例: ボードの家系ごとのプラグイン）が、両方入っているときに `ws_run` へつなぎます。
+
+- キャプチャを開始した直後に `t = ws_run.armed()`
+- 読み終えたら `ws_run.capture(data, rate, bits, t, start_us=..., time_base_slipped=True)`
+  - `bits` は、ビットの順に並べたターゲットのピン名です。
+  - `time_base_slipped` は、プローブが報告したときだけ渡します。
+- コンソールの送受信は `ws_run.command(text)` と `ws_run.reply(text)`
+
+## 開発
+
+```sh
+uv sync
+uv run pytest
+```
+
+## リリース
+
+[pytest-embedded-arduino-cli](https://github.com/tanakamasayuki/pytest-embedded-arduino-cli/blob/main/README.ja.md) と同じ手順です。`CHANGELOG.md` の `## Unreleased` を更新し、`Release` の workflow を版（例 `0.0.2`）を入れて実行します。PyPI への公開は Trusted Publishing で行います。
+
+## ライセンス
+
+MIT

pytest_embedded_wireskein-0.0.1/README.md

@@ -0,0 +1,92 @@
+# pytest-embedded-wireskein
+
+[日本語 README](https://github.com/Open-Embedded-Probe/pytest-embedded-wireskein/blob/main/README.ja.md)
+
+A [pytest-embedded](https://github.com/espressif/pytest-embedded) plugin that gives each test a [WireSkein](https://github.com/Open-Embedded-Probe/wireskein) recorder, `ws_run`. The test records the commands it sent, the logic-analyzer captures, and what each step should look like on the wire. When the test body ends, the plugin checks the captures against these expectations and fails the test if a check fails.
+
+Status: **beta**.
+
+## Install
+
+```sh
+pip install pytest-embedded-wireskein
+```
+
+Python 3.13 or newer. This installs `wireskein` and `pytest-embedded`.
+
+## Use
+
+```python
+from wireskein.runlog import square, level, only_moving
+
+def test_pwm(dut, ws_run, probe):              # `probe` is whatever drives your logic analyzer
+    with ws_run.section(1, "pwm"):
+        for duty in (64, 128, 0):
+            want = [square("PA1", 1000, duty / 255), only_moving(["PA1"])] if duty else [level("PA1", 0)]
+            with ws_run.section(2, f"duty={duty}", expect=want):
+                ws_run.command(f"PWM {duty}")
+                dut.write(f"PWM {duty}")
+                ws_run.reply(dut.expect(r"PWM duty=\d+").group(0).decode())
+                t = ws_run.armed()               # right after arming the capture
+                data, rate = probe.capture()     # bytes, one sample per byte, bit k = pin k
+                ws_run.capture(data, rate, ["PA1", "PA0"], t)
+```
+
+When `test_pwm` returns, the plugin closes the run and verifies it. If a check fails, the test fails in its call phase (FAILED, not ERROR):
+
+```text
+FAILED test_pwm.py::test_pwm - wireskein: 1 NG (5 ok, 1 ng, 0 unchecked (4 segments, 3 captures))
+NG  pwm/duty=128  square  c0002.bin  duty 0.6999 vs 0.5020
+report: /tmp/pytest-embedded/2026-09-29_12-00-00-000000/test_pwm/wireskein/report.json
+```
+
+The checks (`square`, `level`, `starts`, `ends`, `only_moving`, `pulses`, `i2c`, `spi`, `uart`) and the heading rules are described in the [WireSkein README](https://github.com/Open-Embedded-Probe/wireskein#checking-a-test-run).
+
+### Where the run is written
+
+`ws_run` writes to `<test_case_tempdir>/wireskein/`, next to pytest-embedded's `dut.log`: `<root-logdir>/pytest-embedded/<time>/<test name>/wireskein/`.
+
+| File | Content |
+| --- | --- |
+| `run.json` | Headings, commands, replies, notes, captures and expectations (WireSkein run format) |
+| `c0001.bin`, ... | The captures |
+| `report.json` | Every result with measured values, and the log |
+| `report.xml` | The results as JUnit XML |
+
+The same directory can be checked again later with `wireskein verify <dir>`. The test's `user_properties` carry `wireskein_report` (the path of `report.json`), and the result lines are added to the test report as a `wireskein` section (shown with `-rA` or on failure).
+
+### When the plugin verifies
+
+- The run is verified after the test body, only if the test recorded a capture or an expectation.
+- A check that fails makes the test fail.
+- A check whose pins were not captured is unchecked and does not fail the test.
+- If the test body already failed, the run is still recorded and verified, but the test's own failure is kept.
+
+### Options
+
+| Option | ini | Default | Meaning |
+| --- | --- | --- | --- |
+| `--wireskein-verify=fail\|report\|off` | `wireskein_verify` | `fail` | `fail`: verify and fail on NG. `report`: verify and write the reports, never fail. `off`: record only |
+
+### Connecting a probe
+
+This plugin knows nothing about probes or targets. A fixture that drives the logic analyzer (for example the one of a board-family plugin) connects to `ws_run` when both are installed:
+
+- right after arming a capture: `t = ws_run.armed()`
+- when the samples are read: `ws_run.capture(data, rate, bits, t, start_us=..., time_base_slipped=True)`. `bits` lists the target's pin names in bit order. Pass `time_base_slipped` only when the probe reports it.
+- the console traffic: `ws_run.command(text)`, `ws_run.reply(text)`
+
+## Development
+
+```sh
+uv sync
+uv run pytest
+```
+
+## Release
+
+The release works the same way as in [pytest-embedded-arduino-cli](https://github.com/tanakamasayuki/pytest-embedded-arduino-cli#release). Update `## Unreleased` in `CHANGELOG.md`, then run the `Release` workflow with the version (for example `0.0.2`). PyPI publishing uses Trusted Publishing.
+
+## License
+
+MIT

pytest_embedded_wireskein-0.0.1/pyproject.toml

@@ -0,0 +1,48 @@
+[build-system]
+requires = ["hatchling>=1.27"]
+build-backend = "hatchling.build"
+
+[project]
+name = "pytest-embedded-wireskein"
+version = "0.0.1"
+description = "pytest-embedded plugin: record logic-analyzer captures per test with WireSkein and fail the test when a waveform check fails"
+readme = "README.md"
+license = "MIT"
+requires-python = ">=3.13"
+authors = [
+  { name = "TANAKA Masayuki" },
+]
+classifiers = [
+  "Development Status :: 4 - Beta",
+  "Framework :: Pytest",
+  "Programming Language :: Python :: 3",
+  "Topic :: Software Development :: Testing",
+]
+dependencies = [
+  "pytest>=8",
+  "pytest-embedded>=2.0",
+  "wireskein>=0.0.1",
+]
+
+[project.entry-points.pytest11]
+embedded-wireskein = "pytest_embedded_wireskein.plugin"
+
+[project.urls]
+Homepage = "https://github.com/Open-Embedded-Probe/pytest-embedded-wireskein"
+Repository = "https://github.com/Open-Embedded-Probe/pytest-embedded-wireskein"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/pytest_embedded_wireskein"]
+
+[tool.hatch.build.targets.sdist]
+only-include = ["src/pytest_embedded_wireskein", "tests", "README.md", "README.ja.md", "CHANGELOG.md", "LICENSE", "pyproject.toml"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+addopts = "-p pytester"
+filterwarnings = [
+    "ignore:record_xml_attribute is an experimental feature:pytest.PytestExperimentalApiWarning",
+]
+
+[dependency-groups]
+dev = ["pytest>=8"]

pytest_embedded_wireskein-0.0.1/src/pytest_embedded_wireskein/__init__.py

@@ -0,0 +1,5 @@
+"""pytest-embedded plugin that records WireSkein runs per test and verifies them."""
+
+__all__ = ["__version__"]
+
+__version__ = "0.0.1"

pytest_embedded_wireskein-0.0.1/src/pytest_embedded_wireskein/plugin.py

@@ -0,0 +1,91 @@
+"""`ws_run`: a WireSkein recorder per test, verified when the test body ends.
+
+The run is written next to pytest-embedded's dut.log, in
+<test_case_tempdir>/wireskein/ (run.json, the captures, report.json,
+report.xml). A failing check fails the test in its call phase, so pytest
+reports FAILED, not ERROR. The plugin knows nothing about the probe or the
+target: whatever fixture drives the probe feeds `ws_run` (armed / capture /
+command / reply).
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+import pytest
+from wireskein import verify as ws_verify
+from wireskein.runlog import Recorder
+
+MODES = ("fail", "report", "off")
+DIR_NAME = "wireskein"
+
+_recorder_key = pytest.StashKey[Recorder]()
+_done_key = pytest.StashKey[bool]()
+
+
+def pytest_addoption(parser: pytest.Parser) -> None:
+    group = parser.getgroup("embedded-wireskein")
+    group.addoption(
+        "--wireskein-verify",
+        choices=MODES,
+        default=None,
+        help="after each test using ws_run: fail = verify and fail the test on NG (default), "
+             "report = verify and keep the reports only, off = record only",
+    )
+    parser.addini("wireskein_verify", help="fail | report | off (see --wireskein-verify)", default="fail")
+
+
+def pytest_configure(config: pytest.Config) -> None:
+    _mode(config)       # a wrong value is a usage error before any test runs
+
+
+def _mode(config: pytest.Config) -> str:
+    mode = config.getoption("wireskein_verify") or config.getini("wireskein_verify")
+    if mode not in MODES:
+        raise pytest.UsageError(f"wireskein_verify must be one of {', '.join(MODES)}, not {mode!r}")
+    return mode
+
+
+@pytest.fixture
+def ws_run(request: pytest.FixtureRequest, test_case_tempdir: str) -> Recorder:
+    """A wireskein.runlog.Recorder for this test, recording into
+    <test_case_tempdir>/wireskein/. Headings (`section`), commands, replies,
+    captures and expectations go through it; the plugin verifies the run when
+    the test body ends."""
+    rec = Recorder(Path(test_case_tempdir) / DIR_NAME, test=request.node.nodeid)
+    request.node.stash[_recorder_key] = rec
+    yield rec
+    # the call phase did not run (a setup error): still leave the record
+    _finish(request.node, verdict=False)
+
+
+@pytest.hookimpl(wrapper=True)
+def pytest_runtest_call(item: pytest.Item):
+    try:
+        result = yield
+    except BaseException:
+        _finish(item, verdict=False)    # the test failed on its own: record, do not override
+        raise
+    _finish(item, verdict=True)
+    return result
+
+
+def _finish(item: pytest.Item, verdict: bool) -> None:
+    rec = item.stash.get(_recorder_key, None)
+    if rec is None or item.stash.get(_done_key, False):
+        return
+    item.stash[_done_key] = True
+    path = rec.close()
+    mode = _mode(item.config)
+    if mode == "off" or not (rec.doc["expect"] or rec.doc["captures"]):
+        return
+    report = ws_verify.verify(path.parent)
+    (path.parent / "report.json").write_text(ws_verify.dumps(report))
+    (path.parent / "report.xml").write_text(ws_verify.junit(report))
+    item.user_properties.append(("wireskein_report", str(path.parent / "report.json")))
+    text = "\n".join([ws_verify.summary_line(report), *ws_verify.lines(report), f"report: {path.parent / 'report.json'}"])
+    item.add_report_section("call", "wireskein", text)
+    if verdict and mode == "fail" and report["summary"]["ng"]:
+        ng = [line for line in ws_verify.lines(report) if line.startswith("NG")]
+        pytest.fail(f"wireskein: {report['summary']['ng']} NG ({ws_verify.summary_line(report)})\n"
+                    + "\n".join(ng) + f"\nreport: {path.parent / 'report.json'}", pytrace=False)

pytest_embedded_wireskein-0.0.1/tests/test_plugin.py

@@ -0,0 +1,86 @@
+import json
+from pathlib import Path
+
+import pytest
+
+# A test file using ws_run with a synthetic capture: P0 low for 1000 samples.
+TEST_FILE = '''
+from wireskein.runlog import level
+
+def test_{name}(ws_run):
+    with ws_run.section(1, "t", expect=[level("P0", {want})]):
+        ws_run.command("PING")
+        ws_run.reply("PONG")
+        t = ws_run.armed()
+        ws_run.capture(bytes(1000), 1e6, ["P0"], t)
+'''
+
+
+def run(pytester: pytest.Pytester, *args, name="x", want=0, body=None):
+    pytester.makepyfile(body or TEST_FILE.format(name=name, want=want))
+    logdir = pytester.path / "logs"
+    return pytester.runpytest("--root-logdir", str(logdir), *args), logdir
+
+
+def run_dir(logdir: Path, name: str) -> Path:
+    (d,) = logdir.glob(f"pytest-embedded/*/test_{name}/wireskein")
+    return d
+
+
+def test_ok_run_is_recorded_next_to_the_dut_log(pytester):
+    result, logdir = run(pytester)
+    result.assert_outcomes(passed=1)
+    d = run_dir(logdir, "x")
+    assert {p.name for p in d.iterdir()} == {"run.json", "c0001.bin", "report.json", "report.xml"}
+    doc = json.loads((d / "run.json").read_text())
+    assert doc["meta"]["test"].endswith("::test_x")
+    assert [e["src"] for e in doc["log"]] == ["marker", "host", "dut", "marker"]
+    assert json.loads((d / "report.json").read_text())["summary"]["ok"] == 1
+
+
+def test_ng_fails_the_call_phase(pytester):
+    result, logdir = run(pytester, want=1)
+    result.assert_outcomes(failed=1)                     # FAILED, not ERROR
+    result.stdout.fnmatch_lines(["*wireskein: 1 NG*", "*NG  t  level  c0001.bin  not constant 1*", "*report: *report.json*"])
+
+
+def test_report_mode_keeps_the_reports_without_failing(pytester):
+    result, logdir = run(pytester, "--wireskein-verify=report", want=1)
+    result.assert_outcomes(passed=1)
+    assert json.loads((run_dir(logdir, "x") / "report.json").read_text())["summary"]["ng"] == 1
+
+
+def test_off_mode_only_records(pytester):
+    pytester.makeini("[pytest]\nwireskein_verify = off\n")
+    result, logdir = run(pytester, want=1)
+    result.assert_outcomes(passed=1)
+    assert {p.name for p in run_dir(logdir, "x").iterdir()} == {"run.json", "c0001.bin"}
+
+
+def test_a_failing_test_body_is_not_overridden(pytester):
+    body = TEST_FILE.format(name="x", want=1) + "        assert False, 'the body failed'\n"
+    result, logdir = run(pytester, body=body)
+    result.assert_outcomes(failed=1)
+    result.stdout.fnmatch_lines(["*the body failed*"])
+    result.stdout.no_fnmatch_line("*wireskein: 1 NG*")
+    assert (run_dir(logdir, "x") / "report.json").exists()   # still verified and recorded
+
+
+def test_unchecked_does_not_fail(pytester):
+    body = TEST_FILE.format(name="x", want=0).replace('level("P0", 0)', 'level("NOT_CAPTURED", 0)')
+    result, _ = run(pytester, body=body)
+    result.assert_outcomes(passed=1)
+
+
+def test_unused_recorder_writes_no_report(pytester):
+    body = "def test_x(ws_run):\n    pass\n"
+    result, logdir = run(pytester, body=body)
+    result.assert_outcomes(passed=1)
+    assert {p.name for p in run_dir(logdir, "x").iterdir()} == {"run.json"}
+
+
+def test_bad_mode_is_a_usage_error(pytester):
+    pytester.makeini("[pytest]\nwireskein_verify = maybe\n")
+    result, _ = run(pytester)
+    assert result.ret != 0
+    result.stderr.fnmatch_lines(["*wireskein_verify must be one of fail, report, off*"])