Parth
e7d75c3b05
* Rewrite comments in Google developer documentation style Rewrite the comments and docstrings across the backend core modules so they read plainly. The previous prose was accurate but dense and figurative, which made it slow to skim. Applies the Google developer documentation style guide: short sentences, active voice, present tense, American spelling, and no metaphors, idioms, or rhetorical asides. Replaces em-dash chains with separate sentences.
244 lines
8.1 KiB
Python
244 lines
8.1 KiB
Python
"""Opening an adventure fetches a window, not the whole story.
|
|
|
|
A story only ever gets longer. Production's longest is 607 actions and
|
|
589.5 kB in one response, and that number never decreases on its own. The
|
|
page load returns the newest `ACTION_PAGE` window, and the reader pages
|
|
upward from there.
|
|
|
|
The paging anchors on an action id rather than an offset, and these tests
|
|
cover why. An offset counted back from the newest shifts every older
|
|
position the moment a turn lands, which is exactly when a reader is likely
|
|
to be scrolling. An anchor means the same thing before and after.
|
|
|
|
python -m pytest tests/test_action_paging.py -v
|
|
"""
|
|
import os
|
|
import tempfile
|
|
|
|
_tmp = tempfile.NamedTemporaryFile(suffix=".db", delete=False)
|
|
_tmp.close()
|
|
os.environ["AIDND_DB_PATH"] = _tmp.name
|
|
os.environ.pop("AIDND_DATABASE_URL", None)
|
|
os.environ.pop("DATABASE_URL", None)
|
|
|
|
import pytest
|
|
from fastapi import Depends
|
|
from fastapi.testclient import TestClient
|
|
|
|
from app import auth, limits, models
|
|
from app.database import Base, SessionLocal, engine, get_db
|
|
from app.main import app
|
|
from app.routers.adventures import ACTION_PAGE
|
|
from tools import dbmeter
|
|
|
|
TOTAL = ACTION_PAGE * 3 + 7 # deliberately not a whole number of pages
|
|
|
|
|
|
@pytest.fixture()
|
|
def client(monkeypatch):
|
|
Base.metadata.create_all(bind=engine)
|
|
setup = SessionLocal()
|
|
user = models.User(is_guest=False, email="paging@example.com")
|
|
setup.add(user)
|
|
setup.flush()
|
|
setup.add(models.Settings(user_id=user.id, api_key="enc:dummy", model="m"))
|
|
adventure = models.Adventure(user_id=user.id, title="Cave", script_state={})
|
|
setup.add(adventure)
|
|
setup.flush()
|
|
for i in range(TOTAL):
|
|
setup.add(models.Action(
|
|
adventure_id=adventure.id, index=i,
|
|
type="start" if i == 0 else ("ai" if i % 2 else "do"),
|
|
text=f"Action {i}." + "word " * 200,
|
|
))
|
|
setup.commit()
|
|
adv_id, user_id = adventure.id, user.id
|
|
setup.close()
|
|
|
|
monkeypatch.setattr(limits, "rate_limit", lambda *a, **k: None)
|
|
monkeypatch.setattr(limits, "check_row_cap", lambda *a, **k: None)
|
|
|
|
def _current_user(db=Depends(get_db)):
|
|
return db.get(models.User, user_id)
|
|
|
|
app.dependency_overrides[auth.get_current_user] = _current_user
|
|
c = TestClient(app)
|
|
c.adv_id = adv_id
|
|
try:
|
|
yield c
|
|
finally:
|
|
app.dependency_overrides.clear()
|
|
Base.metadata.drop_all(bind=engine)
|
|
|
|
|
|
def page(client, before_id=None, limit=None):
|
|
params = {}
|
|
if before_id is not None:
|
|
params["before_id"] = before_id
|
|
if limit is not None:
|
|
params["limit"] = limit
|
|
r = client.get(f"/api/adventures/{client.adv_id}/actions", params=params)
|
|
assert r.status_code == 200, r.text
|
|
return r.json()
|
|
|
|
|
|
def add_action(client, text="A new turn.") -> int:
|
|
db = SessionLocal()
|
|
try:
|
|
highest = db.query(models.Action.index).order_by(
|
|
models.Action.index.desc()).first()[0]
|
|
action = models.Action(
|
|
adventure_id=client.adv_id, index=highest + 1, type="ai", text=text
|
|
)
|
|
db.add(action)
|
|
db.commit()
|
|
return action.id
|
|
finally:
|
|
db.close()
|
|
|
|
|
|
# ------------------------------------------------------------- the page load
|
|
|
|
def test_the_page_load_returns_only_the_newest_window(client):
|
|
r = client.get(f"/api/adventures/{client.adv_id}")
|
|
assert r.status_code == 200
|
|
body = r.json()
|
|
assert len(body["actions"]) == ACTION_PAGE
|
|
assert body["action_count"] == TOTAL
|
|
# It is the newest window, ending on the last action.
|
|
assert body["actions"][-1]["index"] == TOTAL - 1
|
|
assert body["actions"][0]["index"] == TOTAL - ACTION_PAGE
|
|
|
|
|
|
def test_a_short_story_is_returned_whole(client):
|
|
db = SessionLocal()
|
|
try:
|
|
db.query(models.Action).filter(models.Action.index >= 5).delete()
|
|
db.commit()
|
|
finally:
|
|
db.close()
|
|
|
|
body = client.get(f"/api/adventures/{client.adv_id}").json()
|
|
assert len(body["actions"]) == 5
|
|
assert body["action_count"] == 5
|
|
|
|
|
|
def test_the_page_load_does_not_grow_with_the_story(client):
|
|
"""Confirm that opening a story costs a window, regardless of the
|
|
story's length."""
|
|
meter = dbmeter.Meter()
|
|
meter.attach(engine)
|
|
try:
|
|
with meter.scope("page load"):
|
|
client.get(f"/api/adventures/{client.adv_id}")
|
|
windowed = meter.scopes[-1].total.fetched
|
|
finally:
|
|
meter.detach()
|
|
|
|
# Each action carries about 1 KB of text, and there are 187 of them. A
|
|
# window holds 60 actions. This ceiling is generous but still far below
|
|
# the size of the whole story.
|
|
assert windowed < ACTION_PAGE * 2_000, f"{windowed:,} B for one window"
|
|
assert windowed < TOTAL * 500, (
|
|
f"{windowed:,} B — that is the whole story, not a window"
|
|
)
|
|
|
|
|
|
# ------------------------------------------------------------------ paging up
|
|
|
|
def test_the_first_page_is_the_newest(client):
|
|
body = page(client)
|
|
assert len(body["actions"]) == ACTION_PAGE
|
|
assert body["total"] == TOTAL
|
|
assert body["has_more"] is True
|
|
assert body["actions"][-1]["index"] == TOTAL - 1
|
|
|
|
|
|
def test_paging_up_covers_the_whole_story_exactly_once(client):
|
|
seen = []
|
|
body = page(client)
|
|
seen = [a["index"] for a in body["actions"]]
|
|
guard = 0
|
|
while body["has_more"]:
|
|
guard += 1
|
|
assert guard < 20, "paging did not terminate"
|
|
body = page(client, before_id=body["actions"][0]["id"])
|
|
seen = [a["index"] for a in body["actions"]] + seen
|
|
|
|
assert seen == list(range(TOTAL)), "gap, duplicate or reordering while paging"
|
|
|
|
|
|
def test_has_more_is_false_at_the_beginning_of_the_story(client):
|
|
body = page(client)
|
|
while body["has_more"]:
|
|
body = page(client, before_id=body["actions"][0]["id"])
|
|
assert body["actions"][0]["index"] == 0
|
|
|
|
|
|
def test_each_page_is_ordered_oldest_first(client):
|
|
body = page(client)
|
|
indices = [a["index"] for a in body["actions"]]
|
|
assert indices == sorted(indices)
|
|
|
|
|
|
# ------------------------------------------------- the reason for the anchor
|
|
|
|
def test_a_turn_arriving_mid_scroll_does_not_shift_the_next_page(client):
|
|
"""Reproduce the failure an offset-based scheme would have. Read the
|
|
newest page, let a turn land, then page up. The reader must get exactly
|
|
what precedes the actions they already hold, with no duplicate and no
|
|
skipped action."""
|
|
first = page(client)
|
|
oldest_held = first["actions"][0]
|
|
|
|
add_action(client)
|
|
|
|
older = page(client, before_id=oldest_held["id"])
|
|
assert older["actions"][-1]["index"] == oldest_held["index"] - 1, \
|
|
"the page shifted when a turn landed"
|
|
assert all(a["index"] < oldest_held["index"] for a in older["actions"])
|
|
# The new turn changes the total, which is expected. It must not move the window.
|
|
assert older["total"] == TOTAL + 1
|
|
|
|
|
|
def test_a_deleted_anchor_reports_the_end_rather_than_a_duplicate_page(client):
|
|
"""Undo can remove the action a slow scroll was anchored to. The endpoint
|
|
must stop instead of returning a page the reader already has."""
|
|
body = page(client)
|
|
anchor = body["actions"][0]
|
|
|
|
db = SessionLocal()
|
|
try:
|
|
db.query(models.Action).filter(models.Action.id == anchor["id"]).delete()
|
|
db.commit()
|
|
finally:
|
|
db.close()
|
|
|
|
after = page(client, before_id=anchor["id"])
|
|
assert after["actions"] == []
|
|
assert after["has_more"] is False
|
|
|
|
|
|
# ------------------------------------------------------------------- limits
|
|
|
|
def test_limit_is_honoured_and_capped(client):
|
|
assert len(page(client, limit=5)["actions"]) == 5
|
|
# A client that asks for the whole story cannot bypass the paging cap.
|
|
assert len(page(client, limit=100_000)["actions"]) <= ACTION_PAGE * 4
|
|
|
|
|
|
def test_a_nonsense_limit_still_returns_something(client):
|
|
assert len(page(client, limit=0)["actions"]) >= 1
|
|
assert len(page(client, limit=-5)["actions"]) >= 1
|
|
|
|
|
|
# --------------------------------------------------------------------- undo
|
|
|
|
def test_undo_returns_a_window_not_the_story(client):
|
|
r = client.post(f"/api/adventures/{client.adv_id}/undo")
|
|
assert r.status_code == 200, r.text
|
|
body = r.json()
|
|
assert len(body["actions"]) == ACTION_PAGE
|
|
assert body["total"] == TOTAL - 1
|
|
assert body["has_more"] is True
|