|
| 1 | +"""`@cache` when the backend raises (#228). |
| 2 | +
|
| 3 | +A cache is an optimisation: by default a failing backend makes the route answer |
| 4 | +uncached instead of turning every cached route into a 500. |
| 5 | +""" |
| 6 | + |
| 7 | +import logging |
| 8 | + |
| 9 | +import pytest |
| 10 | +from fastapi import FastAPI |
| 11 | +from fastapi.responses import PlainTextResponse |
| 12 | +from fastapi.testclient import TestClient |
| 13 | + |
| 14 | +from fastapi_cachex import BackendProxy |
| 15 | +from fastapi_cachex import cache |
| 16 | +from fastapi_cachex.backends import MemcachedBackend |
| 17 | +from fastapi_cachex.backends.memory import MemoryBackend |
| 18 | +from fastapi_cachex.types import CacheEntry |
| 19 | +from tests.live_servers import MEMCACHED_SERVER |
| 20 | +from tests.live_servers import requires_memcached |
| 21 | + |
| 22 | + |
| 23 | +class FailingBackend(MemoryBackend): |
| 24 | + """A memory backend whose reads and/or writes raise like a lost connection.""" |
| 25 | + |
| 26 | + def __init__(self, *, fail_get: bool, fail_set: bool) -> None: |
| 27 | + super().__init__() |
| 28 | + self.fail_get = fail_get |
| 29 | + self.fail_set = fail_set |
| 30 | + |
| 31 | + async def get(self, key: str) -> CacheEntry | None: |
| 32 | + if self.fail_get: |
| 33 | + msg = "backend unreachable" |
| 34 | + raise ConnectionError(msg) |
| 35 | + return await super().get(key) |
| 36 | + |
| 37 | + async def set(self, key: str, value: CacheEntry, ttl: int | None = None) -> None: |
| 38 | + if self.fail_set: |
| 39 | + msg = "backend unreachable" |
| 40 | + raise ConnectionError(msg) |
| 41 | + await super().set(key, value, ttl) |
| 42 | + |
| 43 | + |
| 44 | +def _counting_app(*, fail_open: bool = True) -> tuple[FastAPI, list[int]]: |
| 45 | + app = FastAPI() |
| 46 | + calls: list[int] = [] |
| 47 | + |
| 48 | + @app.get("/item") |
| 49 | + @cache(ttl=60, fail_open=fail_open) |
| 50 | + async def item() -> dict[str, int]: |
| 51 | + calls.append(1) |
| 52 | + return {"n": len(calls)} |
| 53 | + |
| 54 | + return app, calls |
| 55 | + |
| 56 | + |
| 57 | +@pytest.mark.parametrize( |
| 58 | + ("fail_get", "fail_set"), |
| 59 | + [(True, False), (False, True), (True, True)], |
| 60 | + ids=["get", "set", "both"], |
| 61 | +) |
| 62 | +def test_failing_backend_serves_the_handler_response( |
| 63 | + caplog: pytest.LogCaptureFixture, *, fail_get: bool, fail_set: bool |
| 64 | +) -> None: |
| 65 | + """A read or write error is logged and the handler's response is served.""" |
| 66 | + BackendProxy.set(FailingBackend(fail_get=fail_get, fail_set=fail_set)) |
| 67 | + app, calls = _counting_app() |
| 68 | + client = TestClient(app) |
| 69 | + |
| 70 | + with caplog.at_level(logging.WARNING, logger="fastapi_cachex.cache"): |
| 71 | + first = client.get("/item") |
| 72 | + second = client.get("/item") |
| 73 | + |
| 74 | + assert first.status_code == 200 |
| 75 | + assert first.json() == {"n": 1} |
| 76 | + assert "ETag" in first.headers |
| 77 | + assert first.headers["Cache-Control"] == "max-age=60" |
| 78 | + assert second.status_code == 200 |
| 79 | + # Nothing could be served from the backend, so the handler ran again. |
| 80 | + assert len(calls) == 2 |
| 81 | + warnings = [r.getMessage() for r in caplog.records if r.levelno == logging.WARNING] |
| 82 | + if fail_get: |
| 83 | + assert any("read failed" in m for m in warnings) |
| 84 | + if fail_set: |
| 85 | + assert any("write failed" in m for m in warnings) |
| 86 | + |
| 87 | + |
| 88 | +def test_a_write_failure_does_not_hide_a_working_read() -> None: |
| 89 | + """Only the failing half is skipped: entries already stored are still served.""" |
| 90 | + backend = FailingBackend(fail_get=False, fail_set=False) |
| 91 | + BackendProxy.set(backend) |
| 92 | + app, calls = _counting_app() |
| 93 | + client = TestClient(app) |
| 94 | + client.get("/item") |
| 95 | + |
| 96 | + backend.fail_set = True |
| 97 | + response = client.get("/item") |
| 98 | + |
| 99 | + assert response.json() == {"n": 1} |
| 100 | + assert len(calls) == 1 |
| 101 | + |
| 102 | + |
| 103 | +@pytest.mark.parametrize( |
| 104 | + ("fail_get", "fail_set"), [(True, False), (False, True)], ids=["get", "set"] |
| 105 | +) |
| 106 | +def test_fail_open_false_propagates_the_error( |
| 107 | + *, fail_get: bool, fail_set: bool |
| 108 | +) -> None: |
| 109 | + """Opting out lets the backend error fail the request.""" |
| 110 | + BackendProxy.set(FailingBackend(fail_get=fail_get, fail_set=fail_set)) |
| 111 | + app, _calls = _counting_app(fail_open=False) |
| 112 | + client = TestClient(app) |
| 113 | + |
| 114 | + with pytest.raises(ConnectionError, match="backend unreachable"): |
| 115 | + client.get("/item") |
| 116 | + |
| 117 | + |
| 118 | +@requires_memcached |
| 119 | +def test_response_over_the_memcached_item_size_is_served_unstored() -> None: |
| 120 | + """Memcached refuses items over 1 MB by default; the route must still answer.""" |
| 121 | + BackendProxy.set(MemcachedBackend(servers=[MEMCACHED_SERVER])) |
| 122 | + app = FastAPI() |
| 123 | + body = "x" * (2 * 1024 * 1024) |
| 124 | + |
| 125 | + @app.get("/large", response_class=PlainTextResponse) |
| 126 | + @cache(ttl=60) |
| 127 | + async def large() -> PlainTextResponse: |
| 128 | + return PlainTextResponse(body) |
| 129 | + |
| 130 | + response = TestClient(app).get("/large") |
| 131 | + |
| 132 | + assert response.status_code == 200 |
| 133 | + assert response.text == body |
0 commit comments