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

oopsie_data_tools/test/test_hf_upload.py

@@ -0,0 +1,234 @@
+"""Tests for the validate-and-upload helpers.
+
+``utils/hf_upload.py`` is what stands between a lab and the public dataset, and it had no
+tests at all. Nothing here touches the network: the HuggingFace API is a stand-in object,
+and the only real work is on temporary directories.
+"""
+
+from __future__ import annotations
+
+import logging
+
+import pytest
+
+from oopsie_data_tools.test.fixtures.make_valid import write_valid_episode
+from oopsie_data_tools.utils import hf_upload
+from oopsie_data_tools.utils.log import setup_logger
+
+
+class FakeApi:
+    """Records what an upload would have done, without doing it."""
+
+    def __init__(self, existing_repos=()):
+        self.existing = set(existing_repos)
+        self.created: list[str] = []
+        self.uploaded: list[tuple[str, str]] = []
+        self.remote_files: list[str] = []
+
+    def repo_info(self, repo_id, repo_type):
+        if repo_id not in self.existing:
+            raise RuntimeError("404")
+        return {"id": repo_id}
+
+    def create_repo(self, repo_id, repo_type, private):
+        self.existing.add(repo_id)
+        self.created.append(repo_id)
+
+    def upload_large_folder(self, folder_path, repo_id, repo_type):
+        self.uploaded.append((repo_id, str(folder_path)))
+
+    def list_repo_files(self, repo_id, repo_type):
+        return self.remote_files
+
+
+# ── run_validation ─────────────────────────────────────────────────────────────
+
+
+def test_validation_passes_for_a_good_session(tmp_path):
+    write_valid_episode(tmp_path, "ep_a")
+
+    assert hf_upload.run_validation(str(tmp_path)) == 0
+
+
+def test_validation_fails_for_a_bad_session(tmp_path):
+    write_valid_episode(tmp_path, "ep_a")
+    (tmp_path / "broken.h5").write_text("not hdf5", encoding="utf-8")
+
+    assert hf_upload.run_validation(str(tmp_path)) == 1
+
+
+def test_validation_reports_a_missing_path(tmp_path, caplog):
+    assert hf_upload.run_validation(str(tmp_path / "nope")) == 1
+    assert "does not exist" in caplog.text
+
+
+def test_validation_of_a_single_episode_by_id(tmp_path):
+    write_valid_episode(tmp_path, "000001")
+
+    assert hf_upload.run_validation(str(tmp_path), episode_id="000001") == 0
+
+
+def test_validation_writes_the_log_file_when_asked(tmp_path):
+    write_valid_episode(tmp_path, "ep_a")
+    log_path = tmp_path / "run.log"
+
+    hf_upload.run_validation(str(tmp_path), log_path=str(log_path))
+
+    assert log_path.exists() and log_path.stat().st_size > 0
+
+
+# ── check_folder_size ──────────────────────────────────────────────────────────
+
+
+def test_folder_size_check_passes_for_a_normal_layout(tmp_path):
+    write_valid_episode(tmp_path, "ep_a")
+
+    assert hf_upload.check_folder_size(str(tmp_path)) == []
+
+
+def test_folder_size_check_flags_a_directory_over_the_limit(tmp_path, monkeypatch, caplog):
+    monkeypatch.setattr(hf_upload, "FILE_LIMIT", 3)
+    for i in range(5):
+        (tmp_path / f"f{i}.bin").write_text("x", encoding="utf-8")
+
+    oversized = hf_upload.check_folder_size(str(tmp_path))
+
+    assert [count for _, count in oversized] == [5]
+    assert "exceed" in caplog.text
+    # The remedy must be a subcommand, not a path into the source checkout. It used to name
+    # scripts/validate_and_upload/restructure_large_folder.py, which does not exist for anyone
+    # who pip-installed the package — leaving the precheck's only fix unreachable.
+    assert "oopsie-data restructure --source" in caplog.text, "tell the user how to fix it"
+    assert "scripts/" not in caplog.text
+
+
+def test_folder_size_result_is_falsy_when_fine(tmp_path):
+    """cmd_upload branches on this directly, so its truthiness is load-bearing."""
+    assert not hf_upload.check_folder_size(str(tmp_path))
+
+
+# ── resolve_hf_target ──────────────────────────────────────────────────────────
+
+
+def test_repo_is_derived_from_the_lab_id(monkeypatch):
+    monkeypatch.delenv("HF_TOKEN", raising=False)
+
+    token, repo = hf_upload.resolve_hf_target()
+
+    assert repo == "OopsieData-Submissions/test_lab"  # conftest's stubbed contributor config
+    assert token == "test_token"
+
+
+def test_hf_token_env_var_overrides_the_config(monkeypatch):
+    monkeypatch.setenv("HF_TOKEN", "hf_from_the_environment")
+
+    token, _ = hf_upload.resolve_hf_target()
+
+    assert token == "hf_from_the_environment"
+
+
+# ── ensure_repo / upload_dataset ───────────────────────────────────────────────
+
+
+def test_missing_repo_is_created():
+    api = FakeApi()
+
+    hf_upload.ensure_repo(api, "OopsieData-Submissions/lab")
+
+    assert api.created == ["OopsieData-Submissions/lab"]
+
+
+def test_existing_repo_is_left_alone():
+    api = FakeApi(existing_repos={"OopsieData-Submissions/lab"})
+
+    hf_upload.ensure_repo(api, "OopsieData-Submissions/lab")
+
+    assert api.created == []
+
+
+def test_upload_sends_the_whole_folder(tmp_path):
+    write_valid_episode(tmp_path, "ep_a")
+    api = FakeApi()
+    api.remote_files = ["ep_a.h5"]
+
+    hf_upload.upload_dataset(api, "OopsieData-Submissions/lab", str(tmp_path))
+
+    assert api.uploaded == [("OopsieData-Submissions/lab", str(tmp_path))]
+
+
+def test_upload_warns_when_fewer_episodes_arrive_than_were_sent(tmp_path, caplog):
+    write_valid_episode(tmp_path, "ep_a")
+    write_valid_episode(tmp_path, "ep_b")
+    api = FakeApi()
+    api.remote_files = ["ep_a.h5"]  # one of the two is missing remotely
+
+    with caplog.at_level(logging.WARNING):
+        hf_upload.upload_dataset(api, "OopsieData-Submissions/lab", str(tmp_path))
+
+    assert "below local" in caplog.text
+
+
+def test_upload_survives_a_repo_listing_failure(tmp_path, caplog):
+    """The post-upload check is a courtesy; it must not fail an upload that worked."""
+    write_valid_episode(tmp_path, "ep_a")
+    api = FakeApi()
+
+    def boom(**_):
+        raise RuntimeError("listing unavailable")
+
+    api.list_repo_files = boom
+
+    hf_upload.upload_dataset(api, "OopsieData-Submissions/lab", str(tmp_path))
+
+    assert api.uploaded, "the upload itself still happened"
+    assert "Could not confirm" in caplog.text
+
+
+# ── utils/log.py ───────────────────────────────────────────────────────────────
+
+
+def test_setup_logger_writes_to_the_named_file(tmp_path):
+    log_path = tmp_path / "a.log"
+
+    logger = setup_logger("oopsie_data_tools.test.logging_probe", str(log_path))
+    logger.info("hello")
+
+    assert "hello" in log_path.read_text(encoding="utf-8")
+
+
+def test_setup_logger_does_not_stack_handlers(tmp_path):
+    """It is called once per validated file, so repeated calls must not accumulate."""
+    name = "oopsie_data_tools.test.logging_probe_repeat"
+
+    first = setup_logger(name, str(tmp_path / "a.log"))
+    handler_count = len(first.handlers)
+    for _ in range(3):
+        setup_logger(name, str(tmp_path / "a.log"))
+
+    assert len(first.handlers) == handler_count
+
+
+def test_setup_logger_honours_a_second_different_file(tmp_path):
+    """The guard used to be "any handler at all", so a second --log-path wrote nothing."""
+    name = "oopsie_data_tools.test.logging_probe_repeat"
+    first_file, second_file = tmp_path / "a.log", tmp_path / "b.log"
+
+    setup_logger(name, str(first_file))
+    logger = setup_logger(name, str(second_file))
+    logger.info("second run")
+
+    assert "second run" in second_file.read_text(encoding="utf-8")
+
+
+@pytest.fixture(autouse=True)
+def _detach_probe_loggers():
+    """Loggers are global; leave none behind holding a temp file open."""
+    yield
+    for name in (
+        "oopsie_data_tools.test.logging_probe",
+        "oopsie_data_tools.test.logging_probe_repeat",
+    ):
+        logger = logging.getLogger(name)
+        for handler in list(logger.handlers):
+            handler.close()
+            logger.removeHandler(handler)

oopsie_data_tools/test/test_init_wizard.py

@@ -0,0 +1,193 @@
+"""Tests for ``oopsie-data init`` (``oopsie_data_tools/init_wizard.py``).
+
+The wizard is driven by scripted answers: ``builtins.input`` is replaced with a queue and
+``sys.stdin.isatty`` is forced True, which is what the prompt helpers gate on.
+
+Note: ``conftest._test_contributor_config`` rebinds ``read_contributor_config`` for the whole
+session, so assertions here read the written YAML directly rather than through that name.
+"""
+
+from __future__ import annotations
+
+import sys
+
+import pytest
+import yaml
+
+from oopsie_data_tools import cli
+from oopsie_data_tools.utils import paths
+
+
+@pytest.fixture
+def config_dir(tmp_path, monkeypatch):
+    """Send every config read and write into a scratch directory."""
+    target = tmp_path / "config"
+    monkeypatch.setenv(paths.ENV_CONFIG_DIR, str(target))
+    return target
+
+
+@pytest.fixture
+def answers(monkeypatch):
+    """Script the wizard's prompts; returns the list to fill in per test."""
+    queue: list[str] = []
+
+    def _fake_input(prompt: str = "") -> str:
+        if not queue:
+            raise AssertionError(f"wizard asked an unexpected question: {prompt!r}")
+        return queue.pop(0)
+
+    monkeypatch.setattr("builtins.input", _fake_input)
+    monkeypatch.setattr(sys.stdin, "isatty", lambda: True)
+    return queue
+
+
+def _read_yaml(path):
+    return yaml.safe_load(path.read_text(encoding="utf-8"))
+
+
+# ── credentials ───────────────────────────────────────────────────────────────
+
+
+def test_credentials_written_and_readable(config_dir, answers):
+    answers.extend(["MyLab", "hf_secret_token"])
+
+    assert cli.main(["init", "--no-verify-token"]) == 0
+
+    path = config_dir / "contributor_config.yaml"
+    assert _read_yaml(path) == {"lab_id": "MyLab", "huggingface_token": "hf_secret_token"}
+    assert path.stat().st_mode & 0o777 == 0o600, "the token file must not be world readable"
+
+
+def test_credentials_from_flags_need_no_prompts(config_dir, answers):
+    # `answers` is empty: any prompt raises. Fully-flagged runs must be unattended.
+    assert (
+        cli.main(
+            ["init", "--lab-id", "FlagLab", "--hf-token", "t", "--no-verify-token"]
+        )
+        == 0
+    )
+    assert _read_yaml(config_dir / "contributor_config.yaml")["lab_id"] == "FlagLab"
+
+
+def test_placeholder_lab_id_is_rejected(config_dir, answers):
+    answers.extend(["your_lab_id", "RealLab", ""])  # re-asked after the placeholder
+
+    assert cli.main(["init", "--no-verify-token"]) == 0
+    assert _read_yaml(config_dir / "contributor_config.yaml")["lab_id"] == "RealLab"
+
+
+def test_placeholder_lab_id_from_flag_aborts(config_dir, answers):
+    assert cli.main(["init", "--lab-id", "your_lab_id"]) == 1
+    assert not (config_dir / "contributor_config.yaml").exists()
+
+
+def test_existing_config_is_not_overwritten_without_consent(config_dir, answers):
+    config_dir.mkdir(parents=True)
+    path = config_dir / "contributor_config.yaml"
+    path.write_text("lab_id: Original\nhuggingface_token: keep\n")
+    answers.append("n")  # "Update it?" -> no
+
+    assert cli.main(["init", "--no-verify-token"]) == 0
+    assert _read_yaml(path)["lab_id"] == "Original"
+
+
+def test_existing_config_without_force_fails_non_interactively(config_dir, monkeypatch):
+    """Nothing was written, so the exit code must say so rather than report success."""
+    config_dir.mkdir(parents=True)
+    path = config_dir / "contributor_config.yaml"
+    path.write_text("lab_id: Original\nhuggingface_token: keep\n")
+    monkeypatch.setattr(sys.stdin, "isatty", lambda: False)
+
+    assert cli.main(["init", "--lab-id", "New", "--no-verify-token"]) == 1
+    assert _read_yaml(path)["lab_id"] == "Original"
+
+
+def test_force_overwrites_without_asking(config_dir, answers):
+    config_dir.mkdir(parents=True)
+    path = config_dir / "contributor_config.yaml"
+    path.write_text("lab_id: Original\nhuggingface_token: keep\n")
+
+    assert (
+        cli.main(
+            ["init", "--force", "--lab-id", "New", "--hf-token", "t2",
+             "--no-verify-token"]
+        )
+        == 0
+    )
+    assert _read_yaml(path)["lab_id"] == "New"
+
+
+def test_token_is_verified_when_asked_for(config_dir, answers, monkeypatch):
+    seen = {}
+    monkeypatch.setattr(
+        "huggingface_hub.whoami", lambda token=None: seen.update(token=token) or {"name": "someone"}
+    )
+
+    assert cli.main(["init", "--lab-id", "L", "--hf-token", "good"]) == 0
+    assert seen["token"] == "good"
+
+
+def test_token_verification_failure_is_not_fatal(config_dir, answers, monkeypatch):
+    def _boom(token=None):
+        raise RuntimeError("Invalid user token.")
+
+    monkeypatch.setattr("huggingface_hub.whoami", _boom)
+
+    assert cli.main(["init", "--lab-id", "L", "--hf-token", "bad"]) == 0
+    assert _read_yaml(config_dir / "contributor_config.yaml")["huggingface_token"] == "bad"
+
+
+# ── persisting a custom config dir ────────────────────────────────────────────
+
+
+def test_config_dir_flag_prints_the_export_line(tmp_path, monkeypatch, capsys, caplog):
+    """--config-dir only lives for one process, so init must say how to keep it."""
+    custom = tmp_path / "custom"
+    monkeypatch.delenv(paths.ENV_CONFIG_DIR, raising=False)
+    monkeypatch.setenv("XDG_CONFIG_HOME", str(tmp_path / "xdg"))
+    monkeypatch.setattr(sys.stdin, "isatty", lambda: False)
+
+    assert (
+        cli.main(
+            ["--config-dir", str(custom), "init", "--lab-id", "L", "--hf-token", "t",
+             "--no-verify-token"]
+        )
+        == 0
+    )
+    logged = caplog.text + capsys.readouterr().err
+    assert f'export {paths.ENV_CONFIG_DIR}="{custom}"' in logged
+
+
+def test_exported_env_dir_needs_no_advice(config_dir, monkeypatch, capsys, caplog):
+    """A dir already exported in the environment is found next run; stay quiet."""
+    monkeypatch.setattr(sys.stdin, "isatty", lambda: False)
+
+    assert (
+        cli.main(["init", "--lab-id", "L", "--hf-token", "t", "--no-verify-token"]) == 0
+    )
+    assert f"export {paths.ENV_CONFIG_DIR}" not in (caplog.text + capsys.readouterr().err)
+
+
+# ── non-interactive behaviour ─────────────────────────────────────────────────
+
+
+def test_non_tty_without_flags_exits_one(config_dir, monkeypatch):
+    monkeypatch.setattr(sys.stdin, "isatty", lambda: False)
+    monkeypatch.setattr(
+        "builtins.input", lambda prompt="": pytest.fail("must not prompt without a terminal")
+    )
+
+    assert cli.main(["init"]) == 1
+    assert not (config_dir / "contributor_config.yaml").exists()
+
+
+def test_fully_flagged_run_needs_no_terminal(config_dir, monkeypatch):
+    monkeypatch.setattr(sys.stdin, "isatty", lambda: False)
+    monkeypatch.setattr(
+        "builtins.input", lambda prompt="": pytest.fail("must not prompt without a terminal")
+    )
+
+    assert (
+        cli.main(["init", "--lab-id", "L", "--hf-token", "t", "--no-verify-token"]) == 0
+    )
+    assert (config_dir / "contributor_config.yaml").is_file()

oopsie_data_tools/test/test_install_skill.py

@@ -0,0 +1,120 @@
+"""Tests for ``oopsie-data install-skill``.
+
+The command is a directory copy, so what is worth pinning down is the destination for
+each scope, that an existing directory is never clobbered without --force, and that the
+payload really is inside the package rather than only in a source checkout.
+"""
+
+from __future__ import annotations
+
+import pytest
+
+from oopsie_data_tools import cli
+from oopsie_data_tools.utils import claude_skill
+
+
+@pytest.fixture
+def home(tmp_path, monkeypatch):
+    """An empty home directory, with an empty project as the working directory."""
+    fake_home = tmp_path / "home"
+    fake_home.mkdir()
+    project = tmp_path / "project"
+    project.mkdir()
+    monkeypatch.setenv("HOME", str(fake_home))
+    monkeypatch.setattr(claude_skill.Path, "home", classmethod(lambda cls: fake_home))
+    monkeypatch.chdir(project)
+    return fake_home
+
+
+def test_payload_ships_inside_the_package():
+    """The skill must resolve through the installed package, not the repo layout."""
+    assert (claude_skill.bundled_skill_dir() / "SKILL.md").is_file()
+
+
+def test_payload_ships_the_reference_files_skill_md_points_at():
+    """SKILL.md is a router; the pages it defers to have to be there to be read."""
+    reference = claude_skill.bundled_skill_dir() / "reference"
+    linked = {
+        "setup.md",
+        "robot-profile.md",
+        "format.md",
+        "conversion.md",
+        "troubleshooting.md",
+    }
+
+    assert {p.name for p in reference.glob("*.md")} == linked
+
+    skill_md = (claude_skill.bundled_skill_dir() / "SKILL.md").read_text(encoding="utf-8")
+    for name in linked:
+        assert f"reference/{name}" in skill_md
+
+
+def test_skill_declares_frontmatter_claude_can_discover():
+    text = (claude_skill.bundled_skill_dir() / "SKILL.md").read_text(encoding="utf-8")
+    assert text.startswith("---\n")
+    frontmatter = text.split("---\n")[1]
+    assert f"name: {claude_skill.SKILL_NAME}\n" in frontmatter
+    assert "description:" in frontmatter
+
+
+def test_installs_into_a_visible_project_directory_by_default(home, tmp_path):
+    """Default scope is the project, and deliberately not a hidden .claude directory."""
+    assert cli.main(["install-skill"]) == 0
+
+    assert (tmp_path / "project" / "skills" / "oopsie-data" / "SKILL.md").is_file()
+    assert not (tmp_path / "project" / ".claude").exists()
+    assert not (home / ".claude").exists()
+
+
+def test_install_copies_the_whole_payload_tree(home, tmp_path):
+    """Subdirectories install too, so a page added to the payload cannot go missing."""
+    assert cli.main(["install-skill"]) == 0
+
+    source = claude_skill.bundled_skill_dir()
+    dest = tmp_path / "project" / "skills" / "oopsie-data"
+    expected = {p.relative_to(source) for p in source.rglob("*") if p.is_file()}
+
+    assert expected == {p.relative_to(dest) for p in dest.rglob("*") if p.is_file()}
+
+
+def test_user_scope_installs_where_claude_code_scans(home, tmp_path):
+    assert cli.main(["install-skill", "--user"]) == 0
+
+    assert (home / ".claude" / "skills" / "oopsie-data" / "SKILL.md").is_file()
+    assert not (tmp_path / "project" / "skills").exists()
+
+
+def test_default_install_explains_how_to_activate_the_skill(home, caplog):
+    """./skills is not scanned by Claude Code, so the command must not imply it is live."""
+    with caplog.at_level("INFO"):
+        assert cli.main(["install-skill"]) == 0
+
+    assert ".claude/skills" in caplog.text
+
+
+def test_refuses_to_overwrite_without_force(home, tmp_path):
+    assert cli.main(["install-skill"]) == 0
+    edited = tmp_path / "project" / "skills" / "oopsie-data" / "SKILL.md"
+    edited.write_text("local edits", encoding="utf-8")
+
+    assert cli.main(["install-skill"]) == 1
+    assert edited.read_text(encoding="utf-8") == "local edits"
+
+
+def test_force_replaces_the_existing_installation(home, tmp_path):
+    assert cli.main(["install-skill"]) == 0
+    installed = tmp_path / "project" / "skills" / "oopsie-data"
+    (installed / "SKILL.md").write_text("local edits", encoding="utf-8")
+    stale = installed / "stale.md"
+    stale.write_text("removed by --force", encoding="utf-8")
+
+    assert cli.main(["install-skill", "--force"]) == 0
+
+    assert "local edits" not in (installed / "SKILL.md").read_text(encoding="utf-8")
+    assert not stale.exists()
+
+
+def test_nothing_is_written_when_the_command_is_not_run(home, tmp_path):
+    assert cli.main(["show-config"]) == 0
+    assert not (home / ".claude").exists()
+    assert not (tmp_path / "project" / "skills").exists()