Datasets:
Formats:
json
Languages:
English
Size:
< 1K
Tags:
recursive-self-improvement
program-synthesis
term-rewriting
automated-reasoning
formal-methods
benchmark
File size: 7,991 Bytes
be823b7 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 | """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)
|