File size: 11,035 Bytes
2861100 | 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 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 | """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()
|