| """Offline uploader tests: temporary fixtures and fake API, never real uploads.""" |
|
|
| import getpass |
| import hashlib |
| import importlib.util |
| import json |
| from pathlib import Path |
| from types import SimpleNamespace |
| import sys |
| import tempfile |
| import unittest |
| import warnings |
|
|
|
|
| SCRIPT = Path(__file__).resolve().parents[1] / "UPLOAD_TO_HUGGINGFACE.py" |
| SPEC = importlib.util.spec_from_file_location("release_uploader", SCRIPT) |
| uploader = importlib.util.module_from_spec(SPEC) |
| sys.modules[SPEC.name] = uploader |
| SPEC.loader.exec_module(uploader) |
|
|
|
|
| class MissingRepo(Exception): |
| pass |
|
|
|
|
| class FakeApi: |
| def __init__(self, *, exists=False, private=False, token=""): |
| self.exists = exists |
| self.private = private |
| self.token = token |
| self.creates = [] |
| self.uploads = [] |
| self.whoami_calls = 0 |
| self.during_whoami = None |
| self.raise_upload = None |
|
|
| def whoami(self): |
| self.whoami_calls += 1 |
| if self.during_whoami: |
| self.during_whoami() |
| return {"name": "TestResearcher"} |
|
|
| def repo_info(self, **kwargs): |
| if not self.exists: |
| raise MissingRepo() |
| return SimpleNamespace(private=self.private) |
|
|
| def create_repo(self, **kwargs): |
| self.creates.append(kwargs) |
| self.exists = True |
| self.private = kwargs["private"] |
|
|
| def upload_folder(self, **kwargs): |
| if self.raise_upload: |
| raise self.raise_upload |
| staging = Path(kwargs["folder_path"]) |
| snapshot = {str(path.relative_to(staging)).replace("\\", "/"): path.read_bytes() |
| for path in staging.rglob("*") if path.is_file()} |
| self.uploads.append((kwargs, snapshot)) |
|
|
|
|
| class UploaderTests(unittest.TestCase): |
| def setUp(self): |
| self.temporary = tempfile.TemporaryDirectory() |
| self.root = Path(self.temporary.name) |
| (self.root / "docs").mkdir() |
| (self.root / "README.md").write_bytes(b"Research release\n") |
| (self.root / "docs" / "note.md").write_bytes(b"Verified note\n") |
| self.write_manifest(["README.md", "docs/note.md"]) |
| self.messages = [] |
| self.api = FakeApi() |
| self.token = "hf_TEST_SECRET_NOT_REAL" |
|
|
| def tearDown(self): |
| self.temporary.cleanup() |
|
|
| def write_manifest(self, paths): |
| manifest = {path: hashlib.sha256((self.root / path).read_bytes()).hexdigest() |
| for path in paths} |
| (self.root / uploader.MANIFEST).write_text(json.dumps(manifest), encoding="utf-8") |
|
|
| def loader(self): |
| def factory(*, token): |
| self.api.token = token |
| return self.api |
| return factory, lambda: self.token, MissingRepo |
|
|
| def run_uploader(self, argv, *, answers=(), **kwargs): |
| values = iter(answers) |
| return uploader.main(argv, root=self.root, hub_loader=self.loader, |
| input_fn=lambda prompt: next(values), |
| output=self.messages.append, **kwargs) |
|
|
| def test_dry_run_is_offline_and_ignores_unlisted_credentials(self): |
| (self.root / ".env").write_text("HF_TOKEN=SECRET") |
| (self.root / "generated-results.csv").write_text("local output") |
| def forbidden_loader(): |
| self.fail("Offline dry-run imported the Hub dependency") |
| result = uploader.main(["--dry-run"], root=self.root, |
| hub_loader=forbidden_loader, output=self.messages.append) |
| self.assertEqual(result, 0) |
| output = "\n".join(self.messages) |
| self.assertIn("3 files", output) |
| self.assertNotIn("HF_TOKEN=SECRET", output) |
| self.assertNotIn("generated-results.csv", output) |
| self.assertEqual(self.api.whoami_calls, 0) |
|
|
| def test_checksum_mismatch_refuses_before_authentication(self): |
| (self.root / "README.md").write_bytes(b"changed") |
| result = self.run_uploader(["--repo-id", "TestResearcher/Infinite-Players", "--yes"]) |
| self.assertEqual(result, 1) |
| self.assertIn("Checksum mismatch", "\n".join(self.messages)) |
| self.assertEqual(self.api.whoami_calls, 0) |
| self.assertEqual(self.api.uploads, []) |
|
|
| def test_existing_repo_keeps_visibility_and_uploads_exact_staged_set(self): |
| self.api.exists = True |
| self.api.private = False |
| (self.root / ".env").write_text("secret") |
| (self.root / "extra.txt").write_text("not for publication") |
| result = self.run_uploader(["--repo-id", "TestResearcher/Infinite-Players", "--private", "--yes"]) |
| self.assertEqual(result, 0) |
| self.assertEqual(self.api.creates, []) |
| self.assertFalse(self.api.private) |
| parameters, snapshot = self.api.uploads[0] |
| self.assertEqual(set(snapshot), {"README.md", "docs/note.md", "FILE_MANIFEST.json"}) |
| self.assertEqual(set(parameters["allow_patterns"]), set(snapshot)) |
| self.assertEqual(parameters["repo_type"], "dataset") |
| self.assertNotIn("delete_patterns", parameters) |
| self.assertFalse(Path(parameters["folder_path"]).exists()) |
|
|
| def test_new_repo_defaults_public_then_retry_uses_same_paths(self): |
| argv = ["--repo-id", "TestResearcher/Infinite-Players", "--yes"] |
| self.assertEqual(self.run_uploader(argv), 0) |
| self.assertEqual(self.run_uploader(argv), 0) |
| self.assertEqual(len(self.api.creates), 1) |
| self.assertFalse(self.api.creates[0]["private"]) |
| self.assertFalse(self.api.creates[0]["exist_ok"]) |
| self.assertEqual(self.api.uploads[0][1], self.api.uploads[1][1]) |
| self.assertEqual(self.api.uploads[0][0]["repo_id"], self.api.uploads[1][0]["repo_id"]) |
|
|
| def test_private_flag_creates_new_private_repo(self): |
| self.assertEqual(self.run_uploader(["--repo-id", "TestResearcher/Private-Release", "--private", "--yes"]), 0) |
| self.assertTrue(self.api.creates[0]["private"]) |
|
|
| def test_interactive_username_suggestion_and_exact_confirmation(self): |
| result = self.run_uploader([], answers=["", "private", "TestResearcher/Infinite-Players"]) |
| self.assertEqual(result, 0) |
| self.assertEqual(self.api.creates[0]["repo_id"], "TestResearcher/Infinite-Players") |
| self.assertTrue(self.api.creates[0]["private"]) |
|
|
| def test_wrong_confirmation_cancels_before_remote_mutation(self): |
| result = self.run_uploader(["--repo-id", "TestResearcher/Infinite-Players"], |
| answers=["public", "yes"]) |
| self.assertEqual(result, 0) |
| self.assertEqual(self.api.creates, []) |
| self.assertEqual(self.api.uploads, []) |
|
|
| def test_yes_requires_explicit_target(self): |
| result = self.run_uploader(["--yes"]) |
| self.assertEqual(result, 1) |
| self.assertEqual(self.api.whoami_calls, 0) |
|
|
| def test_no_token_noninteractive_stops_without_hidden_prompt(self): |
| self.token = None |
| def no_prompt(prompt): |
| self.fail("--yes must not ask for a token") |
| result = self.run_uploader(["--repo-id", "TestResearcher/Infinite-Players", "--yes"], |
| getpass_fn=no_prompt) |
| self.assertEqual(result, 1) |
| self.assertEqual(self.api.whoami_calls, 0) |
|
|
| def test_hidden_token_is_transient_and_not_printed(self): |
| self.token = None |
| secret = "hf_TRANSIENT_TEST_SECRET" |
| result = self.run_uploader(["--repo-id", "TestResearcher/Infinite-Players"], |
| answers=["public", "TestResearcher/Infinite-Players"], |
| getpass_fn=lambda prompt: secret) |
| self.assertEqual(result, 0) |
| self.assertEqual(self.api.token, secret) |
| self.assertNotIn(secret, "\n".join(self.messages)) |
| self.assertEqual(sorted(path.name for path in self.root.iterdir()), |
| ["FILE_MANIFEST.json", "README.md", "docs"]) |
|
|
| def test_getpass_fails_closed_if_terminal_cannot_hide_token(self): |
| self.token = None |
| def unsafe_prompt(prompt): |
| warnings.warn("Password may be echoed", getpass.GetPassWarning) |
| return "must-not-be-entered" |
| result = self.run_uploader(["--repo-id", "TestResearcher/Infinite-Players"], |
| getpass_fn=unsafe_prompt) |
| self.assertEqual(result, 1) |
| self.assertEqual(self.api.whoami_calls, 0) |
| self.assertIn("Hidden token entry is unavailable", "\n".join(self.messages)) |
|
|
| def test_upload_uses_verified_bytes_even_if_source_changes_later(self): |
| original = (self.root / "README.md").read_bytes() |
| self.api.during_whoami = lambda: (self.root / "README.md").write_bytes(b"unverified edit") |
| result = self.run_uploader(["--repo-id", "TestResearcher/Infinite-Players", "--yes"]) |
| self.assertEqual(result, 0) |
| self.assertEqual(self.api.uploads[0][1]["README.md"], original) |
|
|
| def test_remote_exception_never_prints_token_or_traceback(self): |
| error = RuntimeError("Remote request failed token=" + self.token) |
| error.response = SimpleNamespace(status_code=403) |
| self.api.raise_upload = error |
| result = self.run_uploader(["--repo-id", "TestResearcher/Infinite-Players", "--yes"]) |
| self.assertEqual(result, 1) |
| output = "\n".join(self.messages) |
| self.assertIn("Authentication or permission denied", output) |
| self.assertNotIn(self.token, output) |
| self.assertNotIn("Traceback", output) |
|
|
| def test_unsafe_paths_and_explicit_credentials_are_rejected(self): |
| for path in ("../escape.txt", "/absolute.txt", "C:/escape", "docs\\note.md", |
| "docs/./note.md", "docs//note.md", ".env", ".hf-uploader-venv/token", |
| "docs/COM1.txt", "docs/name?.txt"): |
| with self.subTest(path=path): |
| (self.root / uploader.MANIFEST).write_text(json.dumps({path: "0" * 64})) |
| with self.assertRaises(uploader.UploadError): |
| uploader.verify_release(self.root) |
|
|
| def test_symlink_is_rejected_even_inside_release(self): |
| link = self.root / "link.md" |
| try: |
| link.symlink_to(self.root / "README.md") |
| except OSError: |
| self.skipTest("Symlink creation is unavailable on this host") |
| self.write_manifest(["link.md"]) |
| with self.assertRaises(uploader.UploadError): |
| uploader.verify_release(self.root) |
|
|
| def test_duplicate_manifest_keys_are_rejected(self): |
| digest = hashlib.sha256((self.root / "README.md").read_bytes()).hexdigest() |
| (self.root / uploader.MANIFEST).write_text( |
| '{"README.md":"' + digest + '","README.md":"' + digest + '"}') |
| with self.assertRaises(uploader.UploadError): |
| uploader.verify_release(self.root) |
|
|
|
|
| if __name__ == "__main__": |
| unittest.main() |
|
|
