universal-wasm-loader 2.0.0__tar.gz → 2.0.2__tar.gz

{universal_wasm_loader-2.0.0 → universal_wasm_loader-2.0.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: universal-wasm-loader
-Version: 2.0.0
+Version: 2.0.2
 Summary: Universal WASM loader for Python
 Project-URL: Homepage, https://github.com/synapticforge1/universalWasmLoader-py
 Project-URL: Repository, https://github.com/synapticforge1/universalWasmLoader-py

{universal_wasm_loader-2.0.0 → universal_wasm_loader-2.0.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "universal-wasm-loader"
-version = "2.0.0"
+version = "2.0.2"
 description = "Universal WASM loader for Python"
 readme = "README.md"
 license = { text = "MIT" }

universal_wasm_loader-2.0.2/tests/test_github_release.py

@@ -0,0 +1,164 @@
+"""scripts/github_release.py against an in-process mock of GitHub's REST API (no network)."""
+from __future__ import annotations
+
+import importlib.util
+import json
+import sys
+import threading
+from collections.abc import Iterator
+from http.server import BaseHTTPRequestHandler, HTTPServer
+from pathlib import Path
+from types import ModuleType
+from typing import Any
+
+import pytest
+
+SCRIPT = Path(__file__).parent.parent / "scripts" / "github_release.py"
+REPO, TAG, SHA, OTHER = "o/r", "v2.0.2", "a" * 40, "b" * 40
+
+
+def _load() -> ModuleType:
+    spec = importlib.util.spec_from_file_location("github_release", SCRIPT)
+    assert spec is not None and spec.loader is not None
+    mod = importlib.util.module_from_spec(spec)
+    sys.modules["github_release"] = mod
+    spec.loader.exec_module(mod)
+    return mod
+
+
+gr = _load()
+
+
+class Mock:
+    """GitHub state + a log of (method, path, auth, body)."""
+
+    def __init__(self) -> None:
+        self.tags: dict[str, dict[str, str]] = {}  # tag -> ref object
+        self.tag_objects: dict[str, dict[str, str]] = {}  # annotated tag sha -> object
+        self.releases: dict[str, dict[str, Any]] = {}
+        self.log: list[tuple[str, str, str | None, Any]] = []
+        self.post_status = 201
+
+    def writes(self) -> list[tuple[str, str, str | None, Any]]:
+        return [e for e in self.log if e[0] != "GET"]
+
+
+@pytest.fixture
+def mock() -> Iterator[tuple[Mock, str]]:
+    state = Mock()
+
+    class Handler(BaseHTTPRequestHandler):
+        def log_message(self, *_: Any) -> None:
+            pass
+
+        def _send(self, code: int, doc: Any = None) -> None:
+            raw = b"" if doc is None else json.dumps(doc).encode()
+            self.send_response(code)
+            self.send_header("Content-Type", "application/json")
+            self.send_header("Content-Length", str(len(raw)))
+            self.end_headers()
+            self.wfile.write(raw)
+
+        def do_GET(self) -> None:  # noqa: N802
+            state.log.append(("GET", self.path, self.headers.get("Authorization"), None))
+            p = self.path
+            if p.startswith(f"/repos/{REPO}/git/ref/tags/"):
+                obj = state.tags.get(p.rsplit("/", 1)[1])
+                return self._send(200, {"object": obj}) if obj else self._send(404)
+            if p.startswith(f"/repos/{REPO}/git/tags/"):
+                obj = state.tag_objects.get(p.rsplit("/", 1)[1])
+                return self._send(200, {"object": obj}) if obj else self._send(404)
+            if p.startswith(f"/repos/{REPO}/releases/tags/"):
+                rel = state.releases.get(p.rsplit("/", 1)[1])
+                return self._send(200, rel) if rel else self._send(404)
+            self._send(404)
+
+        def do_POST(self) -> None:  # noqa: N802
+            body = json.loads(self.rfile.read(int(self.headers["Content-Length"])))
+            state.log.append(("POST", self.path, self.headers.get("Authorization"), body))
+            if self.path != f"/repos/{REPO}/releases" or state.post_status != 201:
+                return self._send(state.post_status, {"message": "nope"})
+            rel = {"id": 7, "tag_name": body["tag_name"], "draft": False,
+                   "html_url": f"https://example.invalid/{body['tag_name']}"}
+            state.releases[body["tag_name"]] = rel
+            self._send(201, rel)
+
+    server = HTTPServer(("127.0.0.1", 0), Handler)
+    thread = threading.Thread(target=server.serve_forever, daemon=True)
+    thread.start()
+    try:
+        yield state, f"http://127.0.0.1:{server.server_port}"
+    finally:
+        server.shutdown()
+
+
+def _run(base: str, token: str | None = "t0k", dry: bool = False, tag: str = TAG) -> int:
+    return int(gr.run(REPO, tag, SHA, dry, gr.Api(base, token)))
+
+
+def test_creates_the_release_then_reads_it_back(mock: tuple[Mock, str]) -> None:
+    state, base = mock
+    state.tags[TAG] = {"type": "commit", "sha": SHA}
+    assert _run(base) == 0
+    (method, path, auth, body), = state.writes()
+    assert (method, path, auth) == ("POST", f"/repos/{REPO}/releases", "Bearer t0k")
+    assert body["tag_name"] == TAG and body["generate_release_notes"] is True
+    assert "target_commitish" not in body  # the tag already exists; nothing to target
+    assert "pypi.org/project/universal-wasm-loader/2.0.2/" in body["body"]
+    assert state.log[-2][1].endswith(f"/releases/tags/{TAG}")  # read back after the POST
+    assert state.log[-1][1].endswith(f"/git/ref/tags/{TAG}")  # tag re-checked last
+
+
+def test_rerun_is_safe_existing_release_means_done(mock: tuple[Mock, str]) -> None:
+    state, base = mock
+    state.tags[TAG] = {"type": "commit", "sha": SHA}
+    state.releases[TAG] = {"tag_name": TAG, "draft": False, "html_url": "x"}
+    assert _run(base) == 0
+    assert state.writes() == []
+
+
+def test_annotated_tag_is_peeled(mock: tuple[Mock, str]) -> None:
+    state, base = mock
+    state.tags[TAG] = {"type": "tag", "sha": "c" * 40}
+    state.tag_objects["c" * 40] = {"type": "commit", "sha": SHA}
+    assert _run(base) == 0
+    assert len(state.writes()) == 1
+
+
+@pytest.mark.parametrize("case", ["missing tag", "moved tag", "annotated tag moved"])
+def test_refuses_with_no_write(mock: tuple[Mock, str], case: str) -> None:
+    state, base = mock
+    if case == "moved tag":
+        state.tags[TAG] = {"type": "commit", "sha": OTHER}
+    elif case == "annotated tag moved":
+        state.tags[TAG] = {"type": "tag", "sha": "c" * 40}
+        state.tag_objects["c" * 40] = {"type": "commit", "sha": OTHER}
+    assert _run(base) == 1
+    assert state.writes() == []
+
+
+def test_dry_run_and_no_token_send_no_write(mock: tuple[Mock, str]) -> None:
+    state, base = mock
+    state.tags[TAG] = {"type": "commit", "sha": SHA}
+    assert _run(base, dry=True) == 0
+    assert _run(base, token=None) == 1
+    assert state.writes() == []
+
+
+def test_a_failed_post_is_a_failure(
+    mock: tuple[Mock, str], monkeypatch: pytest.MonkeyPatch
+) -> None:
+    state, base = mock
+    state.tags[TAG] = {"type": "commit", "sha": SHA}
+    state.post_status = 422
+    with pytest.raises(gr.ApiError, match="HTTP 422"):
+        _run(base)
+    monkeypatch.setenv("GITHUB_API_URL", base)  # main() must hit the mock, never GitHub
+    monkeypatch.setenv("GITHUB_TOKEN", "t0k")
+    assert gr.main(["--repo", REPO, "--tag", TAG, "--sha", SHA]) == 1  # ApiError -> exit 1
+
+
+def test_malformed_tag_sends_no_request(mock: tuple[Mock, str]) -> None:
+    state, base = mock
+    assert _run(base, tag="main") == 1
+    assert state.log == []

universal_wasm_loader-2.0.2/tests/test_pypi_files.py

@@ -0,0 +1,115 @@
+"""scripts/pypi_files.py: which dist files PyPI still needs (no network: urlopen is stubbed)."""
+from __future__ import annotations
+
+import importlib.util
+import io
+import json
+import sys
+import urllib.error
+from pathlib import Path
+from types import ModuleType
+from typing import Any
+
+import pytest
+
+SCRIPT = Path(__file__).parent.parent / "scripts" / "pypi_files.py"
+PKG, VER = "universal-wasm-loader", "2.0.0"
+WHL, SDIST = "universal_wasm_loader-2.0.0-py3-none-any.whl", "universal_wasm_loader-2.0.0.tar.gz"
+
+
+def _load() -> ModuleType:
+    spec = importlib.util.spec_from_file_location("pypi_files", SCRIPT)
+    assert spec is not None and spec.loader is not None
+    mod = importlib.util.module_from_spec(spec)
+    sys.modules["pypi_files"] = mod
+    spec.loader.exec_module(mod)
+    return mod
+
+
+pf = _load()
+
+
+def test_nothing_on_pypi_uploads_everything() -> None:
+    upload, _ = pf.plan({WHL: "a", SDIST: "b"}, None)
+    assert sorted(upload) == sorted([SDIST, WHL])
+
+
+def test_complete_on_pypi_uploads_nothing() -> None:
+    upload, notes = pf.plan({WHL: "a", SDIST: "b"}, {WHL: "a", SDIST: "b"})
+    assert upload == []
+    assert all("same bytes" in n for n in notes)
+
+
+def test_half_published_uploads_only_the_missing_file() -> None:
+    # The wheel went up, the sdist upload failed: a re-run sends the sdist only.
+    upload, _ = pf.plan({WHL: "a", SDIST: "b"}, {WHL: "a"})
+    assert upload == [SDIST]
+
+
+def test_rebuilt_file_with_other_bytes_is_skipped_not_reuploaded() -> None:
+    upload, notes = pf.plan({WHL: "rebuilt", SDIST: "b"}, {WHL: "first"})
+    assert upload == [SDIST]
+    assert any("DIFFERENT bytes" in n and WHL in n for n in notes)
+
+
+def test_local_files_refuses_another_version(tmp_path: Path) -> None:
+    (tmp_path / WHL).write_bytes(b"w")
+    (tmp_path / "universal_wasm_loader-1.1.1.tar.gz").write_bytes(b"s")
+    with pytest.raises(ValueError, match="not a dist of universal-wasm-loader 2.0.0"):
+        pf.local_files(tmp_path, PKG, VER)
+
+
+def test_local_files_refuses_an_empty_dist(tmp_path: Path) -> None:
+    with pytest.raises(ValueError, match="no dist files"):
+        pf.local_files(tmp_path, PKG, VER)
+
+
+def test_local_files_hashes(tmp_path: Path) -> None:
+    (tmp_path / WHL).write_bytes(b"w")
+    (tmp_path / SDIST).write_bytes(b"s")
+    got = pf.local_files(tmp_path, PKG, VER)
+    assert set(got) == {WHL, SDIST}
+    assert len(got[WHL]) == 64
+
+
+def _http_error(code: int) -> urllib.error.HTTPError:
+    return urllib.error.HTTPError("https://pypi.org/x", code, "x", {}, None)  # type: ignore[arg-type]
+
+
+def test_remote_404_means_no_files(monkeypatch: pytest.MonkeyPatch) -> None:
+    def fake(*_: Any, **__: Any) -> Any:
+        raise _http_error(404)
+
+    monkeypatch.setattr(pf.urllib.request, "urlopen", fake)
+    assert pf.remote_files(PKG, VER) is None
+
+
+@pytest.mark.parametrize("code", [403, 500, 503])
+def test_remote_other_status_is_an_error_never_not_published(
+    monkeypatch: pytest.MonkeyPatch, code: int
+) -> None:
+    def fake(*_: Any, **__: Any) -> Any:
+        raise _http_error(code)
+
+    monkeypatch.setattr(pf.urllib.request, "urlopen", fake)
+    with pytest.raises(pf.PyPIError, match=f"HTTP {code}"):
+        pf.remote_files(PKG, VER)
+
+
+def test_remote_unreachable_is_an_error(monkeypatch: pytest.MonkeyPatch) -> None:
+    def fake(*_: Any, **__: Any) -> Any:
+        raise urllib.error.URLError("no route")
+
+    monkeypatch.setattr(pf.urllib.request, "urlopen", fake)
+    with pytest.raises(pf.PyPIError, match="could not reach PyPI"):
+        pf.remote_files(PKG, VER)
+
+
+def test_remote_200_lists_files(monkeypatch: pytest.MonkeyPatch) -> None:
+    body = {"urls": [{"filename": WHL, "digests": {"sha256": "a"}}]}
+
+    def fake(*_: Any, **__: Any) -> Any:
+        return io.BytesIO(json.dumps(body).encode())
+
+    monkeypatch.setattr(pf.urllib.request, "urlopen", fake)
+    assert pf.remote_files(PKG, VER) == {WHL: "a"}

universal_wasm_loader-2.0.2/tests/test_release_script.py

@@ -0,0 +1,58 @@
+"""scripts/release.py helpers: the ls-remote read-back and the Release-page owner item (H30)."""
+from __future__ import annotations
+
+import importlib.util
+import sys
+import urllib.parse
+from pathlib import Path
+from types import ModuleType
+
+SCRIPTS = Path(__file__).parent.parent / "scripts"
+
+
+def _load() -> ModuleType:
+    if str(SCRIPTS) not in sys.path:
+        sys.path.insert(0, str(SCRIPTS))  # release.py imports _common from its own folder
+    spec = importlib.util.spec_from_file_location("release_script", SCRIPTS / "release.py")
+    assert spec is not None and spec.loader is not None
+    mod = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(mod)
+    return mod
+
+
+rel = _load()
+
+LS_REMOTE = (
+    "21e680a433345a63e653fd920ad113332c8bf1d9\tHEAD\n"
+    "21e680a433345a63e653fd920ad113332c8bf1d9\trefs/heads/main\n"
+    "c41c8b9f0b112e41840f3c6841f80cdb9657d841\trefs/tags/v2.0.0\n"
+    "21e680a433345a63e653fd920ad113332c8bf1d9\trefs/tags/v2.0.0^{}\n"
+)
+
+
+def test_remote_refs_keeps_peeled_tags_apart() -> None:
+    refs = rel.remote_refs(LS_REMOTE)
+    assert refs["refs/heads/main"].startswith("21e680a")
+    assert refs["refs/tags/v2.0.0"].startswith("c41c8b9")  # the annotated tag object
+    assert refs["refs/tags/v2.0.0^{}"].startswith("21e680a")  # the commit it peels to
+
+
+def test_release_page_url_for_each_github_remote_form() -> None:
+    for remote in (
+        "https://github.com/synapticforge1/universalWasmLoader-py.git",
+        "https://github.com/synapticforge1/universalWasmLoader-py",
+        "git@github.com:synapticforge1/universalWasmLoader-py.git",
+        "ssh://git@github.com/synapticforge1/universalWasmLoader-py.git",
+    ):
+        url = rel.release_page_url(remote, "v2.0.1", "notes & more?")
+        assert url is not None, remote
+        base, _, query = url.partition("?")
+        assert base == "https://github.com/synapticforge1/universalWasmLoader-py/releases/new"
+        assert urllib.parse.parse_qs(query) == {
+            "tag": ["v2.0.1"], "title": ["v2.0.1"], "body": ["notes & more?"]
+        }
+
+
+def test_release_page_url_none_for_other_hosts() -> None:
+    assert rel.release_page_url("/tmp/scratch-bare.git", "v1", "x") is None
+    assert rel.release_page_url("https://gitlab.com/a/b.git", "v1", "x") is None