ScarriffleandClaude Opus 5
af45bebceb
Der Fehler steckte in der Abfrage, und er ist grob:
beginsAt> = jetzt − 1 Std.
endsAt< = jetzt + 6 Std.
Beide Grenzen schließen genau das aus, was man sehen will. Ein
Zweistünder, der um halb vier begann, war um Viertel nach fünf
unsichtbar — und angezeigt wurde stattdessen die nächste Sendung, die
durch den Filter passte. Deshalb wich die Anzeige von Plex' eigener ab.
Jetzt wird nur der **Anfang** eingegrenzt, mit sechs Stunden Vorlauf für
lange Sendungen, und keine Grenze auf das Ende. Zurück kommt, was den
Zeitraum berührt, statt was vollständig hineinpasst.
Gefiltert wird danach nur das Programm, nicht die Senderliste: ein Sender
ohne frische Daten soll „kein Programm" sagen, statt zu verschwinden.
Dazu zwei Wünsche aus dem Feldtest:
Die Kachel lässt sich in der Größe ziehen. Der Griff sitzt in der Ecke,
die zur Bildschirmmitte zeigt — am äußeren Rand läge er halb außerhalb
des Daumens. Gespeichert wird die begrenzte Breite, nicht die gezogene,
sonst bliebe eine einmal zu weit gezogene Kachel für immer zu groß.
Und eine Senderauswahl. Über zwanzig Sender zu zeichnen und ihr Programm
zu holen kostet Zeit, und die meisten sieht man nie an. Eine leere
Auswahl heißt weiterhin „alle" — sonst stünde man beim ersten Öffnen vor
einer leeren Liste.
Die Zeiten im Raster-Abzug liegen jetzt in der Zukunft. Mit den echten
Zeitstempeln von damals wäre er ab dem Tag nach der Aufnahme leer
gewesen, sobald auf Frische gefiltert wird.
Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
534 lines
24 KiB
Swift
534 lines
24 KiB
Swift
import Foundation
|
|
import Testing
|
|
@testable import PlexKit
|
|
|
|
/// Woher die Senderliste kommt.
|
|
///
|
|
/// Drei Adressen, unter denen die Senderliste stehen sollte, antworteten auf
|
|
/// einem echten Server mit 404 — geraten war jede. Das Programmraster ist
|
|
/// keine Vermutung: die Weboberfläche von Plex zeichnet ihren Guide daraus,
|
|
/// und jeder Eintrag trägt den Sender mit sich. Diese Tests halten fest, dass
|
|
/// die Sender dort auch dann herauskommen, wenn sonst nichts antwortet.
|
|
/// Hält fest, womit tatsächlich gefragt wurde.
|
|
///
|
|
/// Ein Actor, weil der Transport aus einem anderen Zusammenhang schreibt und
|
|
/// Swift 6 das sonst zu Recht verweigert.
|
|
private actor QueryRecorder {
|
|
private(set) var items: [URLQueryItem] = []
|
|
func note(_ new: [URLQueryItem]) { items = new }
|
|
}
|
|
|
|
@Suite("Senderliste aus dem Programmraster")
|
|
struct LiveTVGuideTests {
|
|
|
|
private func server(transport: FakeTransport) -> PlexServer {
|
|
PlexServer(
|
|
resource: PlexResource(
|
|
name: "Test",
|
|
clientIdentifier: "srv",
|
|
accessToken: "token",
|
|
connections: [PlexConnection(uri: "http://server:32400", local: true)]
|
|
),
|
|
connection: PlexConnection(uri: "http://server:32400", local: true),
|
|
identity: .test,
|
|
transport: transport
|
|
)!
|
|
}
|
|
|
|
private func server(routes: [String: String]) -> PlexServer {
|
|
PlexServer(
|
|
resource: PlexResource(
|
|
name: "Test",
|
|
clientIdentifier: "srv",
|
|
accessToken: "token",
|
|
connections: [PlexConnection(uri: "http://server:32400", local: true)]
|
|
),
|
|
connection: PlexConnection(uri: "http://server:32400", local: true),
|
|
identity: .test,
|
|
transport: FakeTransport.routes(routes)
|
|
)!
|
|
}
|
|
|
|
// Die Zeiten in `livetv-grid.json` liegen bewusst weit in der Zukunft:
|
|
// das Programm wird auf Frische gefiltert, und ein Abzug mit den echten
|
|
// Zeitstempeln von damals wäre ab dem Tag nach der Aufnahme leer gewesen.
|
|
private func fixture(_ name: String) throws -> String {
|
|
let url = try #require(Bundle.module.url(forResource: "Fixtures/\(name)", withExtension: "json"))
|
|
return try String(contentsOf: url, encoding: .utf8)
|
|
}
|
|
|
|
private var dvr: PlexDVR {
|
|
PlexDVR(key: "2", epgIdentifier: "tv.plex.providers.epg.cloud:2")
|
|
}
|
|
|
|
@Test("Jeder Sender kommt genau einmal, obwohl er in mehreren Sendungen steht")
|
|
func derivesChannelsFromGrid() async throws {
|
|
let server = server(routes: [
|
|
"/tv.plex.providers.epg.cloud:2/grid": try fixture("livetv-grid"),
|
|
])
|
|
|
|
let guide = await server.liveTVGuide(dvr: dvr)
|
|
|
|
#expect(guide.channels.count == 2)
|
|
// Nach Sendernummer, und ohne die Nummer noch einmal im Namen:
|
|
// Plex schreibt sie dort mit hinein.
|
|
#expect(guide.channels.map(\.title) == ["SRF2", "ZDFGERH (ZDF HD)"])
|
|
}
|
|
|
|
@Test("Fehlt der Sendername, trägt das Kürzel den Sender")
|
|
func fallsBackToCallSign() async throws {
|
|
let server = server(routes: [
|
|
"/tv.plex.providers.epg.cloud:2/grid": try fixture("livetv-grid"),
|
|
])
|
|
|
|
let guide = await server.liveTVGuide(dvr: dvr)
|
|
let callSignOnly = try #require(guide.channels.first)
|
|
|
|
#expect(callSignOnly.title == "SRF2")
|
|
#expect(callSignOnly.channelIdentifier == "002")
|
|
}
|
|
|
|
@Test("Sendungen landen beim richtigen Sender, nach Anfangszeit sortiert")
|
|
func groupsProgramsByChannel() async throws {
|
|
let server = server(routes: [
|
|
"/tv.plex.providers.epg.cloud:2/grid": try fixture("livetv-grid"),
|
|
])
|
|
|
|
let guide = await server.liveTVGuide(dvr: dvr)
|
|
let zdf = try #require(guide.channels.last)
|
|
let programs = try #require(guide.programs[zdf.id])
|
|
|
|
// Auch die Folge ist dabei: mit `type=1` kam nur „Film" durch, und
|
|
// das Raster blieb leer.
|
|
#expect(programs.map(\.title) == ["Endlich Witwer", "heute journal"])
|
|
#expect(guide.programs.count == 2)
|
|
}
|
|
|
|
@Test("Die laufende Sendung fällt nicht aus dem Fenster")
|
|
func keepsTheRunningProgramme() async throws {
|
|
// Der Fehler, der das Programm sichtbar falsch machte: gefiltert wurde
|
|
// auf „endet vor Fensterende" und „beginnt nach Fensteranfang". Ein
|
|
// Zweistünder ab 15:30 war damit um 17:18 unsichtbar, und angezeigt
|
|
// wurde die nächste Sendung, die durch den Filter passte.
|
|
let body = try fixture("livetv-grid-overlap")
|
|
let recorder = QueryRecorder()
|
|
let server = server(transport: FakeTransport { request in
|
|
await recorder.note(
|
|
URLComponents(url: request.url!, resolvingAgainstBaseURL: false)?.queryItems ?? []
|
|
)
|
|
return (Data(body.utf8), FakeTransport.response(for: request, status: 200))
|
|
})
|
|
|
|
// 17:18 — mitten im langen Film.
|
|
let now = Date(timeIntervalSince1970: 1_789_211_880)
|
|
let entries = try await server.guide(
|
|
providerIdentifier: "tv.plex.providers.epg.cloud:2",
|
|
from: now,
|
|
to: now.addingTimeInterval(6 * 3_600)
|
|
)
|
|
|
|
#expect(entries.map(\.program.title).contains("Der lange Film"))
|
|
#expect(entries.first?.program.isRunning(at: now) == true)
|
|
|
|
// Und der Grund dafür steht in der Abfrage: nur der Anfang wird
|
|
// eingegrenzt, mit Vorlauf — keine Grenze auf das Ende.
|
|
let seen = await recorder.items
|
|
#expect(seen.contains { $0.name == "beginsAt<" })
|
|
#expect(!seen.contains { $0.name == "endsAt<" })
|
|
}
|
|
|
|
@Test("Ein Sender ohne Namen taucht nicht als Strich auf")
|
|
func skipsNamelessChannels() async throws {
|
|
let json = """
|
|
{"MediaContainer":{"size":1,"Metadata":[
|
|
{"ratingKey":"x","title":"Irgendwas","beginsAt":1757682000,"endsAt":1757685600,
|
|
"Media":[{"channelIdentifier":"nur-eine-kennung","Part":[{"key":"/livetv/channels/9"}]}]}
|
|
]}}
|
|
"""
|
|
let server = server(routes: ["/tv.plex.providers.epg.cloud:2/grid": json])
|
|
|
|
let guide = await server.liveTVGuide(dvr: dvr)
|
|
|
|
#expect(guide.channels.isEmpty)
|
|
}
|
|
|
|
@Test("Die Senderliste des Empfängers wird gefunden, ohne dass sie geraten wird")
|
|
func sweepsUntilSomethingAnswers() async throws {
|
|
// Der Fall, der viermal danebenging: die Senderliste steht weder beim
|
|
// Programmanbieter noch unter dem Empfänger, sondern beim Gerät — und
|
|
// sie schreibt den Namen in `name` statt in `title`.
|
|
let device = """
|
|
{"MediaContainer":{"size":2,"Channel":[
|
|
{"name":"SRF 1 HD","vcn":1,"key":"/livetv/channels/11","enabled":"1"},
|
|
{"name":"SRF zwei HD","vcn":2,"key":"/livetv/channels/12","enabled":"1"}
|
|
]}}
|
|
"""
|
|
let server = server(routes: ["/media/grabbers/devices/tuner-7/channels": device])
|
|
let withTuner = PlexDVR(
|
|
key: "2",
|
|
devices: [PlexTunerDevice(key: "tuner-7")],
|
|
epgIdentifier: "tv.plex.providers.epg.cloud:2"
|
|
)
|
|
|
|
let lookup = await server.channels(inDVR: withTuner)
|
|
|
|
#expect(lookup.channels.map(\.title) == ["SRF 1 HD", "SRF zwei HD"])
|
|
#expect(lookup.channels.first?.channelIdentifier == "1")
|
|
}
|
|
|
|
@Test("Jede abgeklopfte Adresse steht mit ihrer Antwort in der Spur")
|
|
func recordsWhatEveryPathAnswered() async throws {
|
|
// Ohne diese Spur ist „keine Sender" eine Sackgasse: sie sagt nicht,
|
|
// ob der Server nichts hergibt oder die App am falschen Ort sucht.
|
|
let server = server(routes: [:])
|
|
let withTuner = PlexDVR(key: "2", epgIdentifier: "tv.plex.providers.epg.cloud:2")
|
|
|
|
let lookup = await server.channels(inDVR: withTuner)
|
|
|
|
#expect(lookup.channels.isEmpty)
|
|
#expect(lookup.trace.count >= 3)
|
|
#expect(lookup.trace.allSatisfy { !$0.result.isEmpty })
|
|
#expect(lookup.trace.contains { $0.path == "/livetv/dvrs/2/channels" })
|
|
}
|
|
|
|
@Test("Eine Liste aus Strichen zählt nicht als Senderliste")
|
|
func rejectsNamelessChannels() async throws {
|
|
// Genau das ist einmal durchgegangen: dreißig Einträge ohne Namen
|
|
// sahen aus wie eine Senderliste und verdrängten die richtige Quelle.
|
|
let nameless = """
|
|
{"MediaContainer":{"size":2,"Channel":[
|
|
{"channelKey":"a","enabled":"1"},{"channelKey":"b","enabled":"1"}
|
|
]}}
|
|
"""
|
|
let server = server(routes: ["/livetv/dvrs/2/channels": nameless])
|
|
let withTuner = PlexDVR(key: "2", epgIdentifier: "tv.plex.providers.epg.cloud:2")
|
|
|
|
let lookup = await server.channels(inDVR: withTuner)
|
|
|
|
#expect(lookup.channels.isEmpty)
|
|
#expect(lookup.trace.contains { $0.path == "/livetv/dvrs/2/channels" && $0.result.contains("Channel: 2") })
|
|
}
|
|
|
|
@Test("Jeder Wert wird streng kodiert, Schrägstriche eingeschlossen")
|
|
func encodesEveryValueStrictly() async throws {
|
|
// Plex' eigener Client schickt alle Parameter durch `qs.stringify`,
|
|
// und das kodiert alles. `URLComponents` allein lässt `/`, `:`, `&`
|
|
// und `=` in Werten stehen — beim Server kam `path=/livetv/…` an
|
|
// statt `path=%2Flivetv%2F…`, und die Antwort war eine nackte 400.
|
|
let server = server(routes: [:])
|
|
let url = try #require(await server.transcodeURL(for: TranscodeRequest(
|
|
ratingKey: "5",
|
|
isLocal: true,
|
|
pathOverride: "/tv.plex.providers.epg.cloud:2/metadata/plex%3A%2F%2Fepisode%2Fabc"
|
|
))).absoluteString
|
|
|
|
#expect(url.contains("path=%2Ftv.plex.providers.epg.cloud%3A2%2Fmetadata%2F"))
|
|
// Eine Kennung, die schon `%3A` trägt, wird dabei zu `%253A` — und
|
|
// ist damit genau einmal kodiert.
|
|
#expect(url.contains("plex%253A%252F%252Fepisode%252Fabc"))
|
|
#expect(!url.contains("plex://"))
|
|
}
|
|
|
|
@Test("Nur was tatsächlich mit 200 antwortet, geht an den Player")
|
|
func rejectsStreamsTheServerRefuses() async throws {
|
|
// Vorher galt schon eine gebaute Adresse als Erfolg. Der Fehler
|
|
// tauchte dann erst im Player auf — als „HTTP 400" ohne Begründung.
|
|
let session = """
|
|
{"MediaContainer":{"size":1,"Metadata":[
|
|
{"ratingKey":"live-1","key":"/livetv/sessions/abc","type":"clip","title":"ZDF HD"}
|
|
]}}
|
|
"""
|
|
let server = server(routes: ["/gk-5": session])
|
|
let channel = PlexChannel(id: "5", title: "ZDF HD", key: "5", gridKey: "gk-5")
|
|
|
|
let result = await server.tune(channel: channel, maximumBitrate: nil)
|
|
|
|
#expect(result.url == nil)
|
|
// Und die Antwort des Servers steht in der Spur, nicht nur ein Code.
|
|
#expect(result.trace.contains { $0.result.hasPrefix("HTTP 404") })
|
|
}
|
|
|
|
@Test("Erst den Tuner belegen, dann umrechnen lassen")
|
|
func opensSessionBeforeTranscoding() async throws {
|
|
// Der übersprungene Schritt: ohne belegten Tuner beginnt die
|
|
// Wiedergabe und stirbt sofort — „die Wiedergabe wurde unterbrochen".
|
|
let session = """
|
|
{"MediaContainer":{"size":1,"Metadata":[
|
|
{"ratingKey":"live-1","key":"/livetv/sessions/abc","type":"clip","title":"ZDF HD",
|
|
"Media":[{"id":1,"Part":[{"id":1,"key":"/livetv/sessions/abc/stream"}]}]}
|
|
]}}
|
|
"""
|
|
// Nur unter dem Raster-Schlüssel antwortet eine Sitzung, und der
|
|
// Transcoder liefert erst danach eine Abspielliste.
|
|
let server = server(routes: ["/gk-5": session, "/start.m3u8": "#EXTM3U"])
|
|
let channel = PlexChannel(id: "5", title: "ZDF HD", key: "5", gridKey: "gk-5")
|
|
|
|
let result = await server.tune(channel: channel, maximumBitrate: nil)
|
|
let url = try #require(result.url)
|
|
let items = try #require(URLComponents(url: url, resolvingAgainstBaseURL: false)?.queryItems)
|
|
|
|
// Die Adresse der Sitzung, nicht die des Senders und nicht die der
|
|
// Sendung — der Transcoder sucht sich den Teil darin selbst.
|
|
let path = try #require(items.first { $0.name == "path" }?.value)
|
|
#expect(path.hasPrefix("/livetv/sessions/"))
|
|
// Ein laufender Sender hat keine Fassungen zur Auswahl.
|
|
#expect(items.first { $0.name == "mediaIndex" }?.value == "-1")
|
|
// Ohne die Gerätekennung in der Adresse kann der Server die Abholung
|
|
// keiner Sitzung zuordnen: AVPlayer schickt keine Kopfzeilen mit.
|
|
#expect(items.contains { $0.name == "X-Plex-Client-Identifier" })
|
|
}
|
|
|
|
@Test("Der Raster-Schlüssel wird zuerst versucht, und nie ein ganzer Pfad")
|
|
func sessionKeyOrder() {
|
|
let channel = PlexChannel(id: "hash-5", title: "ZDF HD", key: "5", gridKey: "gk-5")
|
|
let program = PlexProgram(
|
|
id: "p1",
|
|
title: "heute",
|
|
startsAt: .now,
|
|
endsAt: .now.addingTimeInterval(1800),
|
|
metadataKey: "/tv.plex.providers.epg.cloud:2/metadata/plex%3A%2F%2Fmovie%2Fabc"
|
|
)
|
|
|
|
let keys = PlexServer.sessionKeys(channel: channel, program: program)
|
|
|
|
#expect(keys.first == "gk-5")
|
|
// An `/livetv/sessions/<uuid>/` gehört ein Schlüssel, kein zweiter
|
|
// Pfad — auch nicht nach dem Entpacken.
|
|
#expect(keys.allSatisfy { !$0.contains("/") })
|
|
#expect(keys.contains("5"))
|
|
}
|
|
|
|
@Test("Die nachgeschlagene Sendung liefert die abspielbare Adresse")
|
|
func usesPartFromLookup() async throws {
|
|
// Das Raster nennt keine Teil-Adresse, die Einzelabfrage schon. Sie
|
|
// blind an den Transcoder zu geben, ergab dreimal eine nackte 400:
|
|
// eine Sendung beim Cloud-Programmführer hat keine Datei.
|
|
let metadata = """
|
|
{"MediaContainer":{"size":1,"Metadata":[
|
|
{"ratingKey":"epg-1","key":"/tv.plex.providers.epg.cloud:2/metadata/x","type":"movie",
|
|
"title":"Tagesschau",
|
|
"Media":[{"id":1,"Part":[{"id":1,"key":"/livetv/sessions/xyz/stream"}]}]}
|
|
]}}
|
|
"""
|
|
let server = server(routes: [
|
|
"/metadata/plex%3A%2F%2Fmovie%2Fabc": metadata,
|
|
"/start.m3u8": "#EXTM3U",
|
|
])
|
|
let channel = PlexChannel(id: "5", title: "SRF 1 HD", key: "5")
|
|
let program = PlexProgram(
|
|
id: "p1",
|
|
title: "Tagesschau",
|
|
startsAt: .now,
|
|
endsAt: .now.addingTimeInterval(1800),
|
|
metadataKey: "/tv.plex.providers.epg.cloud:2/metadata/plex%3A%2F%2Fmovie%2Fabc"
|
|
)
|
|
|
|
let result = await server.tune(channel: channel, program: program, maximumBitrate: nil)
|
|
let url = try #require(result.url)
|
|
let path = try #require(URLComponents(url: url, resolvingAgainstBaseURL: false)?
|
|
.queryItems?.first { $0.name == "path" }?.value)
|
|
|
|
#expect(path == "/livetv/sessions/xyz/stream")
|
|
}
|
|
|
|
@Test("Der Tuner wird per POST belegt, und die Antwort trägt den Strom")
|
|
func tunesThroughDVRWithPost() async throws {
|
|
// Nachgelesen im Quelltext von Plex' eigenem Client:
|
|
// POST /livetv/dvrs/{dvr}/channels/{kennung}/tune
|
|
// Genau diesen Pfad hatte ich seit Runden richtig — und jedes Mal
|
|
// mit GET abgefragt. Die Antwort darauf ist 404, und das sah aus wie
|
|
// „gibt es nicht" statt wie „nicht so".
|
|
let tuned = """
|
|
{"MediaContainer":{"size":1,"MediaSubscription":[{"key":"77",
|
|
"MetadataItem":{"ratingKey":"live-77","key":"/livetv/sessions/abc","type":"clip",
|
|
"title":"blue ZOOM HD",
|
|
"Media":[{"id":9,"Part":[{"id":9,
|
|
"key":"/livetv/sessions/abc/SITZUNG/index.m3u8?offset=-1.000000"}]}]}}]}}
|
|
"""
|
|
let server = server(routes: [
|
|
"/channels/6228f7f2-5fc705fa/tune": tuned,
|
|
"/index.m3u8": "#EXTM3U",
|
|
])
|
|
let channel = PlexChannel(id: "6228f7f2-5fc705fa", title: "blue ZOOM HD", key: "1")
|
|
let dvr = PlexDVR(key: "2")
|
|
|
|
let result = await server.tune(channel: channel, dvr: dvr, maximumBitrate: nil)
|
|
let url = try #require(result.url)
|
|
|
|
// Unmittelbar abgerufen, nicht umgerechnet: was beim Belegen
|
|
// herauskommt, ist bereits eine fertige HLS-Abspielliste.
|
|
#expect(url.path() == "/livetv/sessions/abc/SITZUNG/index.m3u8")
|
|
#expect(!url.absoluteString.contains("/transcode/"))
|
|
// Die eigene Abfrage der Sitzung darf nicht verlorengehen.
|
|
let items = try #require(URLComponents(url: url, resolvingAgainstBaseURL: false)?.queryItems)
|
|
#expect(items.contains { $0.name == "offset" && $0.value == "-1.000000" })
|
|
// Und der Systemplayer schickt keine Kopfzeilen mit.
|
|
#expect(items.contains { $0.name == "X-Plex-Token" })
|
|
#expect(items.contains { $0.name == "X-Plex-Client-Identifier" })
|
|
#expect(result.trace.contains { $0.path.hasPrefix("POST ") })
|
|
// Womit der Tuner hinterher wieder freigegeben wird.
|
|
#expect(result.subscriptionKey == "77")
|
|
}
|
|
|
|
@Test("Umgerechnet wird die Sitzung des Servers, nicht die eigene Kennung")
|
|
func transcodesTheServersSession() throws {
|
|
// `/livetv/sessions/1268be73-…` ist die Sitzung, die der Server beim
|
|
// Belegen angelegt hat. Ich habe mehrfach meine eigene erzeugte
|
|
// Kennung eingesetzt und mich über 404 gewundert.
|
|
let json = Data("""
|
|
{"MediaContainer":{"MediaSubscription":[{"key":"77","MetadataItem":{
|
|
"key":"/livetv/sessions/1268be73-1598-4fb9-ac9e-35825eba3fdd","live":"1",
|
|
"Media":[{"id":1,"Part":[{"key":"/livetv/sessions/1268be73/ABC/index.m3u8?offset=-1"}]}]}}]}}
|
|
""".utf8)
|
|
|
|
// Die Abspielliste selbst ist nicht gemeint — sie endet auf .m3u8.
|
|
#expect(PlexServer.firstSessionKey(in: json)
|
|
== "/livetv/sessions/1268be73-1598-4fb9-ac9e-35825eba3fdd")
|
|
}
|
|
|
|
@Test("Das Geräteprofil zerfällt nicht in eigene Parameter")
|
|
func encodesProfileExtra() async throws {
|
|
// `URLComponents` lässt `&` und `=` in einem Wert unangetastet. Das
|
|
// Geräteprofil steckt voll davon, und der Server las es als zwei
|
|
// Dutzend eigene Angaben — darunter ein zweites `protocol=`. Der
|
|
// Fehler steckte in jeder Transcoder-Adresse, seit es sie gibt.
|
|
let server = server(routes: [:])
|
|
let url = try #require(
|
|
await server.transcodeURL(for: TranscodeRequest(ratingKey: "5", isLocal: true))
|
|
)
|
|
let text = url.absoluteString
|
|
let profile = try #require(text.split(separator: "&")
|
|
.first { $0.hasPrefix("X-Plex-Client-Profile-Extra=") })
|
|
|
|
// Das ganze Profil steht in genau einem Parameter.
|
|
#expect(profile.contains("%26"))
|
|
#expect(profile.contains("add-transcode-target%28"))
|
|
#expect(profile.contains("%2B"))
|
|
// Und `protocol` kommt nur ein einziges Mal vor.
|
|
#expect(text.split(separator: "&").filter { $0.hasPrefix("protocol=") }.count == 1)
|
|
}
|
|
|
|
@Test("Jede Wiedergabe nennt ein Basisprofil")
|
|
func alwaysNamesBaseProfile() async throws {
|
|
// Ohne `X-Plex-Client-Profile-Name` lehnt der Server jede Anfrage an
|
|
// den Transcoder mit einer nackten 400 ab. `…-Profile-Extra`
|
|
// erweitert ein Profil, es ersetzt keins — ohne Basis gibt es nichts
|
|
// zu erweitern. Das hat zwei Tage gekostet.
|
|
let server = server(routes: [:])
|
|
let url = try #require(
|
|
await server.transcodeURL(for: TranscodeRequest(ratingKey: "5", isLocal: true))
|
|
).absoluteString
|
|
|
|
#expect(url.contains("X-Plex-Client-Profile-Name=Chrome"))
|
|
}
|
|
|
|
@Test("Jede Wiedergabe meldet, dass sie die Entscheidungsantwort versteht")
|
|
func alwaysSendsHasMDE() {
|
|
// Plex' eigener Client schickt `hasMDE=1` bei jeder Wiedergabe mit.
|
|
// Ohne diese Angabe lehnt der Server eine Live-Sitzung mit einer
|
|
// nackten 400 ab — ohne zu sagen, was ihm fehlt.
|
|
let items = TranscodeRequest(ratingKey: "5", isLocal: true).queryItems
|
|
|
|
#expect(items.contains { $0.name == "hasMDE" && $0.value == "1" })
|
|
}
|
|
|
|
@Test("Die Abspieladresse kommt aus der Sitzung, nicht aus der Tune-Antwort")
|
|
func prefersPartFromSession() async throws {
|
|
// Beide Antworten nennen eine Adresse derselben Form, aber mit
|
|
// verschiedenen Kennungen darin: die Tune-Antwort setzt die
|
|
// Sitzungskennung ein, die Sitzung selbst die Gerätekennung. Nur die
|
|
// zweite gibt es wirklich — die erste ergab jedes Mal 404.
|
|
let tuned = """
|
|
{"MediaContainer":{"size":1,"MediaSubscription":[{"key":"22",
|
|
"MetadataItem":{"key":"/livetv/sessions/abc","live":"1",
|
|
"Media":[{"id":1,"Part":[{"key":"/livetv/sessions/abc/SITZUNGSKENNUNG/index.m3u8"}]}]}}]}}
|
|
"""
|
|
let session = """
|
|
{"MediaContainer":{"size":1,"Metadata":[{"key":"/livetv/sessions/abc","live":"1",
|
|
"Media":[{"id":1,"Part":[{"key":"/livetv/sessions/abc/GERAETEKENNUNG/index.m3u8?offset=-1.000000"}]}]}]}}
|
|
"""
|
|
let server = server(routes: [
|
|
"/channels/kanal-7/tune": tuned,
|
|
"/livetv/sessions/abc": session,
|
|
// Nur unter der Gerätekennung liefert der Server eine
|
|
// Abspielliste; die andere Form gibt es nicht.
|
|
"/GERAETEKENNUNG/index.m3u8": "#EXTM3U",
|
|
])
|
|
let channel = PlexChannel(id: "kanal-7", title: "SRF 1 HD", key: "2")
|
|
|
|
let result = await server.tune(channel: channel, dvr: PlexDVR(key: "2"), maximumBitrate: nil)
|
|
let url = try #require(result.url)
|
|
|
|
#expect(url.path() == "/livetv/sessions/abc/GERAETEKENNUNG/index.m3u8")
|
|
#expect(!url.absoluteString.contains("SITZUNGSKENNUNG"))
|
|
#expect(!url.absoluteString.contains("/transcode/"))
|
|
}
|
|
|
|
@Test("Die Teil-Adresse wird gefunden, egal wie tief sie liegt")
|
|
func findsPartAtAnyDepth() throws {
|
|
// Der Vorgang liegt je nach Serverfassung unterschiedlich tief
|
|
// verschachtelt. Ein fest verdrahteter Weg hinein sähe wieder aus
|
|
// wie „nichts da".
|
|
let json = Data("""
|
|
{"MediaContainer":{"Tief":{"Tiefer":[{"Media":[{"Part":[{"key":"/gefunden"}]}]}]}}}
|
|
""".utf8)
|
|
|
|
#expect(PlexServer.firstPartKey(in: json) == "/gefunden")
|
|
#expect(PlexServer.firstPartKey(in: Data("{}".utf8)) == nil)
|
|
}
|
|
|
|
@Test("Die Zuordnung übersetzt zwischen Programmführer und Empfänger")
|
|
func translatesChannelKeyToDeviceChannel() {
|
|
// Der Programmführer kennt den Sender als `6228f7f2…-5fc706…`, der
|
|
// Tuner als `300`. Ohne diese Übersetzung spricht man den Empfänger
|
|
// in einer Sprache an, die er nicht versteht — und bekommt 404 auf
|
|
// alles. Genau daran ist das Einschalten reihenweise gescheitert.
|
|
let dvr = PlexDVR(
|
|
key: "2",
|
|
devices: [PlexTunerDevice(key: "1", channelMappings: [
|
|
PlexChannelMapping(
|
|
channelKey: "6228f7f2364e02fa5ec8e51c-5fc706063f45c6002eab58a3",
|
|
deviceIdentifier: "300",
|
|
lineupIdentifier: "002"
|
|
),
|
|
PlexChannelMapping(
|
|
channelKey: "6228f7f2364e02fa5ec8e51c-5fc705fa6b022a002d77f212",
|
|
deviceIdentifier: "299",
|
|
lineupIdentifier: "001"
|
|
),
|
|
])]
|
|
)
|
|
|
|
#expect(dvr.deviceChannel(forChannelKey: "6228f7f2364e02fa5ec8e51c-5fc706063f45c6002eab58a3") == "300")
|
|
#expect(dvr.deviceChannel(forChannelKey: "6228f7f2364e02fa5ec8e51c-5fc705fa6b022a002d77f212") == "299")
|
|
// Auch ohne den Vorsatz der Senderliste, denn die Kennung kommt je
|
|
// nach Quelle mit oder ohne ihn.
|
|
#expect(dvr.deviceChannel(forChannelKey: "5fc706063f45c6002eab58a3") == "300")
|
|
#expect(dvr.deviceChannel(forChannelKey: "unbekannt") == nil)
|
|
}
|
|
|
|
@Test("Die Sender des Tuners stehen unter DeviceChannel")
|
|
func readsDeviceChannelKey() async throws {
|
|
// Der Server lieferte 278 Sender, die Hülle verwarf sie: sie kannte
|
|
// nur `Channel`. Der Tuner schreibt `DeviceChannel`.
|
|
let json = """
|
|
{"MediaContainer":{"size":2,"DeviceChannel":[
|
|
{"drm":false,"favorite":false,"hd":true,"identifier":"300","key":"300","name":"ZDF HD"},
|
|
{"hd":true,"identifier":"301","key":"301","name":"SRF 1 HD"}
|
|
]}}
|
|
"""
|
|
let server = server(routes: ["/media/grabbers/devices/1/channels": json])
|
|
let withTuner = PlexDVR(
|
|
key: "2",
|
|
devices: [PlexTunerDevice(key: "1")],
|
|
epgIdentifier: "tv.plex.providers.epg.cloud:2"
|
|
)
|
|
|
|
let lookup = await server.channels(inDVR: withTuner)
|
|
|
|
#expect(lookup.channels.map(\.title) == ["ZDF HD", "SRF 1 HD"])
|
|
// Die Nummer steht beim Tuner schlicht im Schlüssel.
|
|
#expect(lookup.channels.first?.channelIdentifier == "300")
|
|
}
|
|
}
|