"""Offline tests only: no Hugging Face account or network calls are used.""" import argparse from contextlib import redirect_stdout, redirect_stderr import hashlib import importlib.util import io import json from pathlib import Path import stat import sys import tempfile from types import SimpleNamespace import unittest from unittest.mock import Mock, patch import zipfile SCRIPT = Path(__file__).resolve().parents[1] / "hf_upload.py" spec = importlib.util.spec_from_file_location("ailith_uploader", SCRIPT) uploader = importlib.util.module_from_spec(spec) spec.loader.exec_module(uploader) def make_release(root): root.mkdir(parents=True, exist_ok=True) (root / "README.md").write_text("# AILITH\n", encoding="utf-8") (root / "release_metadata.json").write_text(json.dumps({ "research_version": "0.5.0", "suggested_repository_type": "dataset", "suggested_repository_slug": "AILITH-Beyond-Reinforcement-Learning", }), encoding="utf-8") (root / "paper").mkdir() (root / "paper" / "research.pdf").write_bytes(b"synthetic test data") lines = [] for path in sorted(root.rglob("*")): if path.is_file(): lines.append(f"{hashlib.sha256(path.read_bytes()).hexdigest()} {path.relative_to(root).as_posix()}") (root / "SHA256SUMS").write_text("\n".join(lines) + "\n", encoding="utf-8") return root class HTTPFailure(Exception): def __init__(self, code): self.response = SimpleNamespace(status_code=code) class VerificationTests(unittest.TestCase): def setUp(self): self.temp = tempfile.TemporaryDirectory() self.addCleanup(self.temp.cleanup) self.root = make_release(Path(self.temp.name) / "release") def test_mapping_and_unlisted_local_files(self): (self.root / ".env").write_text("secret test sentinel") (self.root / "unlisted.log").write_text("local") files, metadata = uploader.verify_release(self.root) self.assertEqual(files, ["README.md", "paper/research.pdf", "release_metadata.json", "SHA256SUMS"]) self.assertEqual(metadata["research_version"], "0.5.0") def test_tamper_fails(self): (self.root / "paper" / "research.pdf").write_bytes(b"tampered") with self.assertRaisesRegex(uploader.UploadError, "Checksum mismatch"): uploader.verify_release(self.root) def test_unsafe_manifest_paths_rejected(self): for name in ("../secret", "/absolute", "C:/secret", "paper/../secret", "paper\\secret", "a*.py", ".env", "a/NUL.txt"): with self.subTest(name=name), self.assertRaises(uploader.UploadError): uploader.safe_relative(name) def test_symlink_file_rejected(self): target = Path(self.temp.name) / "outside" target.write_bytes(b"synthetic test data") inside = self.root / "paper" / "research.pdf" inside.unlink() try: inside.symlink_to(target) except OSError: self.skipTest("Symlinks unavailable") with self.assertRaisesRegex(uploader.UploadError, "Symbolic links"): uploader.verify_release(self.root) def test_offline_dry_run_does_not_import_hub(self): with patch.object(uploader, "load_hub", side_effect=AssertionError("network setup forbidden")), redirect_stdout(io.StringIO()) as output: self.assertEqual(uploader.main(["--dry-run", "--folder", str(self.root)]), 0) self.assertIn("Offline dry run passed", output.getvalue()) def test_outer_zip_mapping(self): archive = Path(self.temp.name) / "release.zip" with zipfile.ZipFile(archive, "w") as writer: for path in self.root.rglob("*"): if path.is_file(): writer.write(path, "outer/release/" + path.relative_to(self.root).as_posix()) with uploader.release_source(archive) as folder: files, _ = uploader.verify_release(folder) self.assertIn("paper/research.pdf", files) def test_zip_traversal_symlink_duplicate_and_size_rejected(self): for mode in ("traversal", "symlink", "duplicate", "bomb"): archive = Path(self.temp.name) / f"{mode}.zip" with zipfile.ZipFile(archive, "w") as writer: if mode == "traversal": writer.writestr("../escape.txt", "bad") elif mode == "symlink": item = zipfile.ZipInfo("link") item.create_system = 3 item.external_attr = (stat.S_IFLNK | 0o777) << 16 writer.writestr(item, "target") elif mode == "duplicate": writer.writestr("file", "a") writer.writestr("FILE", "b") else: writer.writestr("a", "abc") with tempfile.TemporaryDirectory() as destination: limit = 1 if mode == "bomb" else uploader.MAX_BYTES with patch.object(uploader, "MAX_BYTES", limit), self.assertRaises(uploader.UploadError): uploader.extract_zip(archive, Path(destination)) class RepositoryTests(unittest.TestCase): def test_supported_names_and_urls(self): self.assertEqual(uploader.parse_repo("Research", "maciej"), "maciej/Research") self.assertEqual(uploader.parse_repo("team/Research"), "team/Research") self.assertEqual(uploader.parse_repo("https://huggingface.co/datasets/team/Research/"), "team/Research") def test_wrong_or_unsafe_repo_rejected(self): for value in ("https://evil.example/datasets/a/b", "https://huggingface.co/a/b", "a/b/c", "a/../b", "a/b--c", "a/b.git", "https://huggingface.co/datasets/a/b?token=x"): with self.subTest(value=value), self.assertRaises(uploader.UploadError): uploader.parse_repo(value) def test_authentication_denied_is_not_retried(self): call = Mock(side_effect=HTTPFailure(403)) with self.assertRaises(HTTPFailure): uploader.retry(call, sleep=Mock()) self.assertEqual(call.call_count, 1) def test_transient_retry(self): operation = Mock(side_effect=[HTTPFailure(429), HTTPFailure(503), "ok"]) sleep = Mock() self.assertEqual(uploader.retry(operation, sleep=sleep), "ok") self.assertEqual(operation.call_count, 3) self.assertEqual(sleep.call_count, 2) def test_invalid_cached_login_uses_standard_login(self): first, second, login = Mock(), Mock(), Mock() first.whoami.side_effect = HTTPFailure(401) second.whoami.return_value = {"name": "maciej"} factory = Mock(side_effect=[first, second]) api, name = uploader.authenticate(factory, login) self.assertIs(api, second) self.assertEqual(name, "maciej") login.assert_called_once_with(skip_if_logged_in=False) def test_forbidden_login_does_not_reprompt(self): api, login = Mock(), Mock() api.whoami.side_effect = HTTPFailure(403) with self.assertRaises(HTTPFailure): uploader.authenticate(Mock(return_value=api), login) login.assert_not_called() class PublishingTests(unittest.TestCase): def setUp(self): self.temp = tempfile.TemporaryDirectory() self.addCleanup(self.temp.cleanup) self.root = make_release(Path(self.temp.name) / "release") self.files, self.metadata = uploader.verify_release(self.root) self.api = Mock() self.api.repo_info.return_value = SimpleNamespace(private=True) self.args = argparse.Namespace(repo="owner/Research", visibility="public", yes=True) def upload_and_capture(self, **kwargs): self.upload_kwargs = kwargs self.staged_paths = sorted(p.relative_to(kwargs["folder_path"]).as_posix() for p in Path(kwargs["folder_path"]).rglob("*") if p.is_file()) self.assertEqual(uploader.verify_release(Path(kwargs["folder_path"]))[0], self.files) return SimpleNamespace(commit_url="https://huggingface.co/datasets/owner/Research/commit/test") def test_exact_payload_no_deletions_existing_visibility_preserved(self): (self.root / ".env").write_text("synthetic private sentinel") self.api.upload_folder.side_effect = self.upload_and_capture uploader.publish(self.root, self.files, self.metadata, self.args, self.api, "user") self.api.create_repo.assert_not_called() self.assertEqual(self.upload_kwargs["allow_patterns"], self.files) self.assertNotIn("delete_patterns", self.upload_kwargs) self.assertNotIn(".env", self.staged_paths) self.assertEqual(sorted(self.files), self.staged_paths) self.assertEqual(self.upload_kwargs["path_in_repo"], "") self.api.update_repo_settings.assert_not_called() def test_new_creation_is_non_destructive_and_visibility_explicit(self): self.api.repo_info.side_effect = [HTTPFailure(404), SimpleNamespace(private=False)] self.api.upload_folder.side_effect = self.upload_and_capture uploader.publish(self.root, self.files, self.metadata, self.args, self.api, "user") self.api.create_repo.assert_called_once_with(repo_id="owner/Research", repo_type="dataset", exist_ok=True, private=False) self.api.update_repo_settings.assert_not_called() def test_creation_race_visibility_mismatch_aborts_upload(self): self.args.visibility = "private" self.api.repo_info.side_effect = [HTTPFailure(404), SimpleNamespace(private=False)] with self.assertRaisesRegex(uploader.UploadError, "actually public"): uploader.publish(self.root, self.files, self.metadata, self.args, self.api, "user") self.api.upload_folder.assert_not_called() self.api.update_repo_settings.assert_not_called() def test_ambiguous_404_without_visibility_cannot_use_yes(self): self.api.repo_info.side_effect = HTTPFailure(404) self.args.visibility = None with self.assertRaisesRegex(uploader.UploadError, "requires --visibility"): uploader.publish(self.root, self.files, self.metadata, self.args, self.api, "user") self.api.create_repo.assert_not_called() self.api.upload_folder.assert_not_called() def test_cancel_has_no_remote_mutation(self): self.args.yes = False result = uploader.publish(self.root, self.files, self.metadata, self.args, self.api, "user", prompt=lambda _: "n") self.assertIsNone(result) self.api.create_repo.assert_not_called() self.api.upload_folder.assert_not_called() def test_denied_repo_is_not_treated_as_missing(self): self.api.repo_info.side_effect = HTTPFailure(403) with self.assertRaises(HTTPFailure): uploader.publish(self.root, self.files, self.metadata, self.args, self.api, "user") self.api.create_repo.assert_not_called() self.api.upload_folder.assert_not_called() if __name__ == "__main__": unittest.main()