Sync source edition with VCC Plus 3.7.0 build 63
This commit is contained in:
1 parent
c652a5276d
commit
b2ecec4d87
86 files changed
+10519
-472
No files matched your search
@@ -93,6 +93,68 @@ final class SoftwareLibraryBrowseTests: XCTestCase {
|
||||
XCTAssertEqual(LibraryBrowseQuery.type(of: cartridge, related: [disk, music]), "Other", "Conflicting editions do not establish a type")
|
||||
XCTAssertEqual(LibraryBrowseQuery.type(of: release("demo", category: "Disks/Games/Sierra Games/Demos")), "Games")
|
||||
}
|
||||
|
||||
func testUnifiedPersonalGamesAreFirstAndAvailableToLocalDiskCompanion() {
|
||||
var entry = PersonalSoftwareEntry(id: UUID(), title: "Private Game", files: [
|
||||
.init(path: "PRIVATE.DSK", kind: "disk", byteSize: 4, sha256: String(repeating: "a", count: 64))
|
||||
])
|
||||
entry.category = "Games"
|
||||
let privateRelease = entry.release(in: directory)
|
||||
let privateTitle = SoftwareLibraryTitle(id: entry.titleID, name: entry.title, identityStatus: "personal", releases: [privateRelease])
|
||||
let publicGame = title("public-game", name: "Public Game", [release("public-edition", category: "Disks/Games")])
|
||||
let titles = [privateTitle, publicGame]
|
||||
XCTAssertEqual(LibraryBrowseQuery(scope: .all, softwareType: "Games").apply(to: titles, favorites: [entry.titleID], installed: [entry.releaseID]).map(\.id), [entry.titleID, publicGame.id])
|
||||
XCTAssertEqual(LibraryBrowseQuery(scope: .all, category: "Games").apply(to: [privateTitle], favorites: [], installed: []).count, 1)
|
||||
for scope in [LibraryBrowseQuery.Scope.started, .showcase, .installed] {
|
||||
XCTAssertTrue(LibraryBrowseQuery(scope: scope).apply(to: [privateTitle], favorites: [entry.titleID], installed: [entry.releaseID]).isEmpty)
|
||||
}
|
||||
XCTAssertEqual(LibraryBrowseQuery(scope: .personal).apply(to: titles, favorites: [], installed: []).map(\.id), [entry.titleID])
|
||||
XCTAssertEqual(LibraryBrowseQuery(scope: .favorites).apply(to: titles, favorites: [entry.titleID], installed: []).map(\.id), [entry.titleID])
|
||||
XCTAssertEqual(LibraryBrowseQuery(scope: .search, text: "Private Game").apply(to: titles, favorites: [], installed: []).map(\.id), [entry.titleID])
|
||||
let companion = SoftwareLibraryCatalog(titles: titles, metadata: [:]).companionDisksOnly
|
||||
XCTAssertEqual(companion.titles.map(\.id), [privateTitle.id, publicGame.id], "The user's local companion can browse their own disks")
|
||||
}
|
||||
func testPersonalGroupIsAlphabeticalBeforeCatalogWithoutMergingSameNames() {
|
||||
func personal(_ name: String, bytes: Int64) -> SoftwareLibraryTitle {
|
||||
var entry = PersonalSoftwareEntry(id: UUID(), title: name, files: [.init(path: "GAME.dsk", kind: "disk", byteSize: bytes, sha256: String(repeating: "a", count: 64))])
|
||||
entry.category = "Games"
|
||||
return .init(id: entry.titleID, name: name, identityStatus: "personal", releases: [entry.release(in: directory)])
|
||||
}
|
||||
let privateA = personal("A Game", bytes: 10000), privateZ = personal("Z Game", bytes: 1)
|
||||
let publicA = title("public-a", name: "A Game", [release("a", bytes: 10)])
|
||||
let publicB = title("public-b", name: "B Game", [release("b", bytes: 50)])
|
||||
for sort in LibraryBrowseQuery.Sort.allCases {
|
||||
let rows = LibraryBrowseQuery(scope: .all, softwareType: "Games", sort: sort).apply(to: [publicA, privateZ, publicB, privateA], favorites: [], installed: [])
|
||||
XCTAssertEqual(Array(rows.prefix(2)).map(\.id), [privateA.id, privateZ.id])
|
||||
XCTAssertTrue(rows[0].isPersonal); XCTAssertFalse(rows[2].isPersonal)
|
||||
XCTAssertEqual(rows.count, 4, "Personal and catalog editions with the same name stay distinct")
|
||||
XCTAssertEqual(Array(rows.suffix(2)).map(\.id), sort == .size ? [publicB.id, publicA.id] : [publicA.id, publicB.id])
|
||||
}
|
||||
XCTAssertTrue(LibraryBrowseQuery(scope: .all, softwareType: "Music").apply(to: [privateA], favorites: [], installed: []).isEmpty)
|
||||
}
|
||||
|
||||
@MainActor
|
||||
func testHeaderSearchEscapesEveryPriorScopeAndFacetsAndResumes() async throws {
|
||||
let support = directory.appendingPathComponent("GlobalSearch")
|
||||
let continuity = LibraryContinuityStore(directory: support)
|
||||
let model = SoftwareLibraryModel(state: .init(directory: support), continuity: continuity)
|
||||
model.restoreBrowseContext()
|
||||
for scope in LibraryBrowseQuery.Scope.allCases where scope != .search {
|
||||
model.query = .init(scope: scope, category: "Disks", softwareType: "Music", media: "cassette", evidence: "checked", sort: .modified)
|
||||
model.setSearchText("Popstar")
|
||||
XCTAssertEqual(model.query, .init(scope: .search, text: "Popstar", sort: .modified))
|
||||
}
|
||||
model.query.media = "disk"; model.setSearchText("Popstar Game")
|
||||
XCTAssertEqual(model.query.media, "disk", "Explicit filters within Search Results survive further typing")
|
||||
model.saveBrowseContext(); await continuity.flush()
|
||||
let resumed = SoftwareLibraryModel(state: .init(directory: support), continuity: LibraryContinuityStore(directory: support))
|
||||
await resumed.load(from: try database()); try await settle(resumed)
|
||||
XCTAssertEqual(resumed.query.scope, .search); XCTAssertEqual(resumed.query.text, "Popstar Game")
|
||||
XCTAssertEqual(resumed.query.media, "disk")
|
||||
model.setSearchText("")
|
||||
XCTAssertEqual(model.query.scope, .all); XCTAssertEqual(model.query.text, "")
|
||||
await model.shutdown(); await resumed.shutdown()
|
||||
}
|
||||
func testAdvancedFacetsMatchTheSameEditionAndKeepUnknownEvidenceHonest() {
|
||||
let disk = release("disk", environment: "os9", processor: "6309", hardware: ["speech-sound": "optional"], videoModes: ["SG-12"])
|
||||
let tape = release("tape", media: "cassette", environment: "basic", processor: "either", hardware: ["joystick": "unspecified"], videoModes: ["6847T1"])
|
||||
@@ -221,6 +283,87 @@ final class SoftwareLibraryBrowseTests: XCTestCase {
|
||||
await state.flush()
|
||||
}
|
||||
@MainActor
|
||||
func testColdResumeRetainsSelectionWhileCatalogRecoveryIsDelayed() async throws {
|
||||
let support = directory.appendingPathComponent("DelayedResume")
|
||||
let state = SoftwareLibraryState(directory: support), continuity = LibraryContinuityStore(directory: support)
|
||||
let query = LibraryBrowseQuery(scope: .all)
|
||||
let encoded = String(decoding: try JSONEncoder().encode(query), as: UTF8.self)
|
||||
continuity.setBrowse(.init(scope: "all", filters: ["browse-query": encoded, "layout": "Table"], selectedID: "other"), for: "software-main")
|
||||
await continuity.flush()
|
||||
let restored = LibraryContinuityStore(directory: support)
|
||||
let model = SoftwareLibraryModel(state: state, continuity: restored), url = try database()
|
||||
let loading = Task { await model.load(from: url, catalogLoader: { url in
|
||||
try await Task.sleep(nanoseconds: 350_000_000)
|
||||
return try await SoftwareLibraryCatalog.load(from: url)
|
||||
}) }
|
||||
for _ in 0..<100 where !model.loading { try await Task.sleep(nanoseconds: 1_000_000) }
|
||||
try await Task.sleep(nanoseconds: 180_000_000) // exceeds the empty-result filter debounce
|
||||
XCTAssertTrue(model.loading)
|
||||
XCTAssertEqual(model.selection, "other")
|
||||
XCTAssertEqual(restored.browse(for: "software-main")?.selectedID, "other", "An empty interim result must not overwrite resume state")
|
||||
await loading.value; try await settle(model)
|
||||
XCTAssertEqual(model.selection, "other"); XCTAssertEqual(model.layout, "Table")
|
||||
XCTAssertEqual(model.selectedRow?.name, "Other Game")
|
||||
await model.shutdown()
|
||||
}
|
||||
@MainActor
|
||||
func testFailedCatalogReadKeepsPublicResumePendingForRetry() async throws {
|
||||
let support = directory.appendingPathComponent("FailedResume")
|
||||
let state = SoftwareLibraryState(directory: support), continuity = LibraryContinuityStore(directory: support)
|
||||
let encoded = String(decoding: try JSONEncoder().encode(LibraryBrowseQuery(scope: .all)), as: UTF8.self)
|
||||
continuity.setBrowse(.init(scope: "all", filters: ["browse-query": encoded], selectedID: "other"), for: "software-main")
|
||||
let model = SoftwareLibraryModel(state: state, continuity: continuity), url = try database()
|
||||
await model.load(from: url, catalogLoader: { _ in throw CocoaError(.fileReadNoPermission) })
|
||||
try await settle(model)
|
||||
XCTAssertNotNil(model.error); XCTAssertNil(model.catalog)
|
||||
XCTAssertEqual(model.selection, "other")
|
||||
XCTAssertEqual(continuity.browse(for: "software-main")?.selectedID, "other")
|
||||
await model.load(from: url); try await settle(model)
|
||||
XCTAssertNil(model.error); XCTAssertEqual(model.selection, "other")
|
||||
XCTAssertEqual(model.selectedRow?.name, "Other Game")
|
||||
await model.shutdown()
|
||||
}
|
||||
@MainActor
|
||||
func testPrivateScopeRemainsUsableWhenPublicCatalogCannotLoad() async throws {
|
||||
let support = directory.appendingPathComponent("PrivateWithoutCatalog")
|
||||
let state = SoftwareLibraryState(directory: support), continuity = LibraryContinuityStore(directory: support)
|
||||
let encoded = String(decoding: try JSONEncoder().encode(LibraryBrowseQuery(scope: .personal)), as: UTF8.self)
|
||||
continuity.setBrowse(.init(scope: "personal", filters: ["browse-query": encoded], selectedID: "personal:missing"), for: "software-main")
|
||||
let model = SoftwareLibraryModel(state: state, continuity: continuity)
|
||||
let source = directory.appendingPathComponent("LOCAL.ccc"); try Data([0x12,0x39]).write(to: source)
|
||||
let draft = try await model.personalStore.inspect([source]), entry = try await model.personalStore.save(draft)
|
||||
await model.load(from: directory.appendingPathComponent("Unavailable.sqlite"), catalogLoader: { _ in throw CocoaError(.fileReadNoSuchFile) })
|
||||
try await settle(model)
|
||||
XCTAssertNil(model.catalog); XCTAssertNotNil(model.error)
|
||||
XCTAssertEqual(model.query.scope, .personal); XCTAssertEqual(model.selectedRow?.id, entry.titleID)
|
||||
await model.shutdown()
|
||||
}
|
||||
@MainActor
|
||||
func testPersonalSaveDuringColdCatalogLoadWinsOverResumedPublicScope() async throws {
|
||||
let support = directory.appendingPathComponent("PersonalDuringLoad")
|
||||
let state = SoftwareLibraryState(directory: support), continuity = LibraryContinuityStore(directory: support)
|
||||
let encoded = String(decoding: try JSONEncoder().encode(LibraryBrowseQuery(scope: .all)), as: UTF8.self)
|
||||
continuity.setBrowse(.init(scope: "all", filters: ["browse-query": encoded], selectedID: "other"), for: "software-main")
|
||||
let model = SoftwareLibraryModel(state: state, continuity: continuity), url = try database()
|
||||
let source = directory.appendingPathComponent("AUTHORED.ccc")
|
||||
try Data([0x12,0x39]).write(to: source)
|
||||
let draft = try await model.personalStore.inspect([source]), entry = try await model.personalStore.save(draft)
|
||||
let loading = Task { await model.load(from: url, catalogLoader: { url in
|
||||
try await Task.sleep(nanoseconds: 500_000_000)
|
||||
return try await SoftwareLibraryCatalog.load(from: url)
|
||||
}) }
|
||||
for _ in 0..<100 where !model.loading { try await Task.sleep(nanoseconds: 1_000_000) }
|
||||
try await Task.sleep(nanoseconds: 150_000_000)
|
||||
model.editPersonal(entry); model.savePersonal(entry, allowDuplicate: false)
|
||||
for _ in 0..<100 where model.personalSaving { try await Task.sleep(nanoseconds: 5_000_000) }
|
||||
XCTAssertEqual(model.query.scope, .personal); XCTAssertEqual(model.selection, entry.titleID)
|
||||
await loading.value; try await settle(model)
|
||||
XCTAssertEqual(model.query.scope, .personal); XCTAssertEqual(model.selection, entry.titleID)
|
||||
XCTAssertEqual(model.selectedRow?.id, entry.titleID)
|
||||
await model.shutdown()
|
||||
XCTAssertEqual(continuity.browse(for: "software-main")?.selectedID, entry.titleID)
|
||||
}
|
||||
@MainActor
|
||||
func testRapidQueriesAndFavoriteChangesPublishLatestResults() async throws {
|
||||
let state = SoftwareLibraryState(directory: directory.appendingPathComponent("Personal"))
|
||||
let model = SoftwareLibraryModel(state: state)
|
||||
|
||||
Reference in new issue
Block a user