mirror of
https://github.com/yattee/yattee.git
synced 2026-10-23 21:22:53 +00:00
0bfbd47882
The corner layout's below-video host is the portrait info panel, not a page host: it can render only Info, plus Comments as the panel's pill on iOS. The page editor still offered "Below Video" for every page, so assigning Related there was accepted, stored, listed as such, and then silently rendered in the side column. - The Layout section gains a "Below Video" picker in corner mode: Nothing / Info / Info and Comments (macOS offers the first two). It writes the info/comments regions; the per-page Location section and its strings are gone. - PanelSettings.normalizedPages clamps regions to what the host can render (only info/comments below, comments only together with info), so older presets self-correct. effectiveRegion(for:) resolves the platform-specific placement and is used by both the pages list labels and CornerPlayerLayout, replacing its own region checks. - The layout schematic drops the below-video block for "Nothing"; the corner-mode footer explains the constraint. - Tests cover the picker round-trip and the clamping.
327 lines
15 KiB
Swift
327 lines
15 KiB
Swift
//
|
|
// PanelSettingsTests.swift
|
|
// YatteeTests
|
|
//
|
|
// Tests for details panel settings model (Codable compatibility).
|
|
//
|
|
|
|
import Foundation
|
|
import Testing
|
|
@testable import Yattee
|
|
|
|
@Suite("Panel Settings Tests")
|
|
struct PanelSettingsTests {
|
|
private func roundTrip(_ settings: PanelSettings) throws -> PanelSettings {
|
|
let encoded = try JSONEncoder().encode(settings)
|
|
return try JSONDecoder().decode(PanelSettings.self, from: encoded)
|
|
}
|
|
|
|
// MARK: - Round Trip
|
|
|
|
@Test("Default settings round-trip")
|
|
func defaultRoundTrip() throws {
|
|
let decoded = try roundTrip(.default)
|
|
#expect(decoded == PanelSettings.default)
|
|
}
|
|
|
|
@Test("Customized settings round-trip")
|
|
func customizedRoundTrip() throws {
|
|
var settings = PanelSettings.default
|
|
settings.layoutMode = .corner
|
|
settings.setDefaultVisibility(.remember, for: .landscape)
|
|
settings.showPageBarLabels = false
|
|
settings.setEnabled(false, for: .related)
|
|
settings.movePages(fromOffsets: IndexSet(integer: 1), toOffset: 0)
|
|
settings.updateSettings(
|
|
.info(InfoPageSettings(
|
|
showStatsRow: false,
|
|
showDescription: false,
|
|
descriptionCollapsedLines: 5,
|
|
descriptionExpandedByDefault: true
|
|
)),
|
|
for: .info
|
|
)
|
|
|
|
let decoded = try roundTrip(settings)
|
|
#expect(decoded == settings)
|
|
#expect(decoded.effectiveLayoutMode == .corner)
|
|
#expect(decoded.effectiveDefaultVisibility(for: .landscape) == .remember)
|
|
#expect(decoded.effectiveDefaultVisibility(for: .portrait) == .visible)
|
|
#expect(decoded.effectiveShowPageBarLabels == false)
|
|
#expect(!decoded.isPageEnabled(.related))
|
|
|
|
let info = decoded.configuration(for: .info)?.infoSettings
|
|
#expect(info?.effectiveShowStatsRow == false)
|
|
#expect(info?.effectiveShowDescription == false)
|
|
#expect(info?.effectiveShowChannelRow == true)
|
|
#expect(info?.effectiveDescriptionCollapsedLines == 5)
|
|
#expect(info?.effectiveDescriptionExpandedByDefault == true)
|
|
#expect(InfoPageSettings(descriptionCollapsedLines: 0).effectiveDescriptionCollapsedLines == 1)
|
|
#expect(InfoPageSettings().effectiveDescriptionCollapsedLines == 3)
|
|
}
|
|
|
|
@Test("Inline sections follow the configured page order and enablement")
|
|
func inlineSectionsFollowOrder() {
|
|
var settings = PanelSettings.default
|
|
// Default order: info, comments, related, chapters, queue
|
|
#expect(settings.inlineSections().map(\.pageType) == [.related, .chapters])
|
|
|
|
// Move chapters (index 3) above related (index 2)
|
|
settings.movePages(fromOffsets: IndexSet(integer: 3), toOffset: 2)
|
|
#expect(settings.inlineSections().map(\.pageType) == [.chapters, .related])
|
|
|
|
settings.setEnabled(false, for: .related)
|
|
#expect(settings.inlineSections().map(\.pageType) == [.chapters])
|
|
|
|
settings.updateSettings(.chapters(ChaptersPageSettings(showThumbnails: false)), for: .chapters)
|
|
#expect(settings.inlineSections().first?.chaptersSettings.effectiveShowThumbnails == false)
|
|
}
|
|
|
|
@Test("Per-page element settings round-trip for every page type")
|
|
func perPageSettingsRoundTrip() throws {
|
|
var settings = PanelSettings.default
|
|
settings.updateSettings(.comments(CommentsPageSettings(showAvatars: false)), for: .comments)
|
|
settings.updateSettings(.related(RelatedPageSettings(showThumbnails: false)), for: .related)
|
|
settings.updateSettings(.chapters(ChaptersPageSettings(showThumbnails: false, expandedByDefault: false)), for: .chapters)
|
|
settings.updateSettings(.queue(QueuePageSettings(showHistory: false)), for: .queue)
|
|
|
|
let decoded = try roundTrip(settings)
|
|
#expect(decoded == settings)
|
|
#expect(decoded.configuration(for: .comments)?.commentsSettings.effectiveShowAvatars == false)
|
|
#expect(decoded.configuration(for: .related)?.relatedSettings.effectiveShowThumbnails == false)
|
|
#expect(decoded.configuration(for: .chapters)?.chaptersSettings.effectiveShowThumbnails == false)
|
|
#expect(decoded.configuration(for: .chapters)?.chaptersSettings.effectiveExpandedByDefault == false)
|
|
#expect(decoded.configuration(for: .related)?.relatedSettings.effectiveExpandedByDefault == true)
|
|
#expect(decoded.configuration(for: .queue)?.queueSettings.effectiveShowHistory == false)
|
|
}
|
|
|
|
@Test("Typed accessors fall back to defaults for mismatched payloads")
|
|
func typedAccessorFallbacks() {
|
|
// An info payload read through the comments accessor yields defaults.
|
|
let page = PanelPageConfiguration(
|
|
pageType: .comments,
|
|
settings: .info(InfoPageSettings(showStatsRow: false))
|
|
)
|
|
#expect(page.commentsSettings.effectiveShowAvatars == true)
|
|
#expect(page.queueSettings.effectiveShowHistory == true)
|
|
}
|
|
|
|
// MARK: - Backward Compatibility
|
|
|
|
@Test("Layout without panelSettings decodes and falls back to default")
|
|
func layoutWithoutPanelSettings() throws {
|
|
let layout = PlayerControlsLayout.default
|
|
var json = try #require(
|
|
try JSONSerialization.jsonObject(with: JSONEncoder().encode(layout)) as? [String: Any]
|
|
)
|
|
json.removeValue(forKey: "panelSettings")
|
|
let data = try JSONSerialization.data(withJSONObject: json)
|
|
|
|
let decoded = try JSONDecoder().decode(PlayerControlsLayout.self, from: data)
|
|
#expect(decoded.panelSettings == nil)
|
|
#expect(decoded.effectivePanelSettings == .default)
|
|
}
|
|
|
|
@Test("Minimal page entries decode with defaults")
|
|
func minimalPageEntries() throws {
|
|
let json = """
|
|
{ "pages": [ { "pageType": "info" }, { "pageType": "comments" } ] }
|
|
"""
|
|
let decoded = try JSONDecoder().decode(PanelSettings.self, from: Data(json.utf8))
|
|
#expect(decoded.pages.count == 2)
|
|
#expect(decoded.pages.allSatisfy { $0.isEnabled })
|
|
#expect(decoded.pages.allSatisfy { $0.region == .primary })
|
|
#expect(decoded.effectiveLayoutMode == .stacked)
|
|
#expect(decoded.effectiveDefaultVisibility(for: .portrait) == .visible)
|
|
#expect(decoded.effectiveDefaultVisibility(for: .landscape) == .hidden)
|
|
}
|
|
|
|
// MARK: - Forward Compatibility
|
|
|
|
@Test("Unknown page type from a future version is dropped")
|
|
func unknownPageTypeDropped() throws {
|
|
let json = """
|
|
{ "pages": [
|
|
{ "pageType": "info" },
|
|
{ "pageType": "futureHologram", "isEnabled": true },
|
|
{ "pageType": "queue" }
|
|
] }
|
|
"""
|
|
let decoded = try JSONDecoder().decode(PanelSettings.self, from: Data(json.utf8))
|
|
#expect(decoded.pages.map(\.pageType) == [.info, .queue])
|
|
}
|
|
|
|
@Test("Unknown settings discriminator decodes to nil settings")
|
|
func unknownSettingsDiscriminator() throws {
|
|
let json = """
|
|
{ "pages": [
|
|
{ "pageType": "info", "settings": { "type": "futureKind", "futureKind": { "x": 1 } } }
|
|
] }
|
|
"""
|
|
let decoded = try JSONDecoder().decode(PanelSettings.self, from: Data(json.utf8))
|
|
#expect(decoded.pages.count == 1)
|
|
#expect(decoded.pages.first?.settings == nil)
|
|
// nil settings fall back to defaults
|
|
#expect(decoded.pages.first?.infoSettings.effectiveShowDescription == true)
|
|
}
|
|
|
|
@Test("Legacy single default visibility seeds both orientations until set individually")
|
|
func legacyDefaultVisibilitySeedsBothOrientations() throws {
|
|
let json = """
|
|
{ "pages": [ { "pageType": "info" } ], "defaultVisibility": "remember" }
|
|
"""
|
|
var settings = try JSONDecoder().decode(PanelSettings.self, from: Data(json.utf8))
|
|
#expect(settings.effectiveDefaultVisibility(for: .portrait) == .remember)
|
|
#expect(settings.effectiveDefaultVisibility(for: .landscape) == .remember)
|
|
|
|
settings.setDefaultVisibility(.visible, for: .portrait)
|
|
#expect(settings.effectiveDefaultVisibility(for: .portrait) == .visible)
|
|
#expect(settings.effectiveDefaultVisibility(for: .landscape) == .remember)
|
|
|
|
let decoded = try roundTrip(settings)
|
|
#expect(decoded == settings)
|
|
|
|
#expect(PanelDefaultVisibility.remember.resolve(lastVisible: true))
|
|
#expect(!PanelDefaultVisibility.hidden.resolve(lastVisible: true))
|
|
#expect(PanelDefaultVisibility.visible.resolve(lastVisible: false))
|
|
}
|
|
|
|
@Test("Unknown layoutMode and defaultVisibility decode to nil")
|
|
func unknownEnumValues() throws {
|
|
let json = """
|
|
{ "pages": [ { "pageType": "info" } ],
|
|
"layoutMode": "floating",
|
|
"defaultVisibility": "sometimes" }
|
|
"""
|
|
let decoded = try JSONDecoder().decode(PanelSettings.self, from: Data(json.utf8))
|
|
#expect(decoded.layoutMode == nil)
|
|
#expect(decoded.defaultVisibility == nil)
|
|
#expect(decoded.effectiveLayoutMode == .stacked)
|
|
#expect(decoded.effectiveDefaultVisibility(for: .landscape) == .hidden)
|
|
}
|
|
|
|
// MARK: - Normalization
|
|
|
|
@Test("Normalized pages append missing types as disabled")
|
|
func normalizedPagesAppendMissing() throws {
|
|
let json = """
|
|
{ "pages": [ { "pageType": "info" } ] }
|
|
"""
|
|
let decoded = try JSONDecoder().decode(PanelSettings.self, from: Data(json.utf8))
|
|
let normalized = decoded.normalizedPages
|
|
#expect(normalized.count == PanelPageType.allCases.count)
|
|
#expect(normalized.first?.pageType == .info)
|
|
#expect(normalized.dropFirst().allSatisfy { !$0.isEnabled })
|
|
}
|
|
|
|
@Test("Info is pinned first and always enabled")
|
|
func infoPinnedFirstAndEnabled() throws {
|
|
let json = """
|
|
{ "pages": [
|
|
{ "pageType": "related" },
|
|
{ "pageType": "info", "isEnabled": false },
|
|
{ "pageType": "chapters" }
|
|
] }
|
|
"""
|
|
var settings = try JSONDecoder().decode(PanelSettings.self, from: Data(json.utf8))
|
|
#expect(settings.normalizedPages.first?.pageType == .info)
|
|
#expect(settings.isPageEnabled(.info))
|
|
#expect(settings.enabledPages().map(\.pageType) == [.info, .related, .chapters])
|
|
|
|
settings.setEnabled(false, for: .info)
|
|
#expect(settings.isPageEnabled(.info))
|
|
|
|
// Moving info down, or another page above it, leaves info first
|
|
settings.movePages(fromOffsets: IndexSet(integer: 0), toOffset: 3)
|
|
#expect(settings.pages.first?.pageType == .info)
|
|
settings.movePages(fromOffsets: IndexSet(integer: 2), toOffset: 0)
|
|
#expect(settings.pages.map(\.pageType).prefix(3) == [.info, .chapters, .related])
|
|
}
|
|
|
|
@Test("Moving displayed pages keeps hidden pages in their slots")
|
|
func moveVisiblePagesKeepsHiddenSlots() {
|
|
var settings = PanelSettings.default
|
|
// Stored: info, comments, related, chapters, queue. A list that hides
|
|
// info (pinned) and queue displays comments, related, chapters.
|
|
let visible: [PanelPageType] = [.comments, .related, .chapters]
|
|
|
|
// Move chapters (displayed index 2) to the top of the displayed list
|
|
settings.moveVisiblePages(visible, fromOffsets: IndexSet(integer: 2), toOffset: 0)
|
|
#expect(settings.pages.map(\.pageType) == [.info, .chapters, .comments, .related, .queue])
|
|
|
|
// Hidden page in the middle keeps its slot
|
|
settings.movePages(fromOffsets: IndexSet(integer: 4), toOffset: 2)
|
|
#expect(settings.pages.map(\.pageType) == [.info, .chapters, .queue, .comments, .related])
|
|
settings.moveVisiblePages([.chapters, .comments, .related], fromOffsets: IndexSet(integer: 0), toOffset: 3)
|
|
#expect(settings.pages.map(\.pageType) == [.info, .comments, .queue, .related, .chapters])
|
|
}
|
|
|
|
@Test("Enabled pages filter by region")
|
|
func enabledPagesRegionFilter() {
|
|
let settings = PanelSettings.default
|
|
let primary = settings.enabledPages(in: .primary).map(\.pageType)
|
|
let belowVideo = settings.enabledPages(in: .belowVideo).map(\.pageType)
|
|
let all = settings.enabledPages().map(\.pageType)
|
|
|
|
#expect(primary == [.related, .chapters, .queue])
|
|
#expect(belowVideo == [.info, .comments])
|
|
#expect(all == [.info, .comments, .related, .chapters, .queue])
|
|
}
|
|
|
|
// MARK: - Mutations
|
|
|
|
@Test("Disabling and re-enabling a page preserves order")
|
|
func toggleKeepsOrder() {
|
|
var settings = PanelSettings.default
|
|
settings.setEnabled(false, for: .comments)
|
|
#expect(!settings.isPageEnabled(.comments))
|
|
settings.setEnabled(true, for: .comments)
|
|
#expect(settings.pages.map(\.pageType) == PanelSettings.default.pages.map(\.pageType))
|
|
}
|
|
|
|
@Test("Below-video content and layout mode round-trip through Codable")
|
|
func belowVideoContentAndLayoutModeRoundTrip() throws {
|
|
var settings = PanelSettings.default
|
|
settings.layoutMode = .corner
|
|
#expect(settings.belowVideoContent == .infoAndComments)
|
|
|
|
settings.belowVideoContent = .info
|
|
#expect(settings.configuration(for: .info)?.region == .belowVideo)
|
|
#expect(settings.configuration(for: .comments)?.region == .primary)
|
|
#expect(settings.enabledPages(in: .primary).map(\.pageType) == [.comments, .related, .chapters, .queue])
|
|
|
|
let data = try JSONEncoder().encode(settings)
|
|
let decoded = try JSONDecoder().decode(PanelSettings.self, from: data)
|
|
#expect(decoded.effectiveLayoutMode == .corner)
|
|
#expect(decoded.belowVideoContent == .info)
|
|
|
|
settings.belowVideoContent = .nothing
|
|
#expect(settings.enabledPages(in: .belowVideo).isEmpty)
|
|
#expect(settings.enabledPages(in: .primary).map(\.pageType) == [.info, .comments, .related, .chapters, .queue])
|
|
}
|
|
|
|
@Test("Pages the below-video host cannot render are clamped to the side column")
|
|
func unhostableBelowVideoRegionsClamp() {
|
|
// Older presets could assign any page below the video.
|
|
var settings = PanelSettings(pages: [
|
|
PanelPageConfiguration(pageType: .info, region: .primary),
|
|
PanelPageConfiguration(pageType: .comments, region: .belowVideo),
|
|
PanelPageConfiguration(pageType: .related, region: .belowVideo),
|
|
PanelPageConfiguration(pageType: .chapters, region: .belowVideo),
|
|
PanelPageConfiguration(pageType: .queue, region: .belowVideo),
|
|
])
|
|
#expect(settings.belowVideoContent == .nothing)
|
|
#expect(settings.enabledPages(in: .belowVideo).isEmpty)
|
|
#expect(settings.effectiveRegion(for: .related) == .primary)
|
|
|
|
// Comments may sit below only together with info.
|
|
settings.belowVideoContent = .infoAndComments
|
|
#expect(settings.enabledPages(in: .belowVideo).map(\.pageType) == [.info, .comments])
|
|
#expect(settings.enabledPages(in: .primary).map(\.pageType) == [.related, .chapters, .queue])
|
|
|
|
settings.pages[0].region = .primary
|
|
#expect(settings.belowVideoContent == .nothing)
|
|
#expect(settings.effectiveRegion(for: .comments) == .primary)
|
|
}
|
|
}
|