peter
c5f121139b
A season marked watched, a pull from Plex and a YouTube resume point made their first row by a read then an add, and failed on the unique key when a first checkpoint or the watched mark made it in between. They go through the same insert-then-read as the checkpoint (the resume point is one upsert); a pull that meets a local change still waiting for its push leaves it. Folding duplicate Watch later lists moved their videos but not a Home pin, which the cascade then deleted; the first pin of a dropped copy moves onto the kept list. Marking one notice read trimmed before its own flag was flushed, so the trim left one past the cap. The route test now crosses the cap and reads the result from a session of its own.
384 lines
14 KiB
Python
384 lines
14 KiB
Python
"""Writes driven through HTTP, each read back: the handler called its unit and committed.
|
|
|
|
A route's helper only flushes; the handler commits. The `db` fixture fails a test whose request left
|
|
a write uncommitted, so every test here drives one successful write through its route and then
|
|
reads the result back. The read-back holds that the handler called its unit; it runs in the
|
|
request's own session, so it sees a write that was never committed — the commit is the fixture's
|
|
to hold (a test that must see it committed reads from a session of its own). The services' own
|
|
tests hold what each write does; these hold that the route finishes it. Nothing here reaches
|
|
YouTube or Plex: the YouTube client is a stub and no user has a Plex link. Needs the DB.
|
|
"""
|
|
|
|
from datetime import datetime, timedelta, timezone
|
|
|
|
import pytest
|
|
from sqlalchemy import select
|
|
|
|
from app import quota
|
|
from app.auth import require_write_scope
|
|
from app.catalog.models import Channel, ExploredChannel, SearchFind, Subscription, Video
|
|
from app.downloads.models import DownloadJob, DownloadProfile, DownloadShare
|
|
from app.plex.models import PlexItem, PlexLibrary, PlexSeason, PlexShow, PlexState
|
|
from app.db import SessionLocal
|
|
from app.models import Notification
|
|
from app.notifications import READ_SOFT_CAP
|
|
from app.reader.models import SavedView, Tag, VideoState
|
|
from app.routes import channels
|
|
|
|
NOW = datetime.now(timezone.utc)
|
|
|
|
|
|
def _video(db, vid="v1", **kw):
|
|
if db.get(Channel, "UCr") is None:
|
|
db.add(Channel(id="UCr", title="R"))
|
|
db.flush()
|
|
db.add(Video(id=vid, channel_id="UCr", published_at=NOW, duration_seconds=60, **kw))
|
|
db.commit()
|
|
|
|
|
|
# --- tags ------------------------------------------------------------------------------------
|
|
|
|
|
|
def test_a_tag_made_through_the_route_is_listed_back(db, make_user, as_user):
|
|
user = make_user()
|
|
client = as_user(user)
|
|
r = client.post("/api/tags", json={"name": "Science"})
|
|
assert r.status_code == 200, r.text
|
|
assert [t["name"] for t in client.get("/api/tags").json()] == ["Science"]
|
|
|
|
|
|
def test_a_tag_renamed_through_the_route_is_listed_back(db, make_user, as_user):
|
|
user = make_user()
|
|
tag = Tag(user_id=user.id, name="Old")
|
|
db.add(tag)
|
|
db.commit()
|
|
client = as_user(user)
|
|
assert client.patch(f"/api/tags/{tag.id}", json={"name": "New"}).status_code == 200
|
|
assert [t["name"] for t in client.get("/api/tags").json()] == ["New"]
|
|
|
|
|
|
def test_a_tag_deleted_through_the_route_is_gone(db, make_user, as_user):
|
|
user = make_user()
|
|
tag = Tag(user_id=user.id, name="Gone")
|
|
db.add(tag)
|
|
db.commit()
|
|
client = as_user(user)
|
|
assert client.delete(f"/api/tags/{tag.id}").json() == {"deleted": tag.id}
|
|
assert client.get("/api/tags").json() == []
|
|
|
|
|
|
# --- watch state ------------------------------------------------------------------------------
|
|
|
|
|
|
def _state(db, user, vid="v1"):
|
|
db.expire_all()
|
|
return db.execute(
|
|
select(VideoState).where(VideoState.user_id == user.id, VideoState.video_id == vid)
|
|
).scalar_one_or_none()
|
|
|
|
|
|
def test_a_video_marked_watched_through_the_route_stays_watched(db, make_user, as_user):
|
|
user = make_user()
|
|
_video(db)
|
|
r = as_user(user).post("/api/videos/v1/state", json={"status": "watched"})
|
|
assert r.status_code == 200, r.text
|
|
assert _state(db, user).status == "watched"
|
|
|
|
|
|
def test_a_video_unmarked_through_the_route_stays_unmarked(db, make_user, as_user):
|
|
# "new" is its own branch of the handler, with its own commit.
|
|
user = make_user()
|
|
_video(db)
|
|
db.add(VideoState(user_id=user.id, video_id="v1", status="watched"))
|
|
db.commit()
|
|
r = as_user(user).post("/api/videos/v1/state", json={"status": "new"})
|
|
assert r.status_code == 200, r.text
|
|
assert _state(db, user) is None
|
|
|
|
|
|
def test_a_video_state_cleared_through_the_route_is_gone(db, make_user, as_user):
|
|
user = make_user()
|
|
_video(db)
|
|
db.add(VideoState(user_id=user.id, video_id="v1", status="hidden", position_seconds=90))
|
|
db.commit()
|
|
assert as_user(user).delete("/api/videos/v1/state").status_code == 200
|
|
assert _state(db, user) is None
|
|
|
|
|
|
# --- saved views ------------------------------------------------------------------------------
|
|
|
|
|
|
def test_views_reordered_through_the_route_list_back_in_that_order(db, make_user, as_user):
|
|
user = make_user()
|
|
a = SavedView(user_id=user.id, source="feed", name="A", filters={}, position=0)
|
|
b = SavedView(user_id=user.id, source="feed", name="B", filters={}, position=1)
|
|
db.add_all([a, b])
|
|
db.commit()
|
|
client = as_user(user)
|
|
assert client.post("/api/saved-views/reorder", json={"ids": [b.id, a.id]}).status_code == 200
|
|
listed = client.get("/api/saved-views").json()
|
|
assert [(v["name"], v["position"]) for v in listed] == [("B", 0), ("A", 1)]
|
|
|
|
|
|
# --- download profiles and shares -------------------------------------------------------------
|
|
|
|
_SPEC = {"format": "best"}
|
|
|
|
|
|
def _profile(db, user, name="Mine"):
|
|
p = DownloadProfile(user_id=user.id, name=name, spec=_SPEC, is_builtin=False, sort_order=101)
|
|
db.add(p)
|
|
db.commit()
|
|
return p
|
|
|
|
|
|
def _profile_names(client):
|
|
return [p["name"] for p in client.get("/api/downloads/profiles").json()]
|
|
|
|
|
|
def test_a_profile_made_through_the_route_is_listed_back(db, make_user, as_user):
|
|
user = make_user()
|
|
client = as_user(user)
|
|
r = client.post("/api/downloads/profiles", json={"name": "Phone", "spec": _SPEC})
|
|
assert r.status_code == 200, r.text
|
|
assert _profile_names(client) == ["Phone"]
|
|
|
|
|
|
def test_a_profile_renamed_through_the_route_is_listed_back(db, make_user, as_user):
|
|
user = make_user()
|
|
p = _profile(db, user)
|
|
client = as_user(user)
|
|
r = client.patch(f"/api/downloads/profiles/{p.id}", json={"name": "Renamed"})
|
|
assert r.status_code == 200, r.text
|
|
assert _profile_names(client) == ["Renamed"]
|
|
|
|
|
|
def test_a_profile_deleted_through_the_route_is_gone(db, make_user, as_user):
|
|
user = make_user()
|
|
p = _profile(db, user)
|
|
client = as_user(user)
|
|
assert client.delete(f"/api/downloads/profiles/{p.id}").json() == {"deleted": p.id}
|
|
assert _profile_names(client) == []
|
|
|
|
|
|
def test_a_share_taken_back_through_the_route_is_gone(db, make_user, as_user):
|
|
owner, friend = make_user(), make_user()
|
|
job = DownloadJob(
|
|
user_id=owner.id, source_kind="youtube", source_ref="dQw4w9WgXcQ", profile_snapshot={}
|
|
)
|
|
db.add(job)
|
|
db.flush()
|
|
db.add(DownloadShare(job_id=job.id, from_user_id=owner.id, to_user_id=friend.id))
|
|
db.commit()
|
|
r = as_user(owner).delete(f"/api/downloads/{job.id}/share/{friend.email}")
|
|
assert r.json() == {"ok": True}
|
|
db.expire_all()
|
|
assert db.execute(select(DownloadShare)).first() is None
|
|
|
|
|
|
# --- channels ---------------------------------------------------------------------------------
|
|
|
|
|
|
class _YouTube:
|
|
"""The YouTube client, answering every write the channel routes make."""
|
|
|
|
def __init__(self, db, user):
|
|
pass
|
|
|
|
def __enter__(self):
|
|
return self
|
|
|
|
def __exit__(self, *exc):
|
|
return False
|
|
|
|
def insert_subscription(self, channel_id):
|
|
return "yt-sub-1"
|
|
|
|
def delete_subscription(self, sub_id):
|
|
return None
|
|
|
|
def get_channels(self, ids):
|
|
return []
|
|
|
|
|
|
@pytest.fixture
|
|
def youtube(monkeypatch):
|
|
monkeypatch.setattr(channels, "YouTubeClient", _YouTube)
|
|
monkeypatch.setattr(quota, "backfill_reserve_reached", lambda: False)
|
|
|
|
|
|
def _channel(db, cid="UCc", **kw):
|
|
ch = Channel(id=cid, title="C", details_synced_at=NOW, **kw)
|
|
db.add(ch)
|
|
db.commit()
|
|
return ch
|
|
|
|
|
|
def _subscription(db, user, cid="UCc"):
|
|
db.expire_all()
|
|
return db.execute(
|
|
select(Subscription).where(Subscription.user_id == user.id, Subscription.channel_id == cid)
|
|
).scalar_one_or_none()
|
|
|
|
|
|
def test_a_subscribe_through_the_route_is_recorded(db, make_user, as_user, override_dep, youtube):
|
|
user = make_user()
|
|
_channel(db)
|
|
client = as_user(user)
|
|
override_dep(require_write_scope, lambda: user)
|
|
assert client.post("/api/channels/UCc/subscribe").json() == {"ok": True, "subscribed": "UCc"}
|
|
assert _subscription(db, user).yt_subscription_id == "yt-sub-1"
|
|
|
|
|
|
def test_an_explore_through_the_route_is_recorded(db, make_user, as_user, youtube, monkeypatch):
|
|
user = make_user()
|
|
_channel(db)
|
|
# The ingest pages YouTube; what the route itself records is the exploration.
|
|
monkeypatch.setattr(channels, "details_stale", lambda ch, now: False)
|
|
monkeypatch.setattr(
|
|
channels,
|
|
"explore_ingest_page",
|
|
lambda db, yt, ch, token: {"ingested": 0, "next_page_token": None},
|
|
)
|
|
r = as_user(user).post("/api/channels/UCc/explore")
|
|
assert r.status_code == 200, r.text
|
|
db.expire_all()
|
|
assert db.execute(select(ExploredChannel.user_id)).scalars().all() == [user.id]
|
|
assert db.get(Channel, "UCc").from_explore is True
|
|
|
|
|
|
def test_an_unsubscribe_through_the_route_drops_the_subscription(
|
|
db, make_user, as_user, override_dep, youtube
|
|
):
|
|
user = make_user()
|
|
_channel(db)
|
|
db.add(Subscription(user_id=user.id, channel_id="UCc", yt_subscription_id="yt-sub-1"))
|
|
db.commit()
|
|
client = as_user(user)
|
|
override_dep(require_write_scope, lambda: user)
|
|
r = client.delete("/api/channels/UCc/subscription")
|
|
assert r.json() == {"ok": True, "unsubscribed": "UCc"}
|
|
assert _subscription(db, user) is None
|
|
|
|
|
|
def test_a_backfill_reset_through_the_route_is_kept(db, make_user, as_user, monkeypatch):
|
|
admin, reader = make_user(role="admin"), make_user()
|
|
_channel(db, backfill_done=True, backfill_cursor="page-9", recent_synced_at=NOW)
|
|
db.add(Subscription(user_id=reader.id, channel_id="UCc", deep_requested=False))
|
|
db.commit()
|
|
# The recent pull afterwards reaches YouTube; the reset is the route's own write.
|
|
monkeypatch.setattr(channels, "run_recent_backfill", lambda *a, **kw: None)
|
|
r = as_user(admin).post("/api/channels/UCc/reset-backfill")
|
|
assert r.status_code == 200, r.text
|
|
db.expire_all()
|
|
ch = db.get(Channel, "UCc")
|
|
assert (ch.backfill_done, ch.backfill_cursor, ch.recent_synced_at) == (False, None, None)
|
|
assert _subscription(db, reader).deep_requested is True
|
|
|
|
|
|
# --- live search ------------------------------------------------------------------------------
|
|
|
|
|
|
def test_search_results_cleared_through_the_route_are_gone(db, make_user, as_user):
|
|
user = make_user()
|
|
_video(db, "s1", via_search=True)
|
|
db.add(SearchFind(user_id=user.id, video_id="s1"))
|
|
db.commit()
|
|
r = as_user(user).post("/api/search/clear", json={"video_ids": ["s1"]})
|
|
assert r.json() == {"ok": True, "removed": 1}
|
|
db.expire_all()
|
|
assert db.get(Video, "s1") is None
|
|
assert db.execute(select(SearchFind)).first() is None
|
|
|
|
|
|
# --- Plex show and season marks ---------------------------------------------------------------
|
|
|
|
|
|
def _show(db):
|
|
lib = PlexLibrary(plex_key="2", title="Shows", kind="show", enabled=True)
|
|
db.add(lib)
|
|
db.flush()
|
|
sh = PlexShow(rating_key="sh1", library_id=lib.id, title="Show")
|
|
db.add(sh)
|
|
db.flush()
|
|
se = PlexSeason(rating_key="se1", show_id=sh.id, season_number=1)
|
|
db.add(se)
|
|
db.flush()
|
|
for n in (1, 2):
|
|
db.add(
|
|
PlexItem(
|
|
rating_key=f"e{n}",
|
|
library_id=lib.id,
|
|
kind="episode",
|
|
title=f"E{n}",
|
|
show_id=sh.id,
|
|
season_id=se.id,
|
|
season_number=1,
|
|
episode_number=n,
|
|
)
|
|
)
|
|
db.commit()
|
|
|
|
|
|
def _plex_marks(db, user):
|
|
db.expire_all()
|
|
return sorted(
|
|
db.execute(
|
|
select(PlexItem.rating_key, PlexState.status)
|
|
.join(PlexState, PlexState.item_id == PlexItem.id)
|
|
.where(PlexState.user_id == user.id)
|
|
).all()
|
|
)
|
|
|
|
|
|
def test_a_show_marked_watched_through_the_route_stays_watched(db, make_user, as_user):
|
|
user = make_user()
|
|
_show(db)
|
|
r = as_user(user).post("/api/plex/show/sh1/state", json={"watched": True})
|
|
assert r.json() == {"ok": True, "changed": 2, "watched": True}
|
|
assert _plex_marks(db, user) == [("e1", "watched"), ("e2", "watched")]
|
|
|
|
|
|
def test_a_season_marked_watched_through_the_route_stays_watched(db, make_user, as_user):
|
|
user = make_user()
|
|
_show(db)
|
|
r = as_user(user).post("/api/plex/season/se1/state", json={"watched": True})
|
|
assert r.json() == {"ok": True, "changed": 2, "watched": True}
|
|
assert _plex_marks(db, user) == [("e1", "watched"), ("e2", "watched")]
|
|
|
|
|
|
def _read_past_the_cap(db, user) -> list[Notification]:
|
|
"""READ_SOFT_CAP read notices, oldest first, and one unread notice after them."""
|
|
base = datetime(2024, 1, 1, tzinfo=timezone.utc)
|
|
rows = [
|
|
Notification(
|
|
user_id=user.id,
|
|
type="t",
|
|
title=f"n{i}",
|
|
read=i < READ_SOFT_CAP,
|
|
created_at=base + timedelta(minutes=i),
|
|
)
|
|
for i in range(READ_SOFT_CAP + 1)
|
|
]
|
|
db.add_all(rows)
|
|
db.commit()
|
|
return rows
|
|
|
|
|
|
def _committed_notices(user) -> tuple[int, bool]:
|
|
"""What another session sees: how many of the user's notices are left, and whether the oldest is."""
|
|
with SessionLocal() as s:
|
|
ids = s.scalars(select(Notification.title).where(Notification.user_id == user.id)).all()
|
|
return len(ids), "n0" in ids
|
|
|
|
|
|
@pytest.mark.parametrize("path", ["{id}/read", "read_all"])
|
|
def test_reading_a_notice_past_the_cap_commits_the_trim(db, make_user, as_user, path):
|
|
"""Marking a notice read makes READ_SOFT_CAP + 1 read ones: the handler commits the read flag and
|
|
the trim of the oldest together, and the trim counts the notice just read."""
|
|
user = make_user()
|
|
rows = _read_past_the_cap(db, user)
|
|
r = as_user(user).post("/api/me/notifications/" + path.format(id=rows[-1].id))
|
|
assert r.json() == {"ok": True}
|
|
assert _committed_notices(user) == (READ_SOFT_CAP, False)
|