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