Add synthetic base fixtures and the SONiC E2E job

[ideaship]

Part of the series tracked in #2562, which explains the ordering and what each PR covers. Based on the preceding PR in the stack, so review only the top commits here.

This is where the test first runs end to end, and the largest PR in the
series — 3528 lines, of which roughly 2700 is generated golden JSON. Four
commits: five synthetic devices and their goldens, the coverage report, a README
section, and the Zuul job.

It is deliberately not split further. The harness is not independently testable
in smaller pieces, and the Zuul job has to land together with the goldens it
compares against, or the check is red on arrival.

Two things to know before approving:

Once this job exists it gates changes under osism/tasks/conductor/,
osism/settings.py, Makefile and .zuul.yaml. That makes this the point of
no return for the series.

The synthetic-fixture half has never run in Zuul. Only the compose change
has a green CI run, on a branch that no longer exists. The check on this PR is
the first real test of the fixtures, so it is the one to watch.

coverage.py reports 30 of 38 emitted tables here, and exits non-zero saying
so. That is the honest number for the base fixtures alone; the four scenario PRs
above take it to 38.

[sourcery-ai]

Hey - I've found 1 issue

Prompt for AI Agents

Please address the comments from this code review:

## Individual Comments

### Comment 1
<location path="tests/e2e/coverage.py" line_range="61-58" />
<code_context>
+    return tables
+
+
+def covered_tables(golden_dir=GOLDEN_DIR):
+    """Tables that are non-empty in at least one golden file."""
+    import json
+
+    tables = set()
+    for path in sorted(Path(golden_dir).glob("*.json")):
+        config = json.loads(path.read_text())
+        for table, value in config.items():
+            if value:
+                tables.add(table)
+    return tables
+
+
</code_context>
<issue_to_address>
**suggestion (testing):** Add tests for `covered_tables` to ensure the "non-empty" heuristic behaves as intended for different JSON value types.

Currently `covered_tables` treats any truthy JSON value as coverage and any falsy value (e.g. `[]`, `{}`, `0`, `False`, `""`) as uncovered. Please add focused tests with small JSON examples to:
- Confirm empty lists/dicts are ignored.
- Clarify how numeric/boolean values are handled (and whether they’re supported or rejected).
- Define behavior for non-dict top-level JSON (e.g. fail clearly or be explicitly unsupported).
These tests will pin down the intended semantics and guard against future changes in the golden format or producer.

Suggested implementation:

```python
def covered_tables(golden_dir=GOLDEN_DIR):
    """Tables that are non-empty in at least one golden file.

    A table is considered covered if its value in at least one golden JSON file
    is truthy. Falsy values (e.g. [], {}, 0, False, "") are treated as uncovered.
    The golden file must contain a JSON object mapping table names to coverage
    descriptors; non-object top-level JSON is rejected.
    """
    import json

    tables = set()
    for path in sorted(Path(golden_dir).glob("*.json")):
        config = json.loads(path.read_text())
        if not isinstance(config, dict):
            raise TypeError(
                f"{path} must contain a JSON object mapping table names to values, "
                f"got {type(config).__name__}"
            )
        for table, value in config.items():
            if value:
                tables.add(table)
    return tables

```

```python
It works in two independent steps:


def test_covered_tables_ignores_empty_containers(tmp_path):
    """Empty lists/dicts should be ignored, non-empty containers counted."""
    import json

    golden = {
        "EMPTY_LIST": [],
        "EMPTY_DICT": {},
        "NONEMPTY_LIST": ["x"],
        "NONEMPTY_DICT": {"k": "v"},
    }
    (tmp_path / "golden.json").write_text(json.dumps(golden))

    from tests.e2e.coverage import covered_tables

    result = covered_tables(golden_dir=tmp_path)
    assert result == {"NONEMPTY_LIST", "NONEMPTY_DICT"}


def test_covered_tables_numeric_and_boolean_values(tmp_path):
    """Numeric/boolean/string values are treated by truthiness."""
    import json

    golden = {
        "ZERO": 0,
        "ONE": 1,
        "FALSE_BOOL": False,
        "TRUE_BOOL": True,
        "EMPTY_STRING": "",
        "NONEMPTY_STRING": "value",
    }
    (tmp_path / "golden.json").write_text(json.dumps(golden))

    from tests.e2e.coverage import covered_tables

    result = covered_tables(golden_dir=tmp_path)
    assert result == {"ONE", "TRUE_BOOL", "NONEMPTY_STRING"}


def test_covered_tables_rejects_non_object_top_level_json(tmp_path):
    """Non-dict top-level JSON should fail clearly."""
    import json
    import pytest

    # List top-level JSON
    (tmp_path / "list.json").write_text(json.dumps(["not", "a", "dict"]))
    # Scalar top-level JSON
    (tmp_path / "scalar.json").write_text(json.dumps(42))

    from tests.e2e.coverage import covered_tables

    with pytest.raises(TypeError):
        covered_tables(golden_dir=tmp_path)

```

1. If `tests/e2e/coverage.py` is not intended to be imported as `tests.e2e.coverage` during test runs, adjust the imports in the new tests to import `covered_tables` via the actual module path used in your test runner.
2. If you already have a dedicated test module for `coverage.py` (e.g. `tests/e2e/test_coverage.py`), you may prefer to move these `test_covered_tables_*` functions into that file instead of keeping them inline; the bodies can be reused as-is.
3. Ensure `pytest` is available in your test environment, as the non-object JSON test relies on `pytest.raises`. If you use a different testing framework, replace the `pytest.raises` usage with the equivalent assertion mechanism.
</issue_to_address>

---

Sourcery is free for open source - if you like our reviews please consider sharing them ✨

• X
• Mastodon
• LinkedIn
• Facebook

_{Help me be more useful! Please click 👍 or 👎 on each comment and I'll use the feedback to improve your reviews.}

[berendt]

@ideaship Please check the Sourcery review.