"""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()