Download backend/app/tests/test_startup_integrity.py from apoorvrajdev/image-captioning-api: direct link, hf CLI and curl.
- Browser
- Download file 5.46 kB
-
https://huggingface.co/spaces/apoorvrajdev/image-captioning-api/resolve/main/backend/app/tests/test_startup_integrity.py
- Command line
-
hf download hf://spaces/apoorvrajdev/image-captioning-api/backend/app/tests/test_startup_integrity.py
-
curl -L -o test_startup_integrity.py https://huggingface.co/spaces/apoorvrajdev/image-captioning-api/resolve/main/backend/app/tests/test_startup_integrity.py
5.46 kB
| """Startup never hands an unverified file to the model or tokenizer loader (TASK-029). | |
| These tests run the real ``lifespan`` and the real ``resolve_weights`` with its | |
| default downloader. Only ``huggingface_hub.snapshot_download`` (no network) and | |
| ``CaptionPredictor`` (no TensorFlow) are replaced. The stand-in predictor reads | |
| the files the way the real one does: the vocabulary through ``read_vocabulary``, | |
| which ``CaptionTokenizer.load`` calls first, and the weights file's bytes. | |
| Importing ``app.main`` stays TensorFlow-free only while ``captioning.inference`` | |
| imports TensorFlow inside functions. If that changes, move this module to | |
| ``tests/unit`` so the backend suite stays TensorFlow-free. | |
| """ | |
| from __future__ import annotations | |
| import hashlib | |
| import json | |
| from pathlib import Path | |
| from typing import Any, ClassVar | |
| import anyio | |
| import huggingface_hub | |
| import pytest | |
| from fastapi import FastAPI | |
| import app.main as app_main | |
| from app.core.config import BackendSettings | |
| from app.services.weights_loader import PINNED_ARTIFACT_SHA256, ArtifactIntegrityError | |
| from captioning.config.schema import AppConfig | |
| from captioning.preprocessing.tokenizer import read_vocabulary | |
| REPO = "user/captioning-weights" | |
| COMMIT = "0123456789abcdef0123456789abcdef01234567" | |
| UNPINNED_COMMIT = "fedcba9876543210fedcba9876543210fedcba98" | |
| WEIGHTS = b"\x89HDF\r\n\x1a\nfake weights" | |
| VOCAB = ["", "[UNK]", "a", "dog", "on", "grass"] | |
| class RecordingPredictor: | |
| """Stands in for ``CaptionPredictor``; records every file it consumes.""" | |
| consumed: ClassVar[list[str]] = [] | |
| vocabulary: ClassVar[list[str]] = [] | |
| def from_artifacts( | |
| cls, *, weights_path: Path, tokenizer_dir: Path, config: AppConfig | |
| ) -> RecordingPredictor: | |
| cls.vocabulary = read_vocabulary(tokenizer_dir, config.model.vocabulary_size) | |
| cls.consumed.append("vocab.json") | |
| Path(weights_path).read_bytes() | |
| cls.consumed.append(Path(weights_path).name) | |
| return cls() | |
| def warmup(self) -> None: | |
| pass | |
| def snapshot(tmp_path: Path, monkeypatch: pytest.MonkeyPatch) -> Path: | |
| """A snapshot holding the pinned bytes, served by a no-network downloader.""" | |
| directory = tmp_path / "snapshots" / COMMIT | |
| directory.mkdir(parents=True) | |
| vocab_bytes = json.dumps(VOCAB).encode() | |
| (directory / "model.h5").write_bytes(WEIGHTS) | |
| (directory / "vocab.json").write_bytes(vocab_bytes) | |
| monkeypatch.setitem( | |
| PINNED_ARTIFACT_SHA256, | |
| (REPO, COMMIT), | |
| { | |
| "model.h5": hashlib.sha256(WEIGHTS).hexdigest(), | |
| "vocab.json": hashlib.sha256(vocab_bytes).hexdigest(), | |
| }, | |
| ) | |
| return directory | |
| def downloads(snapshot: Path, monkeypatch: pytest.MonkeyPatch) -> list[dict[str, Any]]: | |
| calls: list[dict[str, Any]] = [] | |
| def fake_snapshot_download(**kwargs: Any) -> str: | |
| calls.append(kwargs) | |
| return str(snapshot) | |
| monkeypatch.setattr(huggingface_hub, "snapshot_download", fake_snapshot_download) | |
| monkeypatch.setattr(app_main, "CaptionPredictor", RecordingPredictor) | |
| monkeypatch.setattr(RecordingPredictor, "consumed", []) | |
| monkeypatch.setattr(RecordingPredictor, "vocabulary", []) | |
| return calls | |
| def _start(revision: str = COMMIT) -> FastAPI: | |
| """Run the lifespan's startup and shutdown; return the app as it was while serving.""" | |
| app = FastAPI() | |
| app.state.backend_settings = BackendSettings( | |
| weights_hub_repo=REPO, weights_hub_revision=revision, warmup=True | |
| ) | |
| app.state.app_config = AppConfig() | |
| app.state.predictor_service = None | |
| seen: dict[str, Any] = {} | |
| async def run() -> None: | |
| async with app_main.lifespan(app): | |
| seen["service"] = app.state.predictor_service | |
| anyio.run(run) | |
| app.state.seen_service = seen["service"] | |
| return app | |
| def test_verified_files_load(downloads: list[dict[str, Any]]) -> None: | |
| app = _start() | |
| assert app.state.seen_service is not None | |
| assert RecordingPredictor.vocabulary == VOCAB | |
| assert RecordingPredictor.consumed == ["vocab.json", "model.h5"] | |
| assert [call["allow_patterns"] for call in downloads] == [["model.h5", "vocab.json"]] | |
| assert [call["revision"] for call in downloads] == [COMMIT] | |
| def test_a_tampered_weights_file_stops_startup_before_the_model_loads( | |
| snapshot: Path, downloads: list[dict[str, Any]] | |
| ) -> None: | |
| (snapshot / "model.h5").write_bytes(WEIGHTS + b"\x00") | |
| with pytest.raises(ArtifactIntegrityError, match="model.h5 has SHA-256"): | |
| _start() | |
| assert RecordingPredictor.consumed == [] | |
| def test_a_tampered_vocabulary_is_never_read_even_when_it_would_validate( | |
| snapshot: Path, downloads: list[dict[str, Any]] | |
| ) -> None: | |
| """Swapping two tokens keeps the list valid but shifts token ids.""" | |
| swapped = VOCAB[:2] + [VOCAB[3], VOCAB[2]] + VOCAB[4:] | |
| (snapshot / "vocab.json").write_bytes(json.dumps(swapped).encode()) | |
| assert read_vocabulary(snapshot, AppConfig().model.vocabulary_size) == swapped | |
| with pytest.raises(ArtifactIntegrityError, match="vocab.json has SHA-256"): | |
| _start() | |
| assert RecordingPredictor.consumed == [] | |
| def test_an_unpinned_commit_stops_startup_before_any_download( | |
| downloads: list[dict[str, Any]], | |
| ) -> None: | |
| with pytest.raises(ValueError, match="has no SHA-256 digests"): | |
| _start(UNPINNED_COMMIT) | |
| assert downloads == [] | |
| assert RecordingPredictor.consumed == [] | |