"""Offline tests for release integrity, upload isolation, and audience control.""" from contextlib import redirect_stdout, redirect_stderr import importlib.util import io import json from pathlib import Path import tempfile import types import unittest from unittest.mock import patch spec = importlib.util.spec_from_file_location("nhais_uploader", Path(__file__).with_name("upload_to_hf.py")) uploader = importlib.util.module_from_spec(spec) spec.loader.exec_module(uploader) def make_release(root, files=None): files = files or {"README.md": b"# Test dataset\n", "data/result.json": b'{"ok":true}\n'} entries = [] for name, contents in files.items(): path = root / name path.parent.mkdir(parents=True, exist_ok=True) path.write_bytes(contents) entries.append({"path": name, "sha256": uploader.digest_file(path), "size_bytes": len(contents)}) (root / uploader.MANIFEST_NAME).write_text(json.dumps({"schema_version": 1, "files": entries}), encoding="utf-8") class FakeLegacyApi: def __init__(self, existing_private=None): self.calls = [] self.existing_private = existing_private self.private = None def create_repo(self, repo_id, repo_type, exist_ok, private): self.calls.append(("create", dict(repo_id=repo_id, repo_type=repo_type, exist_ok=exist_ok, private=private))) self.private = private if self.existing_private is None else self.existing_private def repo_info(self, **kwargs): self.calls.append(("info", kwargs)) return types.SimpleNamespace(private=self.private, sha="a" * 40) def upload_folder(self, **kwargs): self.calls.append(("upload", kwargs)) class FakeCurrentApi(FakeLegacyApi): def create_repo(self, repo_id, repo_type, exist_ok, visibility): self.calls.append(("create", dict(repo_id=repo_id, repo_type=repo_type, exist_ok=exist_ok, visibility=visibility))) self.private = visibility == "private" if self.existing_private is None else self.existing_private class UploaderTests(unittest.TestCase): def setUp(self): self.temporary = tempfile.TemporaryDirectory() self.root = Path(self.temporary.name) make_release(self.root) def tearDown(self): self.temporary.cleanup() def manifest(self): return json.loads((self.root / uploader.MANIFEST_NAME).read_text()) def set_manifest(self, value): (self.root / uploader.MANIFEST_NAME).write_text(json.dumps(value)) def test_valid_release(self): self.assertEqual(uploader.validate_release(self.root), ["README.md", "data/result.json"]) def test_tamper_rejected(self): (self.root / "README.md").write_text("changed") with self.assertRaises(uploader.ReleaseError): uploader.validate_release(self.root) def test_missing_rejected(self): (self.root / "data/result.json").unlink() with self.assertRaises(uploader.ReleaseError): uploader.validate_release(self.root) def test_traversal_and_secrets_rejected(self): for value in ["../README.md", "/etc/passwd", "C:/token.txt", "a\\b", "./README.md", ".env", ".venv-hf/thing", "data/token.txt", "a.pem"]: with self.subTest(value=value), self.assertRaises(uploader.ReleaseError): uploader.safe_relative_path(value) def test_case_colliding_paths_rejected(self): manifest = self.manifest() manifest["files"].append({**manifest["files"][0], "path": "readme.md"}) self.set_manifest(manifest) with self.assertRaises(uploader.ReleaseError): uploader.validate_release(self.root) def test_symbolic_link_rejected(self): source = self.root / "data/result.json" source.unlink() try: source.symlink_to(self.root / "README.md") except (OSError, NotImplementedError): self.skipTest("Symlinks not permitted by this OS account") with self.assertRaises(uploader.ReleaseError): uploader.validate_release(self.root) def test_unlisted_credentials_never_staged(self): (self.root / ".env").write_text("SECRET=not-a-real-token") (self.root / "extra.txt").write_text("unlisted") with tempfile.TemporaryDirectory() as directory: staged = Path(directory) uploader.stage_release(self.root, staged, uploader.validate_release(self.root)) actual = {p.relative_to(staged).as_posix() for p in staged.rglob("*") if p.is_file()} self.assertEqual(actual, {"README.md", "data/result.json", uploader.MANIFEST_NAME}) def test_staged_snapshot_is_revalidated(self): files = uploader.validate_release(self.root) (self.root / "README.md").write_text("tampered after first validation") with tempfile.TemporaryDirectory() as directory, self.assertRaises(uploader.ReleaseError): uploader.stage_release(self.root, Path(directory), files) def test_verify_only_does_not_load_hub(self): with patch.object(uploader, "load_hub", side_effect=AssertionError("network dependency loaded")), redirect_stdout(io.StringIO()): self.assertEqual(uploader.main(["--root", str(self.root), "--verify-only"]), 0) def test_private_legacy_api_and_non_deletion(self): api = FakeLegacyApi() with redirect_stdout(io.StringIO()): uploader.upload_verified(api, self.root, "person/release", False) self.assertIs(api.calls[0][1]["private"], True) kwargs = api.calls[-1][1] self.assertEqual(kwargs["repo_type"], "dataset") self.assertNotIn("delete_patterns", kwargs) self.assertEqual(kwargs["parent_commit"], "a" * 40) def test_public_current_api(self): api = FakeCurrentApi() with redirect_stdout(io.StringIO()): uploader.upload_verified(api, self.root, "person/release", True) self.assertEqual(api.calls[0][1]["visibility"], "public") self.assertEqual(api.calls[-1][0], "upload") def test_public_existing_repo_requires_opt_in(self): api = FakeLegacyApi(existing_private=False) with self.assertRaises(uploader.ReleaseError): uploader.upload_verified(api, self.root, "person/release", False) self.assertFalse(any(name == "upload" for name, _ in api.calls)) def test_private_existing_repo_never_made_public(self): api = FakeCurrentApi(existing_private=True) with redirect_stdout(io.StringIO()): uploader.upload_verified(api, self.root, "person/release", True) self.assertTrue(api.private) self.assertEqual([name for name, _ in api.calls], ["create", "info", "upload"]) def test_repo_id_validation(self): self.assertEqual(uploader.validate_repo_id("user/nhais-dq-ii"), "user/nhais-dq-ii") for invalid in ["https://huggingface.co/user/a", "user", "user/../a", "user/bad--name", "user/name."]: with self.subTest(value=invalid), self.assertRaises(uploader.ReleaseError): uploader.validate_repo_id(invalid) def test_noninteractive_missing_auth_does_not_prompt(self): with patch.dict(uploader.os.environ, {"HF_TOKEN": ""}), patch.object(uploader.getpass, "getpass", side_effect=AssertionError("prompted")): with self.assertRaises(uploader.ReleaseError): uploader.resolve_token(lambda: None, True) def test_error_response_never_prints_exception_body(self): secret = "FAKE_TEST_SECRET_DO_NOT_PRINT" def fail_hub(): raise RuntimeError(secret) error = io.StringIO() with patch.object(uploader, "load_hub", fail_hub), redirect_stdout(io.StringIO()), redirect_stderr(error): code = uploader.main(["--root", str(self.root), "--repo-id", "person/release"]) self.assertEqual(code, 1) self.assertNotIn(secret, error.getvalue()) if __name__ == "__main__": unittest.main(verbosity=2)