301 lines
22 KiB
Swift
301 lines
22 KiB
Swift
// SPDX-License-Identifier: GPL-3.0-or-later
|
|
import XCTest
|
|
import SQLite3
|
|
|
|
final class SoftwareLibraryBrowseTests: XCTestCase {
|
|
private var directory: URL!
|
|
private let starter = "authored-curated-edition"
|
|
override func setUpWithError() throws {
|
|
directory = FileManager.default.temporaryDirectory.appendingPathComponent("LibraryBrowse-" + UUID().uuidString)
|
|
try FileManager.default.createDirectory(at: directory, withIntermediateDirectories: true)
|
|
}
|
|
override func tearDownWithError() throws { try? FileManager.default.removeItem(at: directory) }
|
|
private func release(_ id: String, title: String = "game", name: String = "Example", category: String = "Disks/Games", media: String = "disk", system: String = "CoCo 3", status: String = "source-ready", note: String? = nil, bytes: Int64 = 100, date: String? = nil, assets: [SoftwareLibraryAsset] = [], environment: String = "unknown", processor: String = "unknown", hardware: [String: String] = [:], videoModes: [String] = ["SG-12"], gettingStarted: Bool = false) -> SoftwareLibraryRelease {
|
|
SoftwareLibraryRelease(id: id, titleID: title, name: name, category: category, mediaType: media, contentRole: "software", sourceURL: URL(string: "https://colorcomputerarchive.com/\(id)")!, modifiedAt: date, modifiedPrecision: date == nil ? nil : "minute", modifiedTimezone: nil, packageSHA256: String(repeating: "a", count: 64), byteSize: bytes, languageStatus: "unknown", metadata: .object(["getting_started": .bool(gettingStarted), "system": .string(system), "publisher": .string("Test Publisher"), "video_modes": .array(videoModes.map(LibraryJSON.string))]), setup: SoftwareLibrarySetup(status: status, command: nil, instructions: "Mount selected media.", configuration: .object(["browse_environment": .string(environment), "processor_requirement": .string(processor), "hardware_support": .object(hardware.mapValues(LibraryJSON.string)), "compatibility_notes": .array(note.map { [.string($0)] } ?? []), "configuration_requirements": .array([])]), selectedMembers: .array([]), reasons: [], validation: .object(["scope": .string("opening-gameplay-and-disk-switching")])), assets: assets, downloadURLs: [])
|
|
}
|
|
private func title(_ id: String, name: String, _ releases: [SoftwareLibraryRelease]) -> SoftwareLibraryTitle {
|
|
SoftwareLibraryTitle(id: id, name: name, identityStatus: "suggested", releases: releases)
|
|
}
|
|
func testCategoryTreePreservesHierarchyAndPrefixBoundaries() {
|
|
let tree = LibraryCategory.tree(["Disks/Games", "Disks/Coco SDC/Games", "Disks/Coco SDC/Music", "Cassettes/Games", "DisksExtra/Tools", "Cartridges"])
|
|
XCTAssertEqual(tree.map(\.id), ["Cartridges", "Cassettes", "Disks", "DisksExtra"])
|
|
XCTAssertNil(tree[0].children)
|
|
let disks = tree[2]
|
|
XCTAssertEqual(disks.children?.map(\.id), ["Disks/Coco SDC", "Disks/Games"])
|
|
XCTAssertEqual(disks.children?.first?.children?.map(\.id), ["Disks/Coco SDC/Games", "Disks/Coco SDC/Music"])
|
|
var query = LibraryBrowseQuery(scope: .all); query.category = "Disks"
|
|
XCTAssertTrue(query.matches(release("a", category: "Disks/Coco SDC/Games"), titleName: "A"))
|
|
XCTAssertFalse(query.matches(release("b", category: "DisksExtra/Tools"), titleName: "B"))
|
|
}
|
|
func testSearchAndFacetsApplyToSameVariantWithoutDroppingSiblingEditions() {
|
|
let titles = [title("game", name: "Café Adventure", [
|
|
release("cassette", name: "Cassette original", category: "Cassettes/Games", media: "cassette", system: "CoCo 1/2", note: "SG-12 introduction unverified"),
|
|
release("disk", name: "Disk edition", status: "manual-setup")])]
|
|
var query = LibraryBrowseQuery(scope: .all, text: "cafe publisher sg-12", media: "cassette", system: "CoCo 1/2", evidence: "notes")
|
|
let rows = query.apply(to: titles, favorites: [], installed: [])
|
|
XCTAssertEqual(rows.count, 1)
|
|
XCTAssertEqual(rows[0].matchingReleases.map(\.id), ["cassette"])
|
|
XCTAssertEqual(rows[0].title.releases.count, 2)
|
|
query.evidence = "manual"
|
|
XCTAssertTrue(query.apply(to: titles, favorites: [], installed: []).isEmpty)
|
|
query.media = "disk"; query.system = "CoCo 3"
|
|
XCTAssertEqual(query.apply(to: titles, favorites: [], installed: []).first?.matchingReleases.map(\.id), ["disk"])
|
|
}
|
|
func testStarterMembershipIsEditorialAndFavoritesAndInstalledUseCorrectIdentity() {
|
|
let curated = release("curated", status: "spot-checked", gettingStarted: true)
|
|
let formerID = "6062d9b73d08579671fe0d489c53fdd0"
|
|
let formerStarter = release(formerID, status: "spot-checked")
|
|
let extra = release("another-checked", status: "spot-checked")
|
|
let titles = [title("game", name: "Example", [curated, formerStarter, extra]), title("other", name: "Other", [release("other-release", title: "other")])]
|
|
let starters = LibraryBrowseQuery(scope: .started).apply(to: titles, favorites: [], installed: [])
|
|
XCTAssertEqual(starters.flatMap(\.matchingReleases).map(\.id), ["curated"])
|
|
XCTAssertTrue(LibraryBrowseQuery(scope: .all).apply(to: titles, favorites: [], installed: []).flatMap(\.matchingReleases).contains { $0.id == formerID })
|
|
XCTAssertEqual(LibraryBrowseQuery(scope: .favorites).apply(to: titles, favorites: ["game"], installed: []).map(\.id), ["game"])
|
|
let installed = LibraryBrowseQuery(scope: .installed).apply(to: titles, favorites: [], installed: ["another-checked"])
|
|
XCTAssertEqual(installed.map(\.id), ["game"])
|
|
XCTAssertEqual(installed[0].matchingReleases.map(\.id), ["another-checked"])
|
|
XCTAssertTrue(LibraryBrowseQuery(scope: .installed).apply(to: titles, favorites: [], installed: ["game"]).isEmpty)
|
|
}
|
|
func testCoverCollectionUsesArtworkWithoutPromotingRuntimeEvidence() {
|
|
func asset(_ kind: String) -> SoftwareLibraryAsset {
|
|
var item = SoftwareLibraryAsset(id: kind, name: "Example", kind: kind, sourceURL: URL(string: "https://colorcomputerarchive.com/repo/Media/example.png")!, sha256: nil, byteSize: nil, credit: "Archive contributor", matchStatus: "candidate", matchReason: "Title match")
|
|
item.thumbnailURL = URL(string: "https://vccplus.brianholman.com/dl/software/CoCoLibrary/Artwork/Thumbnails/Manuals/example.png")
|
|
item.thumbnailSHA256 = String(repeating: "a", count: 64)
|
|
item.thumbnailByteSize = 100
|
|
return item
|
|
}
|
|
let titles = [title("manual", name: "Manual only", [release("manual", title: "manual", assets: [asset("manual")])]),
|
|
title("cover", name: "Cover", [release("cover", title: "cover", status: "manual-setup", assets: [asset("replacement-label")])]),
|
|
title("screen", name: "Screenshot", [release("screen", title: "screen", assets: [asset("screenshot")])]),
|
|
title("none", name: "No art", [release("none", title: "none")])]
|
|
XCTAssertEqual(LibraryBrowseQuery().scope, .started)
|
|
let query = LibraryBrowseQuery(scope: .showcase)
|
|
let rows = query.apply(to: titles, favorites: [], installed: [])
|
|
XCTAssertEqual(rows.map(\.id), ["cover", "manual", "screen"])
|
|
XCTAssertEqual(rows[0].matchingReleases[0].setup.status, "manual-setup")
|
|
XCTAssertEqual(rows[0].matchingReleases[0].assets[0].matchStatus, "candidate")
|
|
XCTAssertTrue(LibraryBrowseQuery(scope: .started).apply(to: titles, favorites: [], installed: []).isEmpty)
|
|
}
|
|
func testSoftwareTypesSpanFormatsAndRetainMachineAndFormatConstraints() {
|
|
let disk = release("disk", category: "Disks/Games")
|
|
let cassette = release("tape", category: "Cassettes/Games", media: "cassette", system: "CoCo 1/2")
|
|
let sdc = release("sdc", category: "Disks/Coco SDC/OS-9/Level 2/Games", media: "sdc")
|
|
let cartridge = release("cart", category: "Cartridges", media: "cartridge")
|
|
let music = release("music", category: "Disks/Coco SDC/Music", media: "sdc")
|
|
let titles = [title("game", name: "Game", [disk, cassette, sdc, cartridge]), title("music", name: "Music", [music])]
|
|
var query = LibraryBrowseQuery(scope: .all, softwareType: "Games")
|
|
XCTAssertEqual(query.apply(to: titles, favorites: [], installed: []).flatMap(\.matchingReleases).map(\.id), ["disk", "tape", "sdc", "cart"])
|
|
query.system = "CoCo 3"; query.media = "sdc"
|
|
XCTAssertEqual(query.apply(to: titles, favorites: [], installed: []).flatMap(\.matchingReleases).map(\.id), ["sdc"])
|
|
query.softwareType = "Music"
|
|
XCTAssertEqual(query.apply(to: titles, favorites: [], installed: []).flatMap(\.matchingReleases).map(\.id), ["music"])
|
|
XCTAssertEqual(LibraryBrowseQuery.type(of: cartridge), "Other", "An unclassified cartridge is not assumed to be a game")
|
|
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 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"])
|
|
let titles = [title("game", name: "Example", [disk, tape])]
|
|
var query = LibraryBrowseQuery(scope: .all)
|
|
query.environment = "os9"; query.processor = "6309"; query.hardware = "speech-sound"
|
|
query.hardwareUse = "optional"; query.displayFeature = "semigraphics"
|
|
XCTAssertEqual(query.apply(to: titles, favorites: [], installed: []).first?.matchingReleases.map(\.id), ["disk"])
|
|
query.hardware = "joystick"; query.hardwareUse = ""
|
|
XCTAssertTrue(query.apply(to: titles, favorites: [], installed: []).isEmpty, "Do not combine evidence from sibling editions")
|
|
query = LibraryBrowseQuery(scope: .all); query.processor = "6309"
|
|
XCTAssertFalse(query.matches(tape, titleName: "Example"), "Supports both is not 6309 required")
|
|
XCTAssertFalse(query.matches(release("unknown"), titleName: "Unknown"))
|
|
query.processor = ""; query.hardware = "joystick"; query.hardwareUse = "required"
|
|
XCTAssertFalse(query.matches(tape, titleName: "Example"), "A suggested joystick is not mandatory")
|
|
query.hardwareUse = "unspecified"
|
|
XCTAssertTrue(query.matches(tape, titleName: "Example"))
|
|
query.hardware = ""; query.hardwareUse = ""; query.displayFeature = "semigraphics"
|
|
XCTAssertFalse(query.matches(tape, titleName: "Example"), "6847T1 is not a semigraphics tag")
|
|
XCTAssertEqual(tape.videoBadges, ["6847T1"])
|
|
query.displayFeature = "SG-12"
|
|
XCTAssertTrue(query.matches(disk, titleName: "Example"))
|
|
query.displayFeature = "SG-24"
|
|
XCTAssertFalse(query.matches(disk, titleName: "Example"))
|
|
query.environment = "os9"; query.processor = "6309"; query.hardware = "speech-sound"; query.hardwareUse = "optional"
|
|
XCTAssertEqual(query.additionalFilterLabels, ["OS-9 / NitrOS-9", "Requires Hitachi 6309", "Speech/Sound — Optional", "Semigraphics-24"])
|
|
}
|
|
func testSortUsesMatchingEditionAndKeepsUnknownDatesLast() {
|
|
let titles = [title("a", name: "A", [release("a1", title: "a", bytes: 20), release("a2", title: "a", media: "cassette", bytes: 900, date: "2026-01-01")]),
|
|
title("b", name: "B", [release("b1", title: "b", bytes: 100, date: "2020-01-01")])]
|
|
var query = LibraryBrowseQuery(scope: .all, media: "disk", sort: .modified)
|
|
XCTAssertEqual(query.apply(to: titles, favorites: [], installed: []).map(\.id), ["b", "a"])
|
|
query.sort = .size
|
|
XCTAssertEqual(query.apply(to: titles, favorites: [], installed: []).map(\.id), ["b", "a"])
|
|
query.media = ""
|
|
XCTAssertEqual(query.apply(to: titles, favorites: [], installed: []).map(\.id), ["a", "b"])
|
|
}
|
|
private func database() throws -> URL {
|
|
let url = directory.appendingPathComponent("catalog.sqlite")
|
|
var db: OpaquePointer?
|
|
XCTAssertEqual(sqlite3_open(url.path, &db), SQLITE_OK)
|
|
defer { sqlite3_close(db) }
|
|
let sql = """
|
|
PRAGMA user_version=1;
|
|
CREATE TABLE metadata(key TEXT,value TEXT);
|
|
INSERT INTO metadata VALUES('schema_version','1'),('recipe_contract','2');
|
|
CREATE TABLE title(id TEXT,name TEXT,identity_status TEXT);
|
|
INSERT INTO title VALUES('game','Example Game','suggested'),('other','Other Game','suggested');
|
|
CREATE TABLE package(sha256 TEXT,byte_size INTEGER);
|
|
INSERT INTO package VALUES('\(String(repeating: "a", count: 64))',123);
|
|
CREATE TABLE release(id TEXT,title_id TEXT,name TEXT,category TEXT,media_type TEXT,content_role TEXT,source_url TEXT,modified_at TEXT,modified_precision TEXT,modified_timezone TEXT,package_sha256 TEXT,language_status TEXT,metadata_json TEXT);
|
|
CREATE TABLE setup(release_id TEXT,status TEXT,command TEXT,instructions TEXT,configuration_json TEXT,selected_members_json TEXT,reasons_json TEXT,validation_json TEXT);
|
|
CREATE TABLE asset(id TEXT,name TEXT,kind TEXT,source_url TEXT,sha256 TEXT,byte_size INTEGER,credit TEXT);
|
|
CREATE TABLE release_asset(release_id TEXT,asset_id TEXT,status TEXT,reason TEXT);
|
|
CREATE TABLE download_location(package_sha256 TEXT,url TEXT,priority INTEGER);
|
|
"""
|
|
XCTAssertEqual(sqlite3_exec(db, sql, nil, nil, nil), SQLITE_OK)
|
|
for (id, title, name, media, category) in [(starter, "game", "SDC Edition", "sdc", "Disks/Coco SDC/Games"), ("cassette", "game", "Cassette Original", "cassette", "Cassettes/Games"), ("other", "other", "Other Game", "disk", "Disks/Games")] {
|
|
let rows = """
|
|
INSERT INTO release VALUES('\(id)','\(title)','\(name)','\(category)','\(media)','software','https://colorcomputerarchive.com/\(id)',NULL,NULL,NULL,'\(String(repeating: "a", count: 64))','unknown','{"system":"CoCo 3","getting_started":\(id == starter ? "true" : "false")}');
|
|
INSERT INTO setup VALUES('\(id)','spot-checked',NULL,'Mount selected media.','{"browse_environment":"disk-basic","processor_requirement":"\(media == "sdc" ? "6309" : "unknown")","hardware_support":{"joystick":"unspecified"}}','[]','[]','{}');
|
|
"""
|
|
XCTAssertEqual(sqlite3_exec(db, rows, nil, nil, nil), SQLITE_OK)
|
|
}
|
|
return url
|
|
}
|
|
@MainActor private func settle(_ model: SoftwareLibraryModel) async throws {
|
|
for _ in 0..<200 {
|
|
try await Task.sleep(nanoseconds: 10_000_000)
|
|
if !model.filtering && !model.loading { return }
|
|
}
|
|
XCTFail("Library query did not settle")
|
|
}
|
|
@MainActor
|
|
func testPreferredReleaseCannotBypassScopeAndExplicitChoiceClearsConflictingSearch() async throws {
|
|
let state = SoftwareLibraryState(directory: directory.appendingPathComponent("Personal"))
|
|
state.selectRelease("cassette", for: "game")
|
|
let model = SoftwareLibraryModel(state: state)
|
|
model.query.scope = .started
|
|
await model.load(from: try database()); try await settle(model)
|
|
XCTAssertEqual(model.selectedRelease?.id, starter, "A previously preferred edition must not bypass Getting Started")
|
|
model.query = LibraryBrowseQuery(scope: .all, text: "sdc", category: "Disks", media: "sdc")
|
|
try await settle(model)
|
|
XCTAssertEqual(model.selectedRelease?.id, starter)
|
|
model.chooseRelease("cassette")
|
|
try await settle(model)
|
|
XCTAssertEqual(model.selectedRelease?.id, "cassette")
|
|
XCTAssertEqual(model.query.text, "")
|
|
XCTAssertEqual(model.query.category, "")
|
|
XCTAssertEqual(state.preferredReleaseID(for: "game"), "cassette")
|
|
model.query.scope = .started; try await settle(model)
|
|
XCTAssertEqual(model.selectedRelease?.id, starter)
|
|
model.chooseRelease("cassette"); try await settle(model)
|
|
XCTAssertEqual(model.query.scope, .all)
|
|
XCTAssertEqual(model.selectedRelease?.id, "cassette")
|
|
await state.flush()
|
|
}
|
|
@MainActor
|
|
func testEditionChoiceRetainsSharedTitleSearchAndCompatibleFacets() async throws {
|
|
let state = SoftwareLibraryState(directory: directory.appendingPathComponent("Personal"))
|
|
let model = SoftwareLibraryModel(state: state)
|
|
model.query = LibraryBrowseQuery(scope: .all, text: "Example Game", category: "Disks", media: "sdc", system: "CoCo 3", evidence: "checked")
|
|
await model.load(from: try database()); try await settle(model)
|
|
XCTAssertEqual(model.rows.map(\.id), ["game"])
|
|
XCTAssertEqual(model.selectedRelease?.id, starter)
|
|
model.query.environment = "disk-basic"; model.query.processor = "6309"
|
|
model.query.hardware = "joystick"; model.query.hardwareUse = "unspecified"
|
|
try await settle(model)
|
|
model.chooseRelease(starter)
|
|
try await settle(model)
|
|
XCTAssertEqual(model.query.category, "Disks", "A matching ancestor category should be preserved")
|
|
XCTAssertEqual(model.query.media, "sdc")
|
|
model.chooseRelease("cassette")
|
|
try await settle(model)
|
|
XCTAssertEqual(model.selectedRelease?.id, "cassette")
|
|
XCTAssertEqual(model.rows.map(\.id), ["game"], "Changing editions should not discard a shared title search")
|
|
XCTAssertEqual(model.query.text, "Example Game")
|
|
XCTAssertEqual(model.query.system, "CoCo 3")
|
|
XCTAssertEqual(model.query.evidence, "checked")
|
|
XCTAssertEqual(model.query.category, "", "Only the conflicting category should be cleared")
|
|
XCTAssertEqual(model.query.media, "", "Only the conflicting format should be cleared")
|
|
XCTAssertEqual(model.query.processor, "", "Clear the incompatible processor requirement")
|
|
XCTAssertEqual(model.query.environment, "disk-basic")
|
|
XCTAssertEqual(model.query.hardware, "joystick")
|
|
XCTAssertEqual(model.query.hardwareUse, "unspecified")
|
|
await state.flush()
|
|
}
|
|
@MainActor
|
|
func testRapidQueriesAndFavoriteChangesPublishLatestResults() async throws {
|
|
let state = SoftwareLibraryState(directory: directory.appendingPathComponent("Personal"))
|
|
let model = SoftwareLibraryModel(state: state)
|
|
await model.load(from: try database()); try await settle(model)
|
|
for text in ["none", "cassette", "sdc", "missing", "other"] { model.query = LibraryBrowseQuery(scope: .all, text: text) }
|
|
try await settle(model)
|
|
XCTAssertEqual(model.rows.map(\.id), ["other"])
|
|
XCTAssertEqual(model.selection, "other")
|
|
try await Task.sleep(nanoseconds: 200_000_000)
|
|
XCTAssertEqual(model.rows.map(\.id), ["other"], "A stale search must not replace the newest result")
|
|
model.query = LibraryBrowseQuery(scope: .favorites)
|
|
state.toggleFavorite("game")
|
|
try await settle(model)
|
|
XCTAssertEqual(model.rows.map(\.id), ["game"])
|
|
state.toggleFavorite("game"); try await settle(model)
|
|
XCTAssertTrue(model.rows.isEmpty)
|
|
XCTAssertNil(model.selection)
|
|
XCTAssertNil(model.selectedRelease)
|
|
await state.flush()
|
|
}
|
|
@MainActor
|
|
func testSidebarNavigationReplacesOldCategoryAndTypeButKeepsSearchAndFacets() async throws {
|
|
let state = SoftwareLibraryState(directory: directory.appendingPathComponent("Navigation"))
|
|
let model = SoftwareLibraryModel(state: state)
|
|
await model.load(from: try database()); try await settle(model)
|
|
model.query = LibraryBrowseQuery(scope: .showcase, text: "Example", media: "sdc", system: "CoCo 3", evidence: "checked", sort: .size)
|
|
model.browseType("Educational"); try await settle(model)
|
|
XCTAssertTrue(model.rows.isEmpty)
|
|
XCTAssertNil(model.selectedRelease)
|
|
model.browse(.all); try await settle(model)
|
|
XCTAssertEqual(model.rows.map(\.id), ["game"])
|
|
XCTAssertEqual(model.query.softwareType, "")
|
|
XCTAssertEqual(model.query.text, "Example")
|
|
XCTAssertEqual(model.query.media, "sdc")
|
|
XCTAssertEqual(model.query.system, "CoCo 3")
|
|
XCTAssertEqual(model.query.evidence, "checked")
|
|
XCTAssertEqual(model.query.sort, .size)
|
|
model.browseType("Educational")
|
|
model.browse(.all, category: "Disks"); try await settle(model)
|
|
XCTAssertEqual(model.query.softwareType, "")
|
|
XCTAssertEqual(model.query.category, "Disks")
|
|
XCTAssertEqual(model.rows.map(\.id), ["game"])
|
|
model.browseType("Games"); try await settle(model)
|
|
XCTAssertEqual(model.query.category, "")
|
|
model.browse(.showcase)
|
|
XCTAssertEqual(model.query.softwareType, "")
|
|
for scope in [LibraryBrowseQuery.Scope.started, .favorites, .installed] {
|
|
model.browseType("Educational"); model.browse(scope)
|
|
XCTAssertEqual(model.query.softwareType, "")
|
|
XCTAssertEqual(model.query.category, "")
|
|
}
|
|
await state.flush()
|
|
}
|
|
@MainActor
|
|
func testClearFiltersPreservesSearchFolderSortAndPresentation() async throws {
|
|
let state = SoftwareLibraryState(directory: directory.appendingPathComponent("Clear"))
|
|
let model = SoftwareLibraryModel(state: state)
|
|
model.layout = "Table"
|
|
model.query = LibraryBrowseQuery(scope: .all, text: "Example", category: "Disks", softwareType: "Games", media: "sdc", system: "CoCo 3", evidence: "checked", sort: .modified)
|
|
model.query.environment = "os9"; model.query.processor = "6309"
|
|
model.query.hardware = "joystick"; model.query.hardwareUse = "required"; model.query.displayFeature = "SG-12"
|
|
model.clearFilters()
|
|
XCTAssertTrue(model.query.additionalFilterLabels.isEmpty)
|
|
XCTAssertEqual(model.query.hardwareUse, "")
|
|
XCTAssertEqual(model.query.text, "Example")
|
|
XCTAssertEqual(model.query.category, "Disks")
|
|
XCTAssertEqual(model.query.scope, .all)
|
|
XCTAssertEqual(model.query.sort, .modified)
|
|
XCTAssertEqual(model.layout, "Table")
|
|
XCTAssertEqual(model.query.softwareType, "")
|
|
XCTAssertEqual(model.query.media, "")
|
|
XCTAssertEqual(model.query.system, "")
|
|
XCTAssertEqual(model.query.evidence, "")
|
|
await state.flush()
|
|
}
|
|
|
|
}
|