Datasets:
Formats:
json
Languages:
English
Size:
< 1K
Tags:
recursive-self-improvement
program-synthesis
term-rewriting
automated-reasoning
formal-methods
benchmark
| """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) | |