bobframes 0.1.0__py3-none-any.whl

bobframes/tests/test_discovery.py

@@ -0,0 +1,97 @@
+"""Unit tests for discovery (c15, doc's `unit_discovery.py`).
+
+Covers the area/dated-drop walking that drives ingest + smoke: latest-drop selection, the
+area/label/capture filters, the capture sort order, skip rules, and parse_single_drop_arg
+(the correct name — not the doc's earlier `_parse_drop_dirname`).
+
+Named `test_*` for default pytest discovery (no `python_files` override).
+"""
+from __future__ import annotations
+
+import os
+
+import pytest
+
+from .. import discovery
+from ..discovery import Drop
+
+
+def _touch(path: str) -> None:
+    os.makedirs(os.path.dirname(path), exist_ok=True)
+    open(path, 'w', encoding='utf-8').close()
+
+
+def _make_root(tmp_path) -> str:
+    root = str(tmp_path / 'proj')
+    # Town: two dated drops; the newer one has three captures with non-lexical numeric names.
+    _touch(os.path.join(root, 'Town', '2026-05-27_old', '1.rdc'))
+    for cap in ('1', '2', '10'):
+        _touch(os.path.join(root, 'Town', '2026-05-28_new', f'{cap}.rdc'))
+    # Bay: a single undated-label drop (label absent).
+    _touch(os.path.join(root, 'Bay', '2026-01-01', 'cap.rdc'))
+    # Noise that must be ignored: underscore (output) dir is not an area.
+    _touch(os.path.join(root, '_data', 'District 01', '2026-05-28_new', 'x.parquet'))
+    return root
+
+
+def test_find_drops_picks_latest_per_area(tmp_path):
+    drops = {d.area: d for d in discovery.find_drops(_make_root(tmp_path))}
+    assert set(drops) == {'Town', 'Bay'}                  # '_data' skipped
+    assert drops['Town'].drop_date == '2026-05-28'        # newest dated drop
+    assert drops['Town'].drop_label == 'new'
+    assert drops['Bay'].drop_label == ''                  # label optional
+
+
+def test_latest_empty_drop_skips_area_no_fallback(tmp_path):
+    # The newest dated dir has no .rdc; find_drops skips the whole area rather than falling
+    # back to the older drop that does have captures.
+    root = str(tmp_path / 'proj')
+    _touch(os.path.join(root, 'Town', '2026-05-27_old', '1.rdc'))
+    os.makedirs(os.path.join(root, 'Town', '2026-05-28_new'), exist_ok=True)
+    assert discovery.find_drops(root) == []
+
+
+def test_capture_sort_is_length_then_lexical(tmp_path):
+    town = next(d for d in discovery.find_drops(_make_root(tmp_path)) if d.area == 'Town')
+    assert town.captures == ('1', '2', '10')              # NOT lexical ('1','10','2')
+
+
+def test_filters(tmp_path):
+    root = _make_root(tmp_path)
+    assert [d.area for d in discovery.find_drops(root, area_filter='Bay')] == ['Bay']
+    assert discovery.find_drops(root, label_filter='nope') == []
+    capped = discovery.find_drops(root, area_filter='Town', capture_filter='2')
+    assert capped[0].captures == ('2',)
+    # A capture filter that doesn't match the area's drop drops it entirely.
+    assert discovery.find_drops(root, area_filter='Town', capture_filter='999') == []
+
+
+def test_drop_without_rdc_is_skipped(tmp_path):
+    root = str(tmp_path / 'proj')
+    os.makedirs(os.path.join(root, 'Area', '2026-05-28_x'), exist_ok=True)
+    assert discovery.find_drops(root) == []
+
+
+def test_find_drops_missing_root_raises(tmp_path):
+    with pytest.raises(FileNotFoundError):
+        discovery.find_drops(str(tmp_path / 'nope'))
+
+
+def test_parse_single_drop_arg_ok(tmp_path):
+    root = _make_root(tmp_path)
+    d = discovery.parse_single_drop_arg('Town/2026-05-28_new', root)
+    assert isinstance(d, Drop)
+    assert (d.area, d.drop_date, d.drop_label) == ('Town', '2026-05-28', 'new')
+    assert d.captures == ('1', '2', '10')
+    # Trailing separators + backslashes normalize identically.
+    assert discovery.parse_single_drop_arg('Town\\2026-05-28_new\\', root).drop_dir == d.drop_dir
+
+
+def test_parse_single_drop_arg_errors(tmp_path):
+    root = _make_root(tmp_path)
+    with pytest.raises(ValueError):
+        discovery.parse_single_drop_arg('justone', root)            # no <area>/<drop>
+    with pytest.raises(ValueError):
+        discovery.parse_single_drop_arg('Town/not-a-date', root)    # not a dated folder
+    with pytest.raises(FileNotFoundError):
+        discovery.parse_single_drop_arg('Town/2026-05-30_ghost', root)  # dir absent

bobframes/tests/test_hardening.py

@@ -0,0 +1,142 @@
+"""c03 reliability hardening — mocked-subprocess unit tests (DECISIONS ADR-6).
+
+CI has no GPU/RenderDoc, so the ingest-path hardening branches (process-tree kill on timeout,
+replay-failure skip, atomic writes, stderr surfacing, key versioning) get no coverage from the
+golden-parity gate. These drive each branch with fakes instead of real subprocesses.
+
+Named `test_hardening.py` (not the c03 doc's `unit_hardening.py`) so the default-config
+`pytest bobframes/tests` collects it — the repo defines no pytest `python_files` override.
+"""
+from __future__ import annotations
+
+import hashlib
+import os
+import subprocess
+
+import pyarrow as pa
+import pytest
+
+from .. import manifest, parquetize, qrd_harness, rdcmd, run, stable_keys
+from ..discovery import Drop
+
+
+# --- R-4: replay timeout reaps the process tree ------------------------------
+
+def test_qrd_timeout_kills_process_tree(monkeypatch):
+    class _FakeTimeoutPopen:
+        def __init__(self, *a, **k):
+            self.pid = 4242
+            self.returncode = None
+
+        def communicate(self, timeout=None):
+            raise subprocess.TimeoutExpired(cmd='qrenderdoc', timeout=timeout)
+
+        def wait(self, timeout=None):
+            self.returncode = -1
+            return -1
+
+    killed: list[list[str]] = []
+
+    def _rec_run(cmd, *a, **k):
+        killed.append(cmd)
+        return type('R', (), {'returncode': 0})()
+
+    monkeypatch.setattr(qrd_harness, 'find_qrenderdoc', lambda: 'qrenderdoc.exe')
+    monkeypatch.setattr(qrd_harness.subprocess, 'Popen', _FakeTimeoutPopen)
+    monkeypatch.setattr(qrd_harness.subprocess, 'run', _rec_run)
+
+    rc, elapsed = qrd_harness.run('replay_main.py', payload_args=['a', 'b'],
+                                  log_path=None, timeout_s=1)
+
+    assert rc == -1
+    assert ['taskkill', '/T', '/F', '/PID', '4242'] in killed
+
+
+# --- R-6: one capture's replay failure is skipped, not fatal ------------------
+
+def test_replay_failure_skips_and_records_status(monkeypatch, tmp_path):
+    def _fake_run(script, payload_args, log_path=None, timeout_s=600.0):
+        capture = payload_args[1]
+        return (1, 0.1) if capture == '2' else (0, 0.1)
+
+    monkeypatch.setattr(run.qrd_harness, 'run', _fake_run)
+
+    drop = Drop(area='A', drop_date='2026-01-01', drop_label='x',
+                drop_dir=str(tmp_path / 'drop'), captures=('1', '2'))
+    stage_root = str(tmp_path / 'stage')
+
+    statuses = run._do_replay(drop, stage_root, pixel_grid=4)
+
+    assert statuses == {'1': 'ok', '2': 'replay_failed'}
+
+
+# --- R-1: manifest write is atomic (no partial file on mid-write crash) -------
+
+def test_write_manifest_atomic_no_partial(monkeypatch, tmp_path):
+    def _boom(*a, **k):
+        raise RuntimeError('disk full mid-write')
+
+    monkeypatch.setattr(manifest.json, 'dump', _boom)
+
+    with pytest.raises(RuntimeError):
+        manifest.write_manifest(str(tmp_path), {'schema_version': 3})
+
+    assert not os.path.exists(tmp_path / '_manifest.json')
+    assert not os.path.exists(tmp_path / '_manifest.json.tmp')
+
+
+# --- R-2: Parquet+CSV pair rolls back both tmps if either write fails ---------
+
+def test_write_pair_rolls_back_on_csv_failure(monkeypatch, tmp_path):
+    def _boom(*a, **k):
+        raise RuntimeError('csv writer exploded')
+
+    monkeypatch.setattr(parquetize.pacsv, 'write_csv', _boom)
+
+    tbl = pa.table({'x': [1, 2, 3]})
+    with pytest.raises(RuntimeError):
+        parquetize._write_pair(tbl, str(tmp_path), 'foo')
+
+    for leftover in ('foo.parquet', 'foo.csv', 'foo.parquet.tmp', 'foo.csv.tmp'):
+        assert not os.path.exists(tmp_path / leftover), f'left behind: {leftover}'
+
+
+# --- R-8: convert timeout surfaces stderr before re-raising -------------------
+
+def test_convert_timeout_logs_stderr(monkeypatch, capsys):
+    def _raise_timeout(*a, **k):
+        raise subprocess.TimeoutExpired(cmd=['renderdoccmd'], timeout=1,
+                                        output='', stderr='boom-stderr-tail')
+
+    monkeypatch.setattr(rdcmd, 'find_renderdoccmd', lambda: 'renderdoccmd.exe')
+    monkeypatch.setattr(rdcmd.subprocess, 'run', _raise_timeout)
+
+    with pytest.raises(subprocess.TimeoutExpired):
+        rdcmd.convert('a.rdc', 'b.xml', fmt='xml', timeout_s=1)
+
+    assert 'boom-stderr-tail' in capsys.readouterr().err
+
+
+# --- R-7: parse surfaces stderr even when the return code is 0 ----------------
+
+def test_parse_one_returns_stderr_on_success(monkeypatch):
+    def _fake_run(cmd, *a, **k):
+        return type('P', (), {'returncode': 0, 'stdout': 'okout\n', 'stderr': 'warnmsg\n'})()
+
+    monkeypatch.setattr(run.subprocess, 'run', _fake_run)
+
+    capture, elapsed, status, stderr = run._parse_one(
+        ('x.zip.xml', 'root/_data/_stage/cap', 'A', '2026-01-01', 'x', 'cap'))
+
+    assert status == 'okout'
+    assert stderr == 'warnmsg'
+
+
+# --- H-27 / G-11: stable keys carry a version byte ---------------------------
+
+def test_stable_key_version_prefix():
+    assert stable_keys.KEY_VERSION == 1
+    bare = hashlib.sha256(b'x').hexdigest()
+    versioned = hashlib.sha256(bytes([1]) + b'x').hexdigest()
+    assert stable_keys.shader_key('x') != bare
+    assert stable_keys.shader_key('x') == versioned

bobframes/tests/test_parity.py

@@ -0,0 +1,22 @@
+"""Golden-snapshot parity: rendering the synthetic fixture reproduces the frozen golden HTML
+(byte-identical after masking the build timestamp). The backbone gate for every refactor."""
+from __future__ import annotations
+
+import os
+
+from . import _render_util as u
+
+
+def test_render_matches_golden(tmp_path):
+    dest = u.render_fresh(str(tmp_path / "root"))
+
+    actual_files = u.rendered_html_files(dest)
+    golden_files = u.rendered_html_files(u.GOLDEN_DIR)
+    assert actual_files == golden_files, (
+        f"rendered page set changed vs golden: {set(actual_files) ^ set(golden_files)}"
+    )
+
+    for rel in golden_files:
+        golden = u.normalize(open(os.path.join(u.GOLDEN_DIR, rel), encoding="utf-8").read())
+        actual = u.normalize(open(os.path.join(dest, rel), encoding="utf-8").read())
+        assert actual == golden, f"output diverged from golden: {rel}"

bobframes/tests/test_perf.py

@@ -0,0 +1,18 @@
+"""Perf guard: a full render-only of the synthetic fixture stays well under budget. Catches gross
+regressions, not micro-changes. The budget is generous (subprocess incl. interpreter + pyarrow
+import + render of ~60-row tables); tighten if it ever proves too loose."""
+from __future__ import annotations
+
+import time
+
+from . import _render_util as u
+
+PERF_BUDGET_S = 15.0
+
+
+def test_render_perf(tmp_path):
+    root = u.setup_root(str(tmp_path / "root"))
+    t0 = time.monotonic()
+    u.render(root)
+    dt = time.monotonic() - t0
+    assert dt < PERF_BUDGET_S, f"render took {dt:.2f}s (budget {PERF_BUDGET_S}s)"

bobframes/tests/test_replay_drift.py

@@ -0,0 +1,115 @@
+"""c13 — replay-schema drift guardrail (H-6, supports D-2).
+
+``replay/replay_main.py`` runs inside qrenderdoc's embedded Python and cannot reliably import the
+host ``bobframes`` package, so it duplicates the schema column tuples from ``schemas.py``. Nothing
+else fails the build when a ``schemas.py`` edit isn't mirrored into that copy, so this test diffs the
+two literals and fails on drift — the duplication is safe to keep precisely because of this guard.
+
+Per DECISIONS ADR-5 + ADR-9: match the ``*_COLS`` *suffix* (the original ``_COLS_`` *prefix* matched
+zero and passed vacuously), map abbreviated vars to schema stems via an explicit alias, skip the
+shared ``ID_COLS`` base, and assert a minimum table count so a future rename can't silently
+re-disable the guard.
+
+ADR-9 correction (verified empirically): replay defines 20 ``*_COLS`` tables (not 21), and three of
+them — ``events`` / ``draws`` / ``passes`` — legitimately omit four columns that
+``derive_post_merge.py`` computes host-side *after* replay. So the guard compares each replay tuple
+against its schema tuple **minus a pinned set of host-derived columns**: that still catches any
+raw-column add/remove/reorder and any new *unpinned* schema-only column, while staying green today.
+
+Named ``test_replay_drift.py`` (not the c13 doc's ``replay_drift.py``) so default pytest collects it —
+the repo defines no ``python_files`` override. Same reason as c03's ``test_hardening.py``.
+"""
+from __future__ import annotations
+
+import ast
+from pathlib import Path
+
+import bobframes
+
+from .. import schemas
+
+_REPLAY_MAIN = Path(bobframes.__file__).resolve().parent / "replay" / "replay_main.py"
+
+# var (sans _COLS) -> schemas stem; identity-lowercase unless listed.
+_REPLAY_STEM = {
+    "RT": "render_targets",
+    "RT_TIMELINE": "rt_event_timeline",
+    "STATE_CHANGE": "state_change_events",
+    "COUNTERS": "counters_per_event",
+}
+
+# Columns schemas.py carries that the replay stage legitimately does NOT emit: they are derived
+# host-side in derive_post_merge.py (see its module docstring) after the raw CSVs land. Keyed by
+# schema stem. Anything schema-only and NOT listed here is treated as drift.
+_DERIVED_COLS = {
+    "events": ("parent_marker_path_norm",),
+    "draws": ("parent_pass_path_norm", "draw_class"),
+    "passes": ("marker_path_norm",),
+}
+
+_EXPECTED_REPLAY_TABLES = 20  # ADR-9: empirically 20 (ADR-5 estimated 21).
+
+
+def _resolve_tuple(node: ast.AST, names: dict[str, tuple]) -> tuple:
+    """Resolve a column-tuple expression: a literal tuple, a bare Name referring to an already-seen
+    tuple (e.g. ``ID_COLS``), or any chain of ``+`` concatenations of those."""
+    if isinstance(node, ast.BinOp) and isinstance(node.op, ast.Add):
+        return _resolve_tuple(node.left, names) + _resolve_tuple(node.right, names)
+    if isinstance(node, ast.Name):
+        return names[node.id]
+    if isinstance(node, ast.Tuple):
+        return tuple(elt.value for elt in node.elts)
+    raise AssertionError(f"unexpected node in column tuple: {ast.dump(node)}")
+
+
+def _extract_col_tuples(tree: ast.Module, suffix: str, skip: set[str]) -> dict[str, tuple]:
+    """Parse top-level ``<NAME>_COLS = (...)`` assignments into full literal tuples.
+
+    Tracks every resolved ``*_COLS`` name (incl. the skipped base) so later concatenations like
+    ``ID_COLS + (...)`` resolve, but returns only names that end with ``suffix`` and aren't in
+    ``skip``.
+    """
+    names: dict[str, tuple] = {}
+    result: dict[str, tuple] = {}
+    for node in tree.body:
+        if not (isinstance(node, ast.Assign) and len(node.targets) == 1
+                and isinstance(node.targets[0], ast.Name)):
+            continue
+        var = node.targets[0].id
+        if not var.endswith(suffix):
+            continue
+        names[var] = _resolve_tuple(node.value, names)
+        if var not in skip:
+            result[var] = names[var]
+    return result
+
+
+def test_replay_main_schema_in_sync():
+    tree = ast.parse(_REPLAY_MAIN.read_text(encoding="utf-8"))
+    replay_tables = _extract_col_tuples(tree, suffix="_COLS", skip={"ID_COLS"})
+
+    assert len(replay_tables) >= _EXPECTED_REPLAY_TABLES, (
+        f"guard must not match near-zero: found {len(replay_tables)} replay *_COLS tables, "
+        f"expected >= {_EXPECTED_REPLAY_TABLES} (a rename may have silently disabled the guard)"
+    )
+
+    for var, cols in replay_tables.items():
+        base = var[: -len("_COLS")]
+        stem = _REPLAY_STEM.get(base, base.lower())
+        try:
+            expected = schemas.expected_columns(stem)
+        except KeyError:
+            raise AssertionError(f"{var}: no schema stem {stem!r} in schemas.TABLES")
+
+        derived = _DERIVED_COLS.get(stem, ())
+        # Pinned derived columns must really be in the schema, or the allowlist is masking a typo /
+        # a genuine raw column.
+        for d in derived:
+            assert d in expected, f"_DERIVED_COLS[{stem!r}] lists {d!r}, absent from schemas.{stem}"
+
+        expected_raw = tuple(c for c in expected if c not in derived)
+        assert cols == expected_raw, (
+            f"{var} drifted from schemas.{stem}: "
+            f"replay_only={[c for c in cols if c not in expected_raw]} "
+            f"schema_only={[c for c in expected_raw if c not in cols]}"
+        )

bobframes/tests/test_schemas.py

@@ -0,0 +1,26 @@
+"""Schema regression: every synthetic Parquet's column list matches schemas.expected_columns(stem)
+exactly (catches alphabetization drift, dropped columns, dtype-name slips)."""
+from __future__ import annotations
+
+import os
+
+import pyarrow.parquet as pq
+
+from .. import schemas
+from . import _render_util as u
+
+
+def test_synthetic_parquet_schemas():
+    checked = 0
+    for dirpath, _dirs, files in os.walk(u.SYNTHETIC_DATA):
+        for fn in files:
+            if not fn.endswith(".parquet"):
+                continue
+            stem = fn[: -len(".parquet")]
+            if stem.startswith("_"):  # _catalog, _global_entities — not per-table
+                continue
+            expected = schemas.expected_columns(stem)
+            actual = tuple(pq.read_schema(os.path.join(dirpath, fn)).names)
+            assert actual == expected, f"{fn}: symmetric diff {set(actual) ^ set(expected)}"
+            checked += 1
+    assert checked >= 27, f"expected to check >= 27 tables, checked {checked}"

bobframes/tests/test_schemas_unit.py

@@ -0,0 +1,55 @@
+"""Unit tests for the schemas module helpers (c15, doc's `unit_schemas.py`).
+
+Distinct from test_schemas.py (the parity-tier check that emitted Parquet matches the schema): this
+pins the pure-Python contracts of schemas.py itself — expected_columns round-trips, the ID_COLS
+prefix invariant, dtype inference totality, and no duplicate columns.
+
+Named `test_schemas_unit` (not the c15 doc's `unit_schemas.py`) to avoid colliding with the existing
+test_schemas.py and to satisfy default pytest discovery (no `python_files` override).
+"""
+from __future__ import annotations
+
+import pytest
+
+from .. import schemas
+
+
+def test_schema_version_is_int():
+    assert isinstance(schemas.SCHEMA_VERSION, int)
+
+
+def test_expected_columns_roundtrips_every_stem():
+    for stem, (cols, size, entity) in schemas.TABLES.items():
+        assert schemas.expected_columns(stem) == cols
+        assert schemas.is_entity_table(stem) is entity
+        assert schemas.size_class(stem) == size
+        assert size in ('large', 'small')
+
+
+def test_every_table_starts_with_id_cols():
+    for stem, cols in ((s, schemas.expected_columns(s)) for s in schemas.TABLES):
+        assert cols[:len(schemas.ID_COLS)] == schemas.ID_COLS, stem
+
+
+def test_no_duplicate_columns_within_a_table():
+    for stem in schemas.TABLES:
+        cols = schemas.expected_columns(stem)
+        assert len(cols) == len(set(cols)), f'{stem} has duplicate columns'
+
+
+def test_expected_columns_unknown_stem_raises():
+    with pytest.raises(KeyError):
+        schemas.expected_columns('does_not_exist')
+
+
+def test_infer_dtype_total_and_spot_checks():
+    # Every column across every table infers one of the four supported dtypes.
+    for stem in schemas.TABLES:
+        for col in schemas.expected_columns(stem):
+            assert schemas.infer_dtype(col) in ('int', 'float', 'bool', 'str'), (stem, col)
+    # Spot-checks across the inference buckets.
+    assert schemas.infer_dtype('event_id') == 'int'
+    assert schemas.infer_dtype('gpu_duration_s') == 'float'
+    assert schemas.infer_dtype('is_rt') == 'bool'
+    assert schemas.infer_dtype('format') == 'str'
+    assert schemas.infer_dtype('totally_unknown_column') == 'str'  # default

bobframes/tests/test_stable_keys.py

@@ -0,0 +1,61 @@
+"""Unit tests for stable_keys (c15, doc's `unit_keys.py`).
+
+Pins the load-bearing key contracts: version prefix, GLSL normalization, determinism, the
+empty-string contract for unknown inputs, and order-invariance of the composite keys. The exact
+SHA256 version-prefix byte is already asserted in test_hardening.py — here we cover the surrounding
+behavior so a key-derivation rule change can't silently shift results.
+
+Named `test_*` (not the c15 doc's `unit_keys.py`) so default pytest collects it — no `python_files`
+override in pyproject.
+"""
+from __future__ import annotations
+
+from .. import stable_keys as sk
+
+
+def test_key_version_is_one():
+    assert sk.KEY_VERSION == 1
+
+
+def test_normalize_glsl_strips_and_collapses():
+    src = "void main(){\n  // line comment\n  /* block */ x=1;   \n\n\n\n  y=2;\n}\n"
+    out = sk.normalize_glsl(src)
+    assert "//" not in out and "/*" not in out
+    assert "\n\n\n" not in out          # blank-line runs collapsed to at most one blank line
+    assert not out.endswith(" ")        # trailing ws stripped
+    assert sk.normalize_glsl(out) == out  # idempotent
+    assert sk.normalize_glsl("") == ""
+
+
+def test_shader_key_determinism_and_comment_insensitivity():
+    a = sk.normalize_glsl("float f(){ return 1.0; } // v1")
+    b = sk.normalize_glsl("float f(){ return 1.0; } /* different comment */")
+    assert sk.shader_key(a) == sk.shader_key(b)          # comments don't change the key
+    assert sk.shader_key(a) == sk.shader_key(a)          # deterministic
+    assert sk.shader_key("float g(){ return 2.0; }") != sk.shader_key(a)
+    assert len(sk.shader_key(a)) == 64                   # sha256 hexdigest
+
+
+def test_empty_input_contract():
+    assert sk.shader_key("") == ""
+    assert sk.program_key([]) == ""
+    assert sk.program_key(["", ""]) == ""                # only empties -> empty
+    assert sk.fbo_key([]) == ""
+    assert sk.texture_key("lbl", None, 10, 10, 1, 1, 1) == ""   # fmt None
+    assert sk.texture_key("lbl", "RGBA8", None, 10, 1, 1, 1) == ""  # width None
+    assert sk.sampler_key(None, "LIN", "R", "R", "R", 1, "NONE", "ALW") == ""
+    assert sk.buffer_key("h", 0, "t") == ""              # size <= 0
+    assert sk.buffer_key("h", -5, "t") == ""
+
+
+def test_composite_keys_order_invariant_and_filter_empties():
+    assert sk.program_key(["a", "b"]) == sk.program_key(["b", "a"])
+    assert sk.program_key(["a", "", "b"]) == sk.program_key(["b", "a"])  # empties dropped
+    assert sk.fbo_key(["x", "y"]) == sk.fbo_key(["y", "x"])
+    assert sk.program_key(["a", "b"]) != sk.program_key(["a", "c"])
+
+
+def test_distinct_payloads_distinct_keys():
+    t1 = sk.texture_key("color", "RGBA8", 256, 256, 1, 1, 1)
+    t2 = sk.texture_key("color", "RGBA8", 512, 256, 1, 1, 1)
+    assert t1 and t2 and t1 != t2