luminate/Tests/LuminateCoreTests/JellyfinQuickConnectTests.swift

//
//  JellyfinQuickConnectTests.swift
//
//  Copyright 2026 Brendan Szymanski <hello@bscubed.dev>
//
//  This program is free software: you can redistribute it and/or modify
//  it under the terms of the GNU General Public License as published by
//  the Free Software Foundation, either version 3 of the License, or
//  (at your option) any later version.
//
//  This program is distributed in the hope that it will be useful,
//  but WITHOUT ANY WARRANTY; without even the implied warranty of
//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
//  GNU General Public License for more details.
//
//  You should have received a copy of the GNU General Public License
//  along with this program.  If not, see <https://www.gnu.org/licenses/>.
//
//  SPDX-License-Identifier: GPL-3.0-or-later
//

import Testing

@testable import LuminateCore

/// Exercises ``JellyfinQuickConnect``'s initiate-then-poll stream against a scripted
/// ``JellyfinServiceMock``.
@Suite struct JellyfinQuickConnectTests {
    @Test("Yields the code, then the secret once a poll reports authenticated")
    func happyPath() async throws {
        let polls = PolledResults([
            .success(JellyfinQuickConnectState(authenticated: false)),
            .success(JellyfinQuickConnectState(authenticated: true, secret: "top-secret")),
        ])
        let service = JellyfinServiceMock(
            initiateQuickConnect: { JellyfinQuickConnectState(secret: "top-secret", code: "123456") },
            quickConnectState: { _ in try await polls.next() }
        )

        var events: [JellyfinQuickConnect.Event] = []
        for try await event in service.quickConnect.connect(pollInterval: .milliseconds(5), maxPolls: 10) {
            events.append(event)
        }

        #expect(events == [.polling(code: "123456"), .authenticated(secret: "top-secret")])
        #expect(await polls.callCount == 2)
    }

    @Test("A server omitting the secret or code fails without polling")
    func missingPayloadThrows() async {
        let service = JellyfinServiceMock(
            initiateQuickConnect: { JellyfinQuickConnectState(secret: nil, code: "123456") }
        )

        await #expect(throws: JellyfinClientError.missingPayload(operation: "InitiateQuickConnect")) {
            for try await _ in service.quickConnect.connect(pollInterval: .milliseconds(5), maxPolls: 10) {}
        }
    }

    @Test("The server expiring the request propagates from a poll")
    func serverExpiryPropagates() async {
        let polls = PolledResults([
            .success(JellyfinQuickConnectState(authenticated: false)),
            .failure(JellyfinClientError.notFound),
        ])
        let service = JellyfinServiceMock(
            initiateQuickConnect: { JellyfinQuickConnectState(secret: "sec", code: "123456") },
            quickConnectState: { _ in try await polls.next() }
        )

        await #expect(throws: JellyfinClientError.notFound) {
            for try await _ in service.quickConnect.connect(pollInterval: .milliseconds(5), maxPolls: 10) {}
        }
    }

    @Test("Exhausting maxPolls without an answer gives up")
    func maxPollsExhaustedThrows() async {
        let polls = PolledResults(Array(repeating: .success(JellyfinQuickConnectState(authenticated: false)), count: 3))
        let service = JellyfinServiceMock(
            initiateQuickConnect: { JellyfinQuickConnectState(secret: "sec", code: "123456") },
            quickConnectState: { _ in try await polls.next() }
        )

        await #expect(throws: JellyfinClientError.quickConnectTimedOut) {
            for try await _ in service.quickConnect.connect(pollInterval: .milliseconds(5), maxPolls: 3) {}
        }
        #expect(await polls.callCount == 3)
    }

    @Test("Cancelling the consuming task stops polling instead of leaking it")
    func cancellationStopsPolling() async throws {
        let polls = PolledResults(
            Array(repeating: .success(JellyfinQuickConnectState(authenticated: false)), count: 1000)
        )
        let service = JellyfinServiceMock(
            initiateQuickConnect: { JellyfinQuickConnectState(secret: "sec", code: "123456") },
            quickConnectState: { _ in try await polls.next() }
        )

        let task = Task {
            for try await _ in service.quickConnect.connect(pollInterval: .milliseconds(5), maxPolls: 1000) {}
        }

        try await Task.sleep(for: .milliseconds(30))
        task.cancel()
        try await Task.sleep(for: .milliseconds(20))
        let countAtCancel = await polls.callCount

        try await Task.sleep(for: .milliseconds(60))
        let countLater = await polls.callCount

        #expect(countLater == countAtCancel)
    }
}

/// Hands back queued Quick Connect poll results in call order and counts how many were consumed.
///
/// A small actor rather than a plain array captured in a closure because ``JellyfinQuickConnect``
/// polls from a task the stream owns internally, so consumption genuinely races the test.
private actor PolledResults {
    private var queue: [Result<JellyfinQuickConnectState, Error>]
    private(set) var callCount = 0

    init(_ queue: [Result<JellyfinQuickConnectState, Error>]) {
        self.queue = queue
    }

    func next() throws -> JellyfinQuickConnectState {
        callCount += 1
        guard !queue.isEmpty else { throw JellyfinClientError.notFound }
        return try queue.removeFirst().get()
    }
}