oopsie-data-tools 0.2.0__py3-none-any.whl

oopsie_data_tools/test/test_annotation_schema.py

@@ -0,0 +1,190 @@
+"""The v2 annotation schema core: the outcome mapping, v1 reads, and UI/Python drift.
+
+With the questionnaire YAML gone the annotation form is hardcoded markup, so nothing in the
+build would notice if the slugs in ``annotator.html`` and the ones in ``annotation_schema``
+drifted apart. :func:`test_ui_vocabulary_matches_python` is what notices.
+"""
+
+from __future__ import annotations
+
+import json
+import re
+
+import h5py
+import pytest
+
+from oopsie_data_tools.annotation_tool import ANNOTATION_TOOL_DIR
+from oopsie_data_tools.annotation_tool.annotation_schema import (
+    OUTCOME_SUCCESS,
+    OUTCOMES,
+    SEVERITIES,
+    SIDE_EFFECT_CATEGORIES,
+    SUCCESS_THRESHOLD,
+    outcome_to_success,
+    read_annotation_attrs,
+    success_to_outcome,
+    write_annotation_attrs,
+)
+from oopsie_data_tools.utils.validation.annotation_completeness import (
+    OUTCOME_EXPECTED_FIELDS,
+)
+
+_ANNOTATOR_HTML = ANNOTATION_TOOL_DIR / "ui" / "annotator.html"
+
+
+# ── The outcome <-> success mapping ───────────────────────────────────────────
+
+
+def test_every_outcome_has_a_success_value():
+    assert set(OUTCOME_SUCCESS) == set(OUTCOMES)
+    assert all(isinstance(v, float) for v in OUTCOME_SUCCESS.values())
+
+
+def test_all_three_success_outcomes_score_as_success():
+    """Downstream consumers that only read the float must see every success as one."""
+    for outcome in ("success", "success_suboptimal", "success_side_effect"):
+        assert outcome_to_success(outcome) >= SUCCESS_THRESHOLD
+    assert outcome_to_success("failure") < SUCCESS_THRESHOLD
+
+
+def test_an_unrecognized_outcome_has_no_success_value():
+    """None, not 0.0 — guessing "failure" would silently mislabel the episode."""
+    assert outcome_to_success("sort_of_worked") is None
+    assert outcome_to_success("") is None
+    assert success_to_outcome("not a number") is None
+
+
+def test_success_to_outcome_is_coarse():
+    """The float cannot carry the qualified successes, and must not pretend otherwise."""
+    assert success_to_outcome(1.0) == "success"
+    assert success_to_outcome(0.0) == "failure"
+    assert success_to_outcome(0.9) == "success"
+
+
+def test_an_unrecognized_outcome_leaves_success_unwritten(tmp_path):
+    path = tmp_path / "ep.h5"
+    with h5py.File(path, "w") as f:
+        group = f.require_group("episode_annotations/a")
+        write_annotation_attrs(group, {"outcome": "sort_of_worked"})
+        assert "success" not in group.attrs
+
+
+# ── Reading v1 ────────────────────────────────────────────────────────────────
+
+
+def _v1_attrs(**taxonomy) -> dict:
+    success = taxonomy.pop("success", 0.0)
+    return {
+        "schema": "oopsie_failure_taxonomy_v1",
+        "success": success,
+        "failure_description": taxonomy.pop("failure_description", ""),
+        "taxonomy": json.dumps(taxonomy),
+    }
+
+
+@pytest.mark.parametrize(
+    "success,success_category,expected",
+    [
+        (1.0, None, "success"),
+        (1.0, "Clean success", "success"),
+        (1.0, "Suboptimal execution", "success_suboptimal"),
+        (1.0, "Success with side-effects", "success_side_effect"),
+        (0.0, None, "failure"),
+    ],
+)
+def test_v1_outcome_is_reconstructed(success, success_category, expected):
+    attrs = _v1_attrs(success=success)
+    if success_category:
+        attrs["taxonomy"] = json.dumps({"success_category": success_category})
+
+    assert read_annotation_attrs(attrs)["outcome"] == expected
+
+
+def test_v1_prose_values_read_back_as_slugs():
+    attrs = _v1_attrs(
+        success=0.0,
+        failure_description="dropped it",
+        failure_category=["Grasp failure (at contact)", "Collision failure"],
+        severity="Low severity - no damage, can be reset and reattempted",
+    )
+    out = read_annotation_attrs(attrs)
+
+    assert out["episode_description"] == "dropped it"
+    assert out["side_effect_category"] == ["grasp", "collision"]
+    assert out["severity"] == "low"
+
+
+def test_an_unknown_category_value_is_preserved():
+    """Stale labels stay visible to the annotator instead of being guessed at."""
+    attrs = _v1_attrs(success=0.0, failure_category=["grasp_failure"])
+
+    assert read_annotation_attrs(attrs)["side_effect_category"] == ["grasp_failure"]
+
+
+def test_absent_keys_stay_absent():
+    """Callers distinguish "not annotated" from "annotated and left empty"."""
+    out = read_annotation_attrs({})
+
+    assert "outcome" not in out
+    assert "episode_description" not in out
+
+
+def test_a_malformed_taxonomy_reads_as_empty_rather_than_raising():
+    out = read_annotation_attrs({"success": 0.0, "taxonomy": "{not json"})
+
+    assert out["outcome"] == "failure"
+    assert "side_effect_category" not in out
+
+
+def test_the_legacy_v1_fixture_reads_as_v2(legacy_v1_episode):
+    """The on-disk v1 fixture, opened through the normal read path."""
+    with h5py.File(legacy_v1_episode, "r") as f:
+        out = read_annotation_attrs(f["episode_annotations"]["test_annotator"].attrs)
+
+    assert out["outcome"] == "failure"
+    assert out["side_effect_category"] == ["grasp", "collision"]
+    assert out["severity"] == "medium"
+    assert out["episode_description"].startswith("Gripper closed early")
+
+
+# ── Drift guards ──────────────────────────────────────────────────────────────
+
+
+def _html_values(field: str) -> list:
+    """Every ``value="…"`` on inputs named *field* in the annotation form."""
+    html = _ANNOTATOR_HTML.read_text(encoding="utf-8")
+    pattern = re.compile(
+        r'<input[^>]*name="' + re.escape(field) + r'"[^>]*value="([^"]*)"'
+        r"|"
+        r'<input[^>]*value="([^"]*)"[^>]*name="' + re.escape(field) + r'"'
+    )
+    return [a or b for a, b in pattern.findall(html)]
+
+
+@pytest.mark.parametrize(
+    "field,expected",
+    [
+        ("outcome", OUTCOMES),
+        ("side_effect_category", SIDE_EFFECT_CATEGORIES),
+        ("severity", SEVERITIES),
+    ],
+)
+def test_ui_vocabulary_matches_python(field, expected):
+    """The hardcoded form and the schema must offer exactly the same slugs.
+
+    Nothing else connects them since the questionnaire YAML was removed, so a slug typo in
+    the markup would otherwise only show up as data that quietly fails to round-trip.
+    """
+    assert _html_values(field) == list(expected)
+
+
+def test_expected_fields_match_the_outcomes():
+    assert set(OUTCOME_EXPECTED_FIELDS) == set(OUTCOMES)
+
+
+def test_the_form_marks_only_outcome_as_required():
+    """Only the outcome is required; a required marker anywhere else contradicts that."""
+    html = _ANNOTATOR_HTML.read_text(encoding="utf-8")
+    required_groups = re.findall(r'data-question-id="([^"]+)"[^>]*data-required="1"', html)
+
+    assert required_groups == ["outcome"]

oopsie_data_tools/test/test_annotator_server.py

@@ -0,0 +1,240 @@
+"""Tests for the annotator Flask server's HDF5 sample endpoint.
+
+These use Flask's test client (no real socket / browser). Focus: videos are read
+from the correct ``observations/video_paths`` group — a regression guard for the
+bug where the server read a non-existent ``image_observations`` group and only
+rendered videos by accident via the ``<stem>_<cam>.mp4`` filename fallback.
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+import h5py
+import pytest
+
+from oopsie_data_tools.annotation_tool.annotation_schema import write_annotation_attrs
+from oopsie_data_tools.annotation_tool.annotator_server import app, configure_runtime
+from oopsie_data_tools.test.fixtures.make_valid import (
+    _write_base_h5,
+    _write_video,
+    write_valid_episode,
+)
+
+
+@pytest.fixture
+def client(tmp_path: Path):
+    configure_runtime(
+        samples_dir=tmp_path, annotator_name="test_annotator", browse_only=True
+    )
+    app.config.update(TESTING=True)
+    return app.test_client()
+
+
+def _get_sample(client, rel_path: str) -> dict:
+    resp = client.get(f"/api/h5/sample?path={rel_path}")
+    assert resp.status_code == 200, resp.data
+    return resp.get_json()
+
+
+def test_video_urls_from_video_paths_group_nested_layout(
+    client, tmp_path: Path
+) -> None:
+    """Video sits in a subdir with no ``<stem>_<cam>.mp4`` sibling, so only a
+    correct ``observations/video_paths`` read (not the glob fallback) finds it."""
+    nested = tmp_path / "nested"
+    (nested / "cam_videos").mkdir(parents=True)
+    _write_video(nested / "cam_videos" / "front.mp4", color=(10, 20, 30))
+    with h5py.File(nested / "ep.h5", "w") as f:
+        _write_base_h5(
+            f,
+            episode_id="ep",
+            language_instruction="do the thing",
+            camera_video_paths={"front": "cam_videos/front.mp4"},
+        )
+
+    data = _get_sample(client, "nested/ep.h5")
+
+    assert list(data["video_urls"].keys()) == ["front"]
+    assert data["video_urls"]["front"].endswith("cam_videos/front.mp4")
+
+
+def test_video_urls_resolved_for_flat_layout(client, tmp_path: Path) -> None:
+    """A standard flat episode still resolves its camera video."""
+    write_valid_episode(tmp_path, stem="flat")
+
+    data = _get_sample(client, "flat.h5")
+
+    assert "front" in data["video_urls"]
+
+
+def test_sample_returns_episode_fields(client, tmp_path: Path) -> None:
+    """/api/h5/sample summarizes all logged fields for the visualizer (#30)."""
+    write_valid_episode(tmp_path, stem="ep")
+
+    fields = _get_sample(client, "ep.h5")["episode_fields"]
+
+    assert fields["attributes"]["lab_id"] == "test_lab"
+    assert fields["robot_profile"]["policy_name"] == "test_policy"
+    assert fields["robot_states"]["joint_position"]["shape"] == [20, 7]
+    assert fields["robot_states"]["joint_position"]["empty"] is False
+    # Unused action keys are stored as h5py.Empty and flagged empty.
+    assert fields["actions"]["joint_velocity"]["empty"] is False
+    assert fields["actions"]["cartesian_position"]["empty"] is True
+    assert fields["trajectory_length"] == 20
+
+
+def test_set_instruction_persists(client, tmp_path: Path) -> None:
+    """POST /api/h5/instruction overwrites the language_instruction attr (#31)."""
+    write_valid_episode(tmp_path, stem="ep")
+
+    resp = client.post(
+        "/api/h5/instruction?path=ep.h5",
+        json={"instruction": "pour the water carefully"},
+    )
+    assert resp.status_code == 200, resp.data
+
+    data = _get_sample(client, "ep.h5")
+    assert data["metadata"]["language_instruction"] == "pour the water carefully"
+    assert data["episode_fields"]["attributes"]["language_instruction"] == "pour the water carefully"
+
+
+def test_set_instruction_rejects_empty(client, tmp_path: Path) -> None:
+    write_valid_episode(tmp_path, stem="ep")
+
+    resp = client.post("/api/h5/instruction?path=ep.h5", json={"instruction": "  "})
+
+    assert resp.status_code == 400
+
+
+def test_save_outcome_roundtrip(client, tmp_path: Path) -> None:
+    """A qualified success stores its outcome in the taxonomy and reads back (#29)."""
+    write_valid_episode(tmp_path, stem="ep")
+
+    resp = client.post(
+        "/api/h5/annotations?path=ep.h5",
+        json={
+            "outcome": "success_side_effect",
+            "severity": "low",
+            "side_effect_category": ["collision"],
+            "episode_description": "clipped a nearby cup",
+            "additional_notes": "no damage",
+        },
+    )
+    assert resp.status_code == 200, resp.data
+
+    data = _get_sample(client, "ep.h5")
+    # All three success_* outcomes still store success=1.0, so existing converters and
+    # uploaders keep reading the file unchanged.
+    assert data["metadata"]["success"] == 1.0
+    ann = data["existing_annotation"]
+    assert ann["outcome"] == "success_side_effect"
+    assert ann["side_effect_category"] == ["collision"]
+    assert ann["severity"] == "low"
+
+
+def test_save_rejects_unknown_vocabulary(client, tmp_path: Path) -> None:
+    """Slugs are opaque, so a typo must be caught before it reaches disk."""
+    write_valid_episode(tmp_path, stem="ep")
+
+    resp = client.post(
+        "/api/h5/annotations?path=ep.h5",
+        json={"outcome": "success_side_effect", "side_effect_category": ["grasp_failure"]},
+    )
+    assert resp.status_code == 400
+    assert "grasp_failure" in resp.get_json()["error"]
+
+    resp = client.post("/api/h5/annotations?path=ep.h5", json={"outcome": "sort_of"})
+    assert resp.status_code == 400
+
+
+def test_save_accepts_a_partial_taxonomy(client, tmp_path: Path) -> None:
+    """Only the outcome is required — a failure with just a severity saves cleanly."""
+    write_valid_episode(tmp_path, stem="ep")
+
+    resp = client.post(
+        "/api/h5/annotations?path=ep.h5",
+        json={"outcome": "failure", "severity": "low"},
+    )
+    assert resp.status_code == 200, resp.data
+
+    ann = _get_sample(client, "ep.h5")["existing_annotation"]
+    assert ann["outcome"] == "failure"
+    assert ann["episode_description"] == ""
+
+
+def test_recent_annotations_returns_distinct(client, tmp_path: Path) -> None:
+    """/api/annotations/recent surfaces the annotator's distinct prior failures (#27).
+
+    The endpoint feeds the taxonomy autofill picker, so clean successes are filtered
+    out and identical labels are deduplicated.
+    """
+    write_valid_episode(tmp_path, stem="a")  # clean success by test_annotator — not offered
+    for stem, description in (("b", "dropped the object"), ("c", "dropped the object"), ("d", "missed the grasp")):
+        write_valid_episode(tmp_path, stem=stem)
+        resp = client.post(
+            f"/api/h5/annotations?path={stem}.h5",
+            json={
+                "outcome": "failure",
+                "side_effect_category": ["other"],
+                "episode_description": description,
+                "severity": "low",
+            },
+        )
+        assert resp.status_code == 200, resp.data
+
+    items = client.get("/api/annotations/recent?limit=10").get_json()
+
+    assert {i["outcome"] for i in items} == {"failure"}
+    # b and c share a label; only one of them is offered.
+    assert sorted(i["episode_description"] for i in items) == [
+        "dropped the object",
+        "missed the grasp",
+    ]
+
+
+def test_recent_annotations_includes_qualified_successes(client, tmp_path: Path) -> None:
+    """A suboptimal-execution description is as worth copying as a failure's."""
+    write_valid_episode(tmp_path, stem="a")  # clean success — still filtered out
+    write_valid_episode(tmp_path, stem="b")
+    resp = client.post(
+        "/api/h5/annotations?path=b.h5",
+        json={"outcome": "success_suboptimal", "episode_description": "took a long detour"},
+    )
+    assert resp.status_code == 200, resp.data
+
+    items = client.get("/api/annotations/recent?limit=10").get_json()
+
+    assert [i["episode_description"] for i in items] == ["took a long detour"]
+
+
+def test_list_reports_other_human_annotator(client, tmp_path: Path) -> None:
+    """api_h5_list flags episodes annotated by a different human (#26)."""
+    write_valid_episode(tmp_path, stem="ep")  # annotated by test_annotator
+    with h5py.File(tmp_path / "ep.h5", "r+") as f:
+        g = f["episode_annotations"].require_group("someone_else")
+        write_annotation_attrs(
+            g,
+            {
+                "outcome": "failure",
+                "source": "human",
+                "side_effect_category": ["other"],
+                "episode_description": "x",
+                "severity": "low",
+            },
+        )
+
+    entry = next(e for e in client.get("/api/h5/list").get_json() if e["rel_path"] == "ep.h5")
+    assert entry["annotated_by_others"] is True
+
+
+def test_list_ignores_nonhuman_annotator(client, tmp_path: Path) -> None:
+    """VLM/automated subgroups do not count as 'another annotator' (#26)."""
+    write_valid_episode(tmp_path, stem="ep")
+    with h5py.File(tmp_path / "ep.h5", "r+") as f:
+        g = f["episode_annotations"].require_group("cosmos-7b")
+        g.attrs["source"] = "cosmos-7b"
+        g.attrs["success"] = 0.0
+
+    entry = next(e for e in client.get("/api/h5/list").get_json() if e["rel_path"] == "ep.h5")
+    assert entry["annotated_by_others"] is False

oopsie_data_tools/test/test_annotator_server_guards.py

@@ -0,0 +1,146 @@
+"""Path-handling guards on the annotation server.
+
+The server hands out files from ``--samples-dir`` and writes annotations into HDF5 files
+named by a query parameter. Both of those take a caller-supplied path, and every rejection
+branch was untested: the traversal guard on ``/videos-path/<path>``, and all four failure
+modes of ``_safe_h5_path_from_query``.
+"""
+
+from __future__ import annotations
+
+import h5py
+import pytest
+
+from oopsie_data_tools.annotation_tool import annotator_server
+from oopsie_data_tools.test.fixtures.make_valid import write_valid_episode
+
+
+@pytest.fixture
+def client(tmp_path):
+    """A configured server over a samples dir holding one valid episode."""
+    write_valid_episode(tmp_path, "ep")
+    annotator_server.configure_runtime(
+        samples_dir=tmp_path, annotator_name="tester", browse_only=True
+    )
+    annotator_server.app.config.update(TESTING=True)
+    with annotator_server.app.test_client() as test_client:
+        yield test_client
+
+
+@pytest.fixture
+def secret(tmp_path):
+    """A file outside the samples directory that must never be reachable."""
+    outside = tmp_path.parent / "outside_the_samples_dir.txt"
+    outside.write_text("private", encoding="utf-8")
+    return outside
+
+
+# ── /videos-path/<path> ────────────────────────────────────────────────────────
+
+
+def test_serves_a_video_inside_the_samples_dir(client, tmp_path):
+    mp4 = next(tmp_path.glob("*.mp4"))
+
+    response = client.get(f"/videos-path/{mp4.name}")
+    try:
+        assert response.status_code == 200
+        assert response.mimetype == "video/mp4"
+        assert response.data[:4] != b"", "the file should actually stream"
+    finally:
+        # send_file keeps the handle open until the response is closed, and the suite runs
+        # with filterwarnings=error, so a leaked ResourceWarning fails the test.
+        response.close()
+
+
+@pytest.mark.parametrize(
+    "attempt",
+    [
+        "../outside_the_samples_dir.txt",
+        "../../etc/passwd",
+        "subdir/../../outside_the_samples_dir.txt",
+        "%2e%2e/outside_the_samples_dir.txt",
+    ],
+)
+def test_traversal_out_of_the_samples_dir_is_refused(client, secret, attempt):
+    response = client.get(f"/videos-path/{attempt}")
+
+    assert response.status_code in (403, 404), (
+        f"{attempt!r} returned {response.status_code}; it must not be served"
+    )
+    assert b"private" not in response.data
+
+
+def test_missing_video_is_404(client):
+    assert client.get("/videos-path/no_such_video.mp4").status_code == 404
+
+
+# ── ?path= on the HDF5 endpoints ───────────────────────────────────────────────
+
+
+def test_sample_reads_an_episode_in_the_samples_dir(client, tmp_path):
+    h5_name = next(tmp_path.glob("*.h5")).name
+
+    response = client.get(f"/api/h5/sample?path={h5_name}")
+
+    assert response.status_code == 200
+    assert response.get_json()["metadata"]["rel_path"] == h5_name
+
+
+@pytest.mark.parametrize(
+    "query,expected_status,reason",
+    [
+        ("", 400, "path query parameter is required"),
+        ("?path=", 400, "empty path"),
+        ("?path=../escape.h5", 403, "escapes samples directory"),
+        ("?path=notes.txt", 400, "must refer to an .h5 file"),
+        ("?path=absent.h5", 404, "not found"),
+    ],
+)
+def test_sample_rejects_bad_paths(client, query, expected_status, reason):
+    response = client.get(f"/api/h5/sample{query}")
+
+    assert response.status_code == expected_status, reason
+    assert "error" in response.get_json()
+
+
+def test_annotation_write_refuses_a_path_outside_the_samples_dir(client, secret):
+    response = client.post(
+        "/api/h5/annotations?path=../outside_the_samples_dir.txt",
+        json={"outcome": "success"},
+    )
+
+    assert response.status_code in (400, 403)
+    assert secret.read_text(encoding="utf-8") == "private", "the file must be untouched"
+
+
+def test_annotation_write_lands_in_the_episode(client, tmp_path):
+    h5_path = next(tmp_path.glob("*.h5"))
+
+    response = client.post(
+        f"/api/h5/annotations?path={h5_path.name}",
+        json={"outcome": "success", "additional_notes": "looks fine"},
+    )
+
+    assert response.status_code == 200
+    with h5py.File(h5_path, "r") as f:
+        group = f["episode_annotations"]["tester"]
+        assert float(group.attrs["success"]) == 1.0
+        assert group.attrs["additional_notes"] == "looks fine"
+
+
+def test_instruction_write_refuses_a_path_outside_the_samples_dir(client, secret):
+    response = client.post(
+        "/api/h5/instruction?path=../outside_the_samples_dir.txt",
+        json={"instruction": "overwritten"},
+    )
+
+    assert response.status_code in (400, 403)
+    assert secret.read_text(encoding="utf-8") == "private"
+
+
+def test_instruction_rejects_an_empty_value(client, tmp_path):
+    h5_name = next(tmp_path.glob("*.h5")).name
+
+    response = client.post(f"/api/h5/instruction?path={h5_name}", json={"instruction": "  "})
+
+    assert response.status_code == 400

oopsie_data_tools/test/test_bulk_inference_end_to_end.py

@@ -0,0 +1,112 @@
+"""End-to-end: a bulk inference loop records episodes that validate.
+
+This is the only test that exercises record -> HDF5 -> MP4 -> validate as one flow. It
+lived in ``mock_bulk_inference.py``, which pytest never collected because of the filename,
+so the one integration check in the repo never ran in CI.
+
+It also no longer sleeps between episodes. That sleep was hiding a real defect: episode
+names are second-resolution, so a fast loop produced two episodes with the same name and
+the second overwrote the first. ``test_back_to_back_episodes_do_not_collide`` pins the fix.
+"""
+
+from __future__ import annotations
+
+import numpy as np
+import pytest
+
+from oopsie_data_tools.annotation_tool.episode_recorder import EpisodeRecorder
+from oopsie_data_tools.utils.robot_profile.robot_profile import RobotProfile
+from oopsie_data_tools.utils.validation.validation_utils import validate_session_dir
+
+IMG_H, IMG_W = 224, 224
+
+PROFILE = RobotProfile(
+    policy_name="mock_pi0",
+    robot_name="franka_research_3",
+    is_biarm=False,
+    uses_mobile_base=False,
+    gripper_name="robotiq_2f_85",
+    control_freq=10,
+    camera_names=["front", "wrist"],
+    robot_state_keys=["joint_position", "gripper_position"],
+    robot_state_joint_names=["j1", "j2", "j3", "j4", "j5", "j6", "j7"],
+    action_space=["joint_velocity", "gripper_position"],
+    action_joint_names=["j1", "j2", "j3", "j4", "j5", "j6", "j7"],
+)
+
+EPISODES = [
+    {"instruction": "pick up the red block", "n_steps": 25, "success": 1.0},
+    {"instruction": "place the cup on the tray", "n_steps": 30, "success": 0.0},
+    {"instruction": "open the drawer", "n_steps": 22, "success": 1.0},
+]
+
+
+def _observation(step: int) -> dict:
+    rng = np.random.default_rng(step)
+    return {
+        "robot_state": {
+            "joint_position": rng.standard_normal(7).astype(np.float32),
+            "gripper_position": np.array([rng.uniform(-1, 1)], dtype=np.float32),
+        },
+        "image_observation": {
+            cam: rng.integers(0, 255, (IMG_H, IMG_W, 3), dtype=np.uint8)
+            for cam in PROFILE.camera_names
+        },
+    }
+
+
+def _action() -> dict:
+    return {
+        "joint_velocity": (np.random.randn(7) * 0.05).astype(np.float32),
+        "gripper_position": np.clip(np.random.randn(1).astype(np.float32), -1.0, 1.0),
+    }
+
+
+@pytest.fixture
+def recorded_session(tmp_path):
+    """Record every episode back to back, with no pause between them."""
+    recorder = EpisodeRecorder(
+        robot_profile=PROFILE, data_root_dir=tmp_path, operator_name="mock_operator"
+    )
+    for episode in EPISODES:
+        recorder.reset_episode_recorder()
+        for step in range(episode["n_steps"]):
+            recorder.record_step(_observation(step), _action())
+        recorder.finish_rollout(
+            instruction=episode["instruction"], success=episode["success"]
+        )
+    return recorder.session_dir
+
+
+def test_a_recorded_session_validates(recorded_session):
+    """What the recorder writes must be what the validator accepts."""
+    assert validate_session_dir(str(recorded_session), strict_annotation_check=True) == 0
+
+
+def test_every_episode_is_written(recorded_session):
+    assert len(list(recorded_session.glob("*.h5"))) == len(EPISODES)
+
+
+def test_back_to_back_episodes_do_not_collide(recorded_session):
+    """The defect the old sleep(1.1) was working around.
+
+    These episodes are recorded within the same second, so second-resolution names used to
+    repeat and each episode overwrote the previous one's HDF5 and videos.
+    """
+    episodes = sorted(p.stem for p in recorded_session.glob("*.h5"))
+
+    assert len(set(episodes)) == len(EPISODES), f"names collided: {episodes}"
+    expected_videos = len(EPISODES) * len(PROFILE.camera_names)
+    assert len(list(recorded_session.glob("*.mp4"))) == expected_videos
+
+
+def test_each_episode_keeps_its_own_instruction(recorded_session):
+    """A weaker collision would leave the right number of files with the wrong contents."""
+    import h5py
+
+    instructions = set()
+    for h5_path in recorded_session.glob("*.h5"):
+        with h5py.File(h5_path, "r") as f:
+            instructions.add(f.attrs["language_instruction"])
+
+    assert instructions == {e["instruction"] for e in EPISODES}