peter
b7ce1d467c
- Every playlist item write (add, remove, move, reorder, rename; Plex remove and remove-bulk) row-locks the playlist before it touches an item, a move both lists in id order: remove beside reorder was a deadlock, and two adds of one video a unique-key 500. - The scheduled mirror refresh re-reads dirty under that lock, so an edit made during its YouTube calls is not replaced by YouTube's order. - A user's bulk pull holds a per-user advisory claim: two at once created duplicate mirrors. The manual sync answers 409 sync_all_busy instead of '0 synced', and like the re-pull spends its cooldown only on a pull that runs. - Deleted mirrors are committed at once, not only when a later list commits. - The claims open an unpooled connection of their own instead of a third pooled one per push.
114 lines
4.7 KiB
Python
114 lines
4.7 KiB
Python
"""An action YouTube refuses answers a 422 the UI can translate — never a raw 500 — and says what the
|
|
user can do about it (`routes/_common.youtube_refusal`). E9 F1: the two manual syncs had no handler
|
|
at all, so a quota or transport failure opened the blocking "Server error" dialog."""
|
|
|
|
from types import SimpleNamespace
|
|
|
|
import httpx
|
|
import pytest
|
|
|
|
from app.auth import has_read_scope
|
|
from app.models import OAuthToken
|
|
from app.youtube import client as yt
|
|
from app.youtube.client import YouTubeError, refusal_reason
|
|
|
|
|
|
@pytest.mark.parametrize(
|
|
("exc", "reason"),
|
|
[
|
|
(YouTubeError("m", reason="quotaExceeded", path="playlists"), "quota"),
|
|
(YouTubeError("m", reason="backendError,dailyLimitExceeded", path="videos"), "quota"),
|
|
(YouTubeError("m", reason="invalid_grant", path="oauth2/token"), "reconnect"),
|
|
# The token endpoint failing any other way leaves the grant alone — and a reconnect would
|
|
# not help: Google's bad minute, a rate limit, a misconfigured client.
|
|
(YouTubeError("m", reason="backend_error", path="oauth2/token"), "unavailable"),
|
|
(YouTubeError("m", reason="<unparseable>", path="oauth2/token"), "unavailable"),
|
|
(YouTubeError("m", reason="invalid_client", path="oauth2/token"), "unavailable"),
|
|
(YouTubeError("No refresh token; user must re-authenticate"), "reconnect"),
|
|
(YouTubeError("m", reason="transport"), "unavailable"),
|
|
(YouTubeError("m", reason="backendError", path="subscriptions"), "unavailable"),
|
|
],
|
|
)
|
|
def test_a_failure_is_sorted_by_what_the_user_can_do(exc, reason):
|
|
assert refusal_reason(exc) == reason
|
|
|
|
|
|
@pytest.mark.parametrize(
|
|
("route", "target"),
|
|
[
|
|
("/api/sync/subscriptions", "app.routes.sync.import_subscriptions"),
|
|
("/api/playlists/sync-youtube", "app.routes.playlists.pull_user_playlists"),
|
|
],
|
|
)
|
|
def test_a_manual_sync_youtube_refuses_is_a_422_not_a_500(
|
|
db, as_user, make_user, monkeypatch, route, target
|
|
):
|
|
user = make_user()
|
|
db.commit()
|
|
module, name = target.rsplit(".", 1)
|
|
|
|
def refused(*a, **k):
|
|
raise YouTubeError("GET subscriptions -> 403: quotaExceeded", reason="quotaExceeded")
|
|
|
|
monkeypatch.setattr(f"{module}.has_read_scope", lambda u: True)
|
|
monkeypatch.setattr(f"{module}.{name}", refused)
|
|
|
|
r = as_user(user).post(route)
|
|
assert r.status_code == 422
|
|
assert r.json()["detail"] == {"code": "youtube", "reason": "quota"}
|
|
|
|
|
|
def test_a_revoked_grant_is_forgotten_so_the_account_can_reconnect(db, make_user, monkeypatch):
|
|
"""Google's `invalid_grant` is final. Kept, the grant read as live in Settings — with no connect
|
|
button — while every call failed; cleared, the connect button comes back."""
|
|
user = make_user()
|
|
db.add(
|
|
OAuthToken(
|
|
user_id=user.id,
|
|
refresh_token_enc="x",
|
|
scopes="openid https://www.googleapis.com/auth/youtube.readonly",
|
|
)
|
|
)
|
|
db.commit()
|
|
db.refresh(user)
|
|
assert has_read_scope(user)
|
|
|
|
resp = httpx.Response(
|
|
400,
|
|
json={"error": "invalid_grant", "error_description": "Token has been expired or revoked."},
|
|
request=httpx.Request("POST", yt.GOOGLE_TOKEN_URL),
|
|
)
|
|
c = yt.YouTubeClient.__new__(yt.YouTubeClient) # no HTTP client: `_send` is the stub
|
|
c.db, c.user = db, user
|
|
monkeypatch.setattr(yt, "decrypt", lambda value: "a-refresh-token")
|
|
monkeypatch.setattr(yt.sysconfig, "get_str", lambda d, key: "")
|
|
monkeypatch.setattr(c, "_send", lambda *a, **k: resp)
|
|
|
|
with pytest.raises(YouTubeError) as caught:
|
|
c._access_token()
|
|
assert refusal_reason(caught.value) == "reconnect"
|
|
|
|
db.expire_all()
|
|
assert not has_read_scope(db.get(type(user), user.id))
|
|
|
|
|
|
def test_any_other_token_refusal_keeps_the_grant(monkeypatch):
|
|
"""Only `invalid_grant` is final: a 5xx from the token endpoint is Google having a bad minute —
|
|
and the user is told to try again, not to reconnect an account that still reads as connected."""
|
|
resp = httpx.Response(
|
|
503, json={"error": "backend_error"}, request=httpx.Request("POST", yt.GOOGLE_TOKEN_URL)
|
|
)
|
|
tok = SimpleNamespace(access_token=None, expiry=None, refresh_token_enc="x", scopes="s")
|
|
c = yt.YouTubeClient.__new__(yt.YouTubeClient)
|
|
c.db = SimpleNamespace(add=lambda o: None, commit=lambda: None)
|
|
c.user = SimpleNamespace(id=1, token=tok)
|
|
monkeypatch.setattr(yt, "decrypt_optional", lambda value: None)
|
|
monkeypatch.setattr(yt, "decrypt", lambda value: "a-refresh-token")
|
|
monkeypatch.setattr(yt.sysconfig, "get_str", lambda d, key: "")
|
|
monkeypatch.setattr(c, "_send", lambda *a, **k: resp)
|
|
|
|
with pytest.raises(YouTubeError) as caught:
|
|
c._access_token()
|
|
assert tok.scopes == "s"
|
|
assert refusal_reason(caught.value) == "unavailable"
|