Initial Commit

This commit is contained in:
Mark Gregory
2026-11-03 12:53:05 +00:00
commit 83acfc63c9
136 changed files with 19465 additions and 0 deletions
File diff suppressed because it is too large Load Diff
@@ -0,0 +1,286 @@
import Foundation
import SQLite3
struct Song: Identifiable, Hashable {
var id: Int64
var title: String
var audio: String
var cdg: String?
var rating: Int
var plays: Int
var artist: String = ""
var album: String = ""
var label: String = ""
var duration: Double = 0
}
struct MusicStore: Identifiable, Hashable {
var id: Int64
var name: String
var url: String
var searchTemplate: String
func destination(query: String = "") throws -> URL {
let query = query.trimmingCharacters(in:.whitespacesAndNewlines)
let encoded = query.addingPercentEncoding(withAllowedCharacters:CharacterSet(charactersIn:"abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789-._~")) ?? ""
let value = query.isEmpty || searchTemplate.isEmpty ? url : searchTemplate.replacingOccurrences(of:"{query}",with:encoded)
guard let result = URL(string:value), ["http","https"].contains(result.scheme?.lowercased() ?? ""), result.host?.isEmpty == false, result.user == nil, result.password == nil else { throw LibraryError.message("Use a valid http:// or https:// store URL without credentials") }
return result
}
}
struct PersonPlace: Identifiable, Hashable { var id: Int64; var name: String }
struct SongPreference: Equatable {
var pitch: Double = 0
var tempo: Double = 1
var rating: Int = 0
}
struct Performance: Identifiable {
var id: Int64
var song: String
var singer: String
var venue: String
var date: String
var singerID: Int64?
var songID: Int64?
}
struct QueueEntry: Identifiable {
var id: Int64
var songID: Int64
var singerID: Int64?
var title: String
var singer: String
}
enum LibraryError: LocalizedError {
case message(String)
var errorDescription: String? { if case .message(let s) = self { return s }; return nil }
}
final class Library {
private var db: OpaquePointer?
init(url: URL) throws {
guard sqlite3_open(url.path, &db) == SQLITE_OK else { throw LibraryError.message("Cannot open library") }
try execute("PRAGMA foreign_keys=ON")
try execute("CREATE TABLE IF NOT EXISTS songs(id INTEGER PRIMARY KEY,title TEXT NOT NULL,audio TEXT UNIQUE NOT NULL,cdg TEXT,rating INTEGER NOT NULL DEFAULT 0 CHECK(rating BETWEEN 0 AND 5),plays INTEGER NOT NULL DEFAULT 0)")
try execute("CREATE TABLE IF NOT EXISTS singers(id INTEGER PRIMARY KEY,name TEXT UNIQUE NOT NULL)")
try execute("CREATE TABLE IF NOT EXISTS venues(id INTEGER PRIMARY KEY,name TEXT UNIQUE NOT NULL)")
try execute("CREATE TABLE IF NOT EXISTS history(id INTEGER PRIMARY KEY,song INTEGER REFERENCES songs(id),singer INTEGER REFERENCES singers(id),venue INTEGER REFERENCES venues(id),played TEXT DEFAULT CURRENT_TIMESTAMP)")
// Additive migration: preserve older libraries and infer existing memberships from history.
for column in ["artist", "album", "label"] {
if try !columns("songs").contains(column) { try execute("ALTER TABLE songs ADD COLUMN \(column) TEXT NOT NULL DEFAULT ''") }
}
try execute("CREATE TABLE IF NOT EXISTS venue_singers(venue INTEGER NOT NULL REFERENCES venues(id) ON DELETE CASCADE,singer INTEGER NOT NULL REFERENCES singers(id) ON DELETE CASCADE,PRIMARY KEY(venue,singer))")
if try schemaVersion() < 3 { try execute("INSERT OR IGNORE INTO venue_singers SELECT DISTINCT venue,singer FROM history WHERE venue IS NOT NULL AND singer IS NOT NULL") }
try execute("CREATE TABLE IF NOT EXISTS settings(key TEXT PRIMARY KEY,value TEXT)")
try execute("CREATE TABLE IF NOT EXISTS preferences(song INTEGER NOT NULL REFERENCES songs(id) ON DELETE CASCADE,singer INTEGER NOT NULL REFERENCES singers(id) ON DELETE CASCADE,pitch REAL NOT NULL DEFAULT 0 CHECK(pitch BETWEEN -12 AND 12),tempo REAL NOT NULL DEFAULT 1 CHECK(tempo BETWEEN 0.5 AND 1.5),rating INTEGER NOT NULL DEFAULT 0 CHECK(rating BETWEEN 0 AND 5),PRIMARY KEY(song,singer))")
try execute("CREATE TABLE IF NOT EXISTS queue(id INTEGER PRIMARY KEY,venue INTEGER REFERENCES venues(id) ON DELETE CASCADE,song INTEGER NOT NULL REFERENCES songs(id) ON DELETE CASCADE,singer INTEGER REFERENCES singers(id) ON DELETE CASCADE,position INTEGER NOT NULL)")
try execute("CREATE TABLE IF NOT EXISTS playlists(id INTEGER PRIMARY KEY,name TEXT UNIQUE NOT NULL)")
try execute("CREATE TABLE IF NOT EXISTS playlist_songs(playlist INTEGER NOT NULL REFERENCES playlists(id) ON DELETE CASCADE,song INTEGER NOT NULL REFERENCES songs(id) ON DELETE CASCADE,position INTEGER NOT NULL,PRIMARY KEY(playlist,song))")
try execute("CREATE TABLE IF NOT EXISTS singer_songs(singer INTEGER NOT NULL REFERENCES singers(id) ON DELETE CASCADE,song INTEGER NOT NULL REFERENCES songs(id) ON DELETE CASCADE,position INTEGER NOT NULL,PRIMARY KEY(singer,song))")
if try schemaVersion() < 4 {
try execute("INSERT OR IGNORE INTO singer_songs(singer,song,position) SELECT singer,song,MIN(id) FROM history WHERE singer IS NOT NULL AND song IS NOT NULL GROUP BY singer,song")
try execute("INSERT OR IGNORE INTO singer_songs(singer,song,position) SELECT singer,song,0 FROM preferences")
}
if try !columns("songs").contains("duration") { try execute("ALTER TABLE songs ADD COLUMN duration REAL NOT NULL DEFAULT 0") }
if try !columns("singer_songs").contains("favourite") { try execute("ALTER TABLE singer_songs ADD COLUMN favourite INTEGER NOT NULL DEFAULT 0 CHECK(favourite IN (0,1))") }
if try schemaVersion() < 5 { try execute("UPDATE singer_songs SET favourite=1 WHERE EXISTS(SELECT 1 FROM preferences WHERE preferences.singer=singer_songs.singer AND preferences.song=singer_songs.song AND preferences.rating>=4)") }
try execute("CREATE TABLE IF NOT EXISTS song_settings(song INTEGER PRIMARY KEY REFERENCES songs(id) ON DELETE CASCADE,pitch REAL NOT NULL DEFAULT 0 CHECK(pitch BETWEEN -12 AND 12),tempo REAL NOT NULL DEFAULT 1 CHECK(tempo BETWEEN 0.5 AND 1.5))")
try execute("CREATE TABLE IF NOT EXISTS music_stores(id INTEGER PRIMARY KEY,name TEXT UNIQUE NOT NULL,url TEXT NOT NULL,search_template TEXT NOT NULL DEFAULT '')")
if try !columns("songs").contains("metadata_edited") { try execute("ALTER TABLE songs ADD COLUMN metadata_edited INTEGER NOT NULL DEFAULT 0") }
try execute("PRAGMA user_version=6")
}
deinit { sqlite3_close(db) }
private func statement(_ sql: String, _ values: [String?]) throws -> OpaquePointer {
var s: OpaquePointer?
guard sqlite3_prepare_v2(db, sql, -1, &s, nil) == SQLITE_OK, let s else { throw error() }
for (i,v) in values.enumerated() {
let code = v.map { sqlite3_bind_text(s, Int32(i + 1), $0, -1, unsafeBitCast(-1, to: sqlite3_destructor_type.self)) } ?? sqlite3_bind_null(s, Int32(i + 1))
if code != SQLITE_OK { sqlite3_finalize(s); throw error() }
}
return s
}
private func error() -> LibraryError { .message(String(cString: sqlite3_errmsg(db))) }
func execute(_ sql: String, _ values: [String?] = []) throws {
let s = try statement(sql, values); defer { sqlite3_finalize(s) }
guard sqlite3_step(s) == SQLITE_DONE else { throw error() }
}
func songs() throws -> [Song] {
let s = try statement("SELECT id,title,audio,cdg,rating,plays,artist,album,label,duration FROM songs ORDER BY title COLLATE NOCASE", []); defer { sqlite3_finalize(s) }
var result = [Song]()
while true {
let code = sqlite3_step(s); if code == SQLITE_DONE { break }; guard code == SQLITE_ROW else { throw error() }
result.append(Song(id: sqlite3_column_int64(s,0), title: String(cString: sqlite3_column_text(s,1)), audio: String(cString: sqlite3_column_text(s,2)), cdg: sqlite3_column_text(s,3).map { String(cString:$0) }, rating: Int(sqlite3_column_int(s,4)), plays: Int(sqlite3_column_int(s,5)), artist: text(s,6), album: text(s,7), label: text(s,8),duration:sqlite3_column_double(s,9)))
}
return result
}
func add(title: String, audio: String, cdg: String?, artist: String = "", album: String = "", label: String = "", duration: Double = 0) throws {
try execute("INSERT INTO songs(title,audio,cdg,artist,album,label,duration) VALUES(?,?,?,?,?,?,?) ON CONFLICT(audio) DO UPDATE SET cdg=COALESCE(excluded.cdg,songs.cdg),artist=CASE WHEN songs.metadata_edited=0 AND excluded.artist!='' THEN excluded.artist ELSE songs.artist END,album=CASE WHEN songs.metadata_edited=0 AND excluded.album!='' THEN excluded.album ELSE songs.album END,label=CASE WHEN songs.metadata_edited=0 AND excluded.label!='' THEN excluded.label ELSE songs.label END,duration=CASE WHEN excluded.duration>0 THEN excluded.duration ELSE songs.duration END", [title,audio,cdg,artist,album,label,String(duration)])
}
func rate(_ id: Int64, _ rating: Int) throws { try execute("UPDATE songs SET rating=? WHERE id=?", [String(rating),String(id)]) }
func entities(_ table: String) throws -> [PersonPlace] {
precondition(["singers","venues","playlists"].contains(table))
let s = try statement("SELECT id,name FROM \(table) ORDER BY name", []); defer { sqlite3_finalize(s) }
var rows = [PersonPlace]()
while sqlite3_step(s) == SQLITE_ROW { rows.append(.init(id: sqlite3_column_int64(s,0), name: String(cString: sqlite3_column_text(s,1)))) }
return rows
}
func addEntity(_ table: String, name: String) throws {
precondition(["singers","venues","playlists"].contains(table))
let name = name.trimmingCharacters(in: .whitespacesAndNewlines)
guard !name.isEmpty else { throw LibraryError.message("Enter a name") }
try execute("INSERT OR IGNORE INTO \(table)(name) VALUES(?)", [name])
}
func record(_ song: Int64, singer: Int64?, venue: Int64?) throws {
try execute("BEGIN IMMEDIATE")
do {
if let singer { try assignSong(song,singer:singer) }
try execute("INSERT INTO history(song,singer,venue) VALUES(?,?,?)", [String(song),singer.map(String.init),venue.map(String.init)])
try execute("UPDATE songs SET plays=plays+1 WHERE id=?", [String(song)])
try execute("COMMIT")
} catch { try? execute("ROLLBACK"); throw error }
}
private func text(_ s: OpaquePointer, _ index: Int32) -> String { sqlite3_column_text(s,index).map { String(cString:$0) } ?? "" }
private func schemaVersion() throws -> Int {
let s = try statement("PRAGMA user_version",[]); defer { sqlite3_finalize(s) }
return sqlite3_step(s) == SQLITE_ROW ? Int(sqlite3_column_int(s,0)) : 0
}
private func columns(_ table: String) throws -> Set<String> {
let s = try statement("PRAGMA table_info(\(table))", []); defer { sqlite3_finalize(s) }
var result = Set<String>(); while sqlite3_step(s) == SQLITE_ROW { result.insert(text(s,1)) }; return result
}
func members(of venue: Int64) throws -> [PersonPlace] {
let s = try statement("SELECT singers.id,singers.name FROM singers JOIN venue_singers ON singers.id=venue_singers.singer WHERE venue=? ORDER BY name", [String(venue)]); defer { sqlite3_finalize(s) }
var result = [PersonPlace](); while sqlite3_step(s) == SQLITE_ROW { result.append(.init(id:sqlite3_column_int64(s,0),name:text(s,1))) }; return result
}
func setMembership(singer: Int64, venue: Int64, included: Bool) throws {
try execute(included ? "INSERT OR IGNORE INTO venue_singers(venue,singer) VALUES(?,?)" : "DELETE FROM venue_singers WHERE venue=? AND singer=?", [String(venue),String(singer)])
if !included { try execute("DELETE FROM queue WHERE venue=? AND singer=?",[String(venue),String(singer)]) }
}
func currentVenue() throws -> Int64? {
let s = try statement("SELECT venues.id FROM venues JOIN settings ON CAST(settings.value AS INTEGER)=venues.id WHERE settings.key='currentVenue'", []); defer { sqlite3_finalize(s) }
return sqlite3_step(s) == SQLITE_ROW ? sqlite3_column_int64(s,0) : nil
}
func selectVenue(_ id: Int64?) throws {
if let id {
guard try entities("venues").contains(where: { $0.id == id }) else { throw LibraryError.message("Venue no longer exists") }
}
try execute("INSERT INTO settings(key,value) VALUES('currentVenue',?) ON CONFLICT(key) DO UPDATE SET value=excluded.value",[id.map(String.init)])
}
func rename(_ table: String, id: Int64, name: String) throws {
precondition(["singers","venues","playlists"].contains(table))
let name = name.trimmingCharacters(in:.whitespacesAndNewlines)
guard !name.isEmpty else { throw LibraryError.message("Enter a name") }
try execute("UPDATE \(table) SET name=? WHERE id=?",[name,String(id)])
}
func deleteEntity(_ table: String, id: Int64) throws {
precondition(["singers","venues","playlists"].contains(table))
try execute("BEGIN IMMEDIATE")
do {
if table == "singers" { try execute("UPDATE history SET singer=NULL WHERE singer=?",[String(id)]) }
if table == "venues" {
try execute("UPDATE history SET venue=NULL WHERE venue=?",[String(id)])
try execute("DELETE FROM settings WHERE key='currentVenue' AND value=?",[String(id)])
}
try execute("DELETE FROM \(table) WHERE id=?",[String(id)])
try execute("COMMIT")
} catch { try? execute("ROLLBACK"); throw error }
}
func preference(song: Int64, singer: Int64) throws -> SongPreference {
let s = try statement("SELECT pitch,tempo,rating FROM preferences WHERE song=? AND singer=?",[String(song),String(singer)]); defer { sqlite3_finalize(s) }
guard sqlite3_step(s) == SQLITE_ROW else { return try defaultPreference(song:song) }
return .init(pitch:sqlite3_column_double(s,0),tempo:sqlite3_column_double(s,1),rating:Int(sqlite3_column_int(s,2)))
}
func savePreference(song: Int64, singer: Int64, value: SongPreference) throws {
try execute("INSERT INTO preferences(song,singer,pitch,tempo,rating) VALUES(?,?,?,?,?) ON CONFLICT(song,singer) DO UPDATE SET pitch=excluded.pitch,tempo=excluded.tempo,rating=excluded.rating",[String(song),String(singer),String(value.pitch),String(value.tempo),String(value.rating)])
}
func history(venue: Int64?, singer: Int64? = nil) throws -> [Performance] {
let s = try statement("SELECT history.id,COALESCE(songs.title,'Deleted song'),COALESCE(singers.name,'—'),COALESCE(venues.name,'—'),played,history.singer,history.song FROM history LEFT JOIN songs ON songs.id=history.song LEFT JOIN singers ON singers.id=history.singer LEFT JOIN venues ON venues.id=history.venue WHERE (? IS NULL OR history.venue=?) AND (? IS NULL OR history.singer=?) ORDER BY history.id DESC",[venue.map(String.init),venue.map(String.init),singer.map(String.init),singer.map(String.init)]); defer { sqlite3_finalize(s) }
var result = [Performance](); while sqlite3_step(s) == SQLITE_ROW { result.append(.init(id:sqlite3_column_int64(s,0),song:text(s,1),singer:text(s,2),venue:text(s,3),date:text(s,4),singerID:sqlite3_column_type(s,5) == SQLITE_NULL ? nil : sqlite3_column_int64(s,5),songID:sqlite3_column_type(s,6) == SQLITE_NULL ? nil : sqlite3_column_int64(s,6))) }; return result
}
func enqueue(song: Int64, singer: Int64?, venue: Int64?) throws {
guard let venue else { throw LibraryError.message("Select a current venue before adding to its queue") }
if let singer, try !members(of:venue).contains(where: { $0.id == singer }) { throw LibraryError.message("Add this singer to the current venue first") }
try execute("BEGIN IMMEDIATE")
do {
if let singer { try assignSong(song,singer:singer) }
try execute("INSERT INTO queue(venue,song,singer,position) VALUES(?,?,?,(SELECT COALESCE(MAX(position),0)+1 FROM queue WHERE venue=?))",[String(venue),String(song),singer.map(String.init),String(venue)])
try execute("COMMIT")
} catch { try? execute("ROLLBACK");throw error }
}
func queue(venue: Int64?) throws -> [QueueEntry] {
guard let venue else { return [] }
let s = try statement("SELECT queue.id,queue.song,queue.singer,songs.title,COALESCE(singers.name,'No singer') FROM queue JOIN songs ON songs.id=queue.song LEFT JOIN singers ON singers.id=queue.singer WHERE queue.venue=? ORDER BY queue.position,queue.id",[String(venue)]); defer { sqlite3_finalize(s) }
var result = [QueueEntry](); while sqlite3_step(s) == SQLITE_ROW { result.append(.init(id:sqlite3_column_int64(s,0),songID:sqlite3_column_int64(s,1),singerID:sqlite3_column_type(s,2) == SQLITE_NULL ? nil : sqlite3_column_int64(s,2),title:text(s,3),singer:text(s,4))) }; return result
}
func removeQueue(_ id: Int64) throws { try execute("DELETE FROM queue WHERE id=?",[String(id)]) }
func moveQueue(_ id: Int64, venue: Int64, by offset: Int) throws {
var rows = try queue(venue:venue)
guard let index = rows.firstIndex(where: { $0.id == id }), rows.indices.contains(index+offset) else { return }
rows.swapAt(index,index+offset)
try execute("BEGIN IMMEDIATE")
do { for (i,row) in rows.enumerated() { try execute("UPDATE queue SET position=? WHERE id=?",[String(i),String(row.id)]) }; try execute("COMMIT") }
catch { try? execute("ROLLBACK"); throw error }
}
func addToPlaylist(_ playlist: Int64, song: Int64) throws {
try execute("INSERT OR IGNORE INTO playlist_songs(playlist,song,position) VALUES(?,?,(SELECT COALESCE(MAX(position),0)+1 FROM playlist_songs WHERE playlist=?))",[String(playlist),String(song),String(playlist)])
}
func playlistSongIDs(_ playlist: Int64) throws -> [Int64] {
let s = try statement("SELECT song FROM playlist_songs WHERE playlist=? ORDER BY position",[String(playlist)]); defer { sqlite3_finalize(s) }
var ids = [Int64](); while sqlite3_step(s) == SQLITE_ROW { ids.append(sqlite3_column_int64(s,0)) }; return ids
}
func removeFromPlaylist(_ playlist: Int64, song: Int64) throws { try execute("DELETE FROM playlist_songs WHERE playlist=? AND song=?",[String(playlist),String(song)]) }
func assignSong(_ song: Int64, singer: Int64) throws {
try execute("INSERT OR IGNORE INTO singer_songs(singer,song,position) VALUES(?,?,(SELECT COALESCE(MAX(position),0)+1 FROM singer_songs WHERE singer=?))",[String(singer),String(song),String(singer)])
}
func removeSingerSong(_ song: Int64, singer: Int64) throws {
try execute("DELETE FROM singer_songs WHERE singer=? AND song=?",[String(singer),String(song)])
}
func singerSongIDs() throws -> [Int64:[Int64]] {
let s = try statement("SELECT singer,song FROM singer_songs ORDER BY singer,position,song",[]); defer { sqlite3_finalize(s) }
var result = [Int64:[Int64]]()
while sqlite3_step(s) == SQLITE_ROW { result[sqlite3_column_int64(s,0),default:[]].append(sqlite3_column_int64(s,1)) }
return result
}
func defaultPreference(song: Int64) throws -> SongPreference {
let s = try statement("SELECT pitch,tempo FROM song_settings WHERE song=?",[String(song)]);defer { sqlite3_finalize(s) }
guard sqlite3_step(s) == SQLITE_ROW else { return .init() }
return .init(pitch:sqlite3_column_double(s,0),tempo:sqlite3_column_double(s,1),rating:0)
}
func saveDefaultPreference(song: Int64, value: SongPreference) throws {
try execute("INSERT INTO song_settings(song,pitch,tempo) VALUES(?,?,?) ON CONFLICT(song) DO UPDATE SET pitch=excluded.pitch,tempo=excluded.tempo",[String(song),String(value.pitch),String(value.tempo)])
}
func updateDuration(_ song: Int64, seconds: Double) throws {
guard seconds.isFinite && seconds >= 0 else { return }
try execute("UPDATE songs SET duration=? WHERE id=?",[String(seconds),String(song)])
}
func setFavourite(song: Int64, singer: Int64, included: Bool) throws {
if included { try assignSong(song,singer:singer) }
try execute("UPDATE singer_songs SET favourite=? WHERE singer=? AND song=?",[included ? "1" : "0",String(singer),String(song)])
}
func favouriteSongIDs() throws -> [Int64:Set<Int64>] {
let s = try statement("SELECT singer,song FROM singer_songs WHERE favourite=1",[]);defer { sqlite3_finalize(s) }
var result = [Int64:Set<Int64>]()
while sqlite3_step(s) == SQLITE_ROW { result[sqlite3_column_int64(s,0),default:[]].insert(sqlite3_column_int64(s,1)) };return result
}
func stores() throws -> [MusicStore] {
let s = try statement("SELECT id,name,url,search_template FROM music_stores ORDER BY name",[]);defer { sqlite3_finalize(s) }
var result = [MusicStore]()
while sqlite3_step(s) == SQLITE_ROW { result.append(.init(id:sqlite3_column_int64(s,0),name:text(s,1),url:text(s,2),searchTemplate:text(s,3))) };return result
}
func saveStore(_ store: MusicStore) throws {
let name = store.name.trimmingCharacters(in:.whitespacesAndNewlines),url = store.url.trimmingCharacters(in:.whitespacesAndNewlines),search = store.searchTemplate.trimmingCharacters(in:.whitespacesAndNewlines)
guard !name.isEmpty else { throw LibraryError.message("Enter a store name") }
let cleaned = MusicStore(id:store.id,name:name,url:url,searchTemplate:search)
_ = try cleaned.destination()
if !search.isEmpty {
guard search.contains("{query}") else { throw LibraryError.message("Search URL must contain {query}") }
_ = try cleaned.destination(query:"test")
}
if store.id == 0 { try execute("INSERT INTO music_stores(name,url,search_template) VALUES(?,?,?)",[name,url,search]) }
else { try execute("UPDATE music_stores SET name=?,url=?,search_template=? WHERE id=?",[name,url,search,String(store.id)]) }
}
func deleteStore(_ id: Int64) throws { try execute("DELETE FROM music_stores WHERE id=?",[String(id)]) }
func updateMetadata(song: Int64,title: String,artist: String,album: String,label: String,rating: Int) throws {
let title = title.trimmingCharacters(in:.whitespacesAndNewlines)
guard !title.isEmpty else { throw LibraryError.message("Song title cannot be empty") }
try execute("UPDATE songs SET title=?,artist=?,album=?,label=?,rating=?,metadata_edited=1 WHERE id=?",[title,artist.trimmingCharacters(in:.whitespacesAndNewlines),album.trimmingCharacters(in:.whitespacesAndNewlines),label.trimmingCharacters(in:.whitespacesAndNewlines),String(rating),String(song)])
guard sqlite3_changes(db) == 1 else { throw LibraryError.message("Song no longer exists") }
}
}
@@ -0,0 +1,455 @@
import XCTest
import AVFoundation
@testable import KJamsClone
final class KJamsCloneTests: XCTestCase {
func packet(_ instruction: UInt8, _ data: [UInt8]) -> [UInt8] { [9,instruction,0,0] + Array((data + Array(repeating: 0,count:16)).prefix(16)) + [0,0,0,0] }
func testPresetTileXORAndInvalidCoordinates() {
var d = CDGDecoder()
d.apply(packet(1,[3,0])); XCTAssertEqual(d.pixels[0],3)
d.apply(packet(6,[0,5,1,1] + Array(repeating:63,count:12)))
XCTAssertEqual(d.pixels[12*300+6],5)
d.apply(packet(38,[0,5,1,1] + Array(repeating:63,count:12)))
XCTAssertEqual(d.pixels[12*300+6],0)
let old = d.pixels; d.apply(packet(6,[1,2,31,63])); XCTAssertEqual(d.pixels,old)
}
func testSeekAndTruncatedPacket() {
var d = CDGDecoder()
let data = Data(packet(1,[2,0]) + packet(1,[7,0]) + [9])
d.render(data,at:1); XCTAssertEqual(d.pixels[0],7); XCTAssertEqual(d.packetIndex,2)
d.render(data,at:1.0/300); XCTAssertEqual(d.pixels[0],2)
d.render(data,at:0); XCTAssertEqual(d.pixels[0],0)
}
func testPaletteBorderScrollAndImage() {
var d = CDGDecoder()
d.apply(packet(30,[63,63])); XCTAssertEqual(d.palette[0],0xFFFFFFFF)
d.apply(packet(2,[4])); XCTAssertEqual(d.pixels[0],4); XCTAssertEqual(d.pixels[12*300+6],0)
d.apply(packet(20,[3,16,0])); XCTAssertEqual(d.pixels[100*300],3)
d.apply(packet(24,[0,32,0])); XCTAssertEqual(d.pixels[100*300+294],3)
XCTAssertEqual(d.image()?.width,288)
}
func testSQLitePersistenceDedupRatingsAndHistory() throws {
let folder = FileManager.default.temporaryDirectory.appendingPathComponent(UUID().uuidString)
try FileManager.default.createDirectory(at: folder,withIntermediateDirectories:true)
defer { try? FileManager.default.removeItem(at:folder) }
let url = folder.appendingPathComponent("test.sqlite")
do {
let db = try Library(url:url)
try db.add(title:"Singer's Song",audio:"/test.mp3",cdg:nil)
try db.add(title:"Duplicate",audio:"/test.mp3",cdg:"/test.cdg")
let song = try XCTUnwrap(db.songs().first)
try db.rate(song.id,5); XCTAssertThrowsError(try db.rate(song.id,6))
try db.addEntity("singers",name:"O'Neil"); try db.addEntity("venues",name:"Hall")
try db.record(song.id,singer:db.entities("singers").first?.id,venue:db.entities("venues").first?.id)
}
let reopened = try Library(url:url); let songs = try reopened.songs()
XCTAssertEqual(songs.count,1); XCTAssertEqual(songs[0].rating,5); XCTAssertEqual(songs[0].plays,1); XCTAssertEqual(songs[0].cdg,"/test.cdg")
XCTAssertEqual(try reopened.entities("singers").first?.name,"O'Neil")
}
func testPairedImportAndContentDedup() throws {
let root = FileManager.default.temporaryDirectory.appendingPathComponent(UUID().uuidString)
try FileManager.default.createDirectory(at:root,withIntermediateDirectories:true)
defer { try? FileManager.default.removeItem(at:root) }
let audio = root.appendingPathComponent("Test.mp3"), cdg = root.appendingPathComponent("Test.CDG")
try Data([1,2,3]).write(to:audio); try Data(packet(1,[2,0])).write(to:cdg)
let db = try Library(url:root.appendingPathComponent("test.sqlite"))
let importer = Importer(media:root.appendingPathComponent("Media"))
try importer.run([audio],library:db); try importer.run([audio],library:db)
XCTAssertEqual(try db.songs().count,1)
XCTAssertNotNil(try db.songs().first?.cdg)
}
func testZippedMP3GImportAndUnsafeArchiveRejection() throws {
let folder = FileManager.default.temporaryDirectory.appendingPathComponent(UUID().uuidString)
try FileManager.default.createDirectory(at:folder,withIntermediateDirectories:true)
defer { try? FileManager.default.removeItem(at:folder) }
let fixtures = try XCTUnwrap(Bundle(for:Self.self).resourceURL?.appendingPathComponent("Fixtures"))
let db = try Library(url:folder.appendingPathComponent("db.sqlite"))
let importer = Importer(media:folder.appendingPathComponent("Media"))
try importer.run([fixtures.appendingPathComponent("Demo.zip")],library:db)
let song = try XCTUnwrap(db.songs().first)
XCTAssertEqual(song.title,"Demo"); XCTAssertNotNil(song.cdg)
XCTAssertTrue(FileManager.default.fileExists(atPath:song.audio))
XCTAssertThrowsError(try importer.run([fixtures.appendingPathComponent("Unsafe.zip")],library:db))
}
@MainActor func testMP3PlaybackPauseAndSeek() throws {
let fixtures = try XCTUnwrap(Bundle(for:Self.self).resourceURL?.appendingPathComponent("Fixtures"))
let player = Player()
defer { player.stop() }
try player.load(Song(id:1,title:"Demo",audio:fixtures.appendingPathComponent("Demo.mp3").path,cdg:fixtures.appendingPathComponent("Demo.cdg").path,rating:0,plays:0))
XCTAssertGreaterThan(player.duration,3.9); XCTAssertTrue(player.playing)
player.toggle(); XCTAssertFalse(player.playing)
player.seek(2); XCTAssertEqual(player.time,2,accuracy:0.05); XCTAssertNotNil(player.image)
player.seek(0.1); XCTAssertEqual(player.time,0.1,accuracy:0.05)
}
@MainActor func testCreateSingerAndVenueThroughAppModel() throws {
let root = FileManager.default.temporaryDirectory.appendingPathComponent(UUID().uuidString)
defer { try? FileManager.default.removeItem(at: root) }
let model = AppModel(storageURL: root)
XCTAssertNil(model.error)
let singer = try model.createEntity(.singer, name: " Alex ")
let venue = try model.createEntity(.venue, name: "Town Hall")
XCTAssertEqual(model.singers.first?.name, "Alex")
XCTAssertEqual(model.venues.first?.name, "Town Hall")
XCTAssertEqual(try model.createEntity(.singer, name: "Alex"), singer)
XCTAssertEqual(model.singers.count, 1)
XCTAssertThrowsError(try model.createEntity(.venue, name: " "))
let reopened = AppModel(storageURL: root)
XCTAssertEqual(reopened.singers.first?.id, singer)
XCTAssertEqual(reopened.venues.first?.id, venue)
}
@MainActor func testVenuesShareSingersAndRememberSelection() throws {
let root = FileManager.default.temporaryDirectory.appendingPathComponent(UUID().uuidString)
defer { try? FileManager.default.removeItem(at:root) }
let model = AppModel(storageURL:root)
let hall = try model.createEntity(.venue,name:"Hall")
let alex = try model.createEntity(.singer,name:"Alex")
let club = try model.createEntity(.venue,name:"Club")
XCTAssertTrue(model.venueSingers.isEmpty)
model.membership(singer:alex,included:true)
XCTAssertEqual(model.venueSingers.map(\.id),[alex])
model.chooseVenue(hall); XCTAssertEqual(model.venueSingers.map(\.id),[alex])
model.chooseVenue(club); model.membership(singer:alex,included:false)
XCTAssertTrue(model.venueSingers.isEmpty)
let reopened = AppModel(storageURL:root)
XCTAssertEqual(reopened.currentVenue,club); XCTAssertTrue(reopened.venueSingers.isEmpty)
reopened.chooseVenue(hall); XCTAssertEqual(reopened.venueSingers.map(\.id),[alex])
XCTAssertEqual(reopened.singers.count,1)
}
func testMigrationAndMembershipRemovalDoesNotReappear() throws {
let root = FileManager.default.temporaryDirectory.appendingPathComponent(UUID().uuidString)
try FileManager.default.createDirectory(at:root,withIntermediateDirectories:true)
defer { try? FileManager.default.removeItem(at:root) }
let url = root.appendingPathComponent("db.sqlite")
var singer: Int64 = 0, venue: Int64 = 0
do {
let db = try Library(url:url)
try db.add(title:"Song",audio:"/a.mp3",cdg:nil)
try db.addEntity("singers",name:"Alex"); try db.addEntity("venues",name:"Hall")
singer = try XCTUnwrap(db.entities("singers").first?.id); venue = try XCTUnwrap(db.entities("venues").first?.id)
try db.record(XCTUnwrap(db.songs().first?.id),singer:singer,venue:venue)
try db.execute("PRAGMA user_version=1")
}
do {
let migrated = try Library(url:url)
XCTAssertEqual(try migrated.members(of:venue).map(\.id),[singer])
try migrated.setMembership(singer:singer,venue:venue,included:false)
}
let reopened = try Library(url:url)
XCTAssertTrue(try reopened.members(of:venue).isEmpty)
XCTAssertEqual(try reopened.history(venue:venue).count,1)
}
func testQueuePlaylistsPreferencesAndDeletion() throws {
let root = FileManager.default.temporaryDirectory.appendingPathComponent(UUID().uuidString)
try FileManager.default.createDirectory(at:root,withIntermediateDirectories:true)
defer { try? FileManager.default.removeItem(at:root) }
let db = try Library(url:root.appendingPathComponent("db.sqlite"))
try db.add(title:"First",audio:"/1.mp3",cdg:nil)
try db.add(title:"Second",audio:"/2.mp3",cdg:nil)
let songs = try db.songs()
try db.addEntity("singers",name:"Alex"); try db.addEntity("venues",name:"Hall"); try db.addEntity("venues",name:"Club")
let singer = try XCTUnwrap(db.entities("singers").first?.id)
let hall = try XCTUnwrap(db.entities("venues").first(where: { $0.name == "Hall" })?.id)
let club = try XCTUnwrap(db.entities("venues").first(where: { $0.name == "Club" })?.id)
XCTAssertThrowsError(try db.enqueue(song:songs[0].id,singer:singer,venue:hall))
try db.setMembership(singer:singer,venue:hall,included:true)
try db.enqueue(song:songs[0].id,singer:singer,venue:hall); try db.enqueue(song:songs[1].id,singer:singer,venue:hall)
XCTAssertTrue(try db.queue(venue:club).isEmpty)
let second = try XCTUnwrap(db.queue(venue:hall).last)
try db.moveQueue(second.id,venue:hall,by:-1)
XCTAssertEqual(try db.queue(venue:hall).first?.songID,songs[1].id)
let preference = SongPreference(pitch:3,tempo:0.85,rating:4)
try db.savePreference(song:songs[0].id,singer:singer,value:preference)
XCTAssertEqual(try db.preference(song:songs[0].id,singer:singer),preference)
XCTAssertThrowsError(try db.savePreference(song:songs[0].id,singer:singer,value:.init(pitch:99)))
try db.addEntity("playlists",name:"Party")
let playlist = try XCTUnwrap(db.entities("playlists").first?.id)
try db.addToPlaylist(playlist,song:songs[0].id); try db.addToPlaylist(playlist,song:songs[0].id)
XCTAssertEqual(try db.playlistSongIDs(playlist),[songs[0].id])
try db.record(songs[0].id,singer:singer,venue:hall)
try db.rename("singers",id:singer,name:"Alex Jones")
XCTAssertEqual(try db.history(venue:hall).first?.singer,"Alex Jones")
try db.deleteEntity("singers",id:singer)
XCTAssertTrue(try db.queue(venue:hall).isEmpty)
XCTAssertEqual(try db.history(venue:hall).count,1)
try db.selectVenue(hall); try db.deleteEntity("venues",id:hall)
XCTAssertNil(try db.currentVenue()); XCTAssertEqual(try db.history(venue:nil).count,1)
}
@MainActor func testTempoSourceClockPauseAndResume() async throws {
let fixtures = try XCTUnwrap(Bundle(for:Self.self).resourceURL?.appendingPathComponent("Fixtures"))
let player = Player(); defer { player.stop() }
let song = Song(id:1,title:"Demo",audio:fixtures.appendingPathComponent("Demo.mp3").path,cdg:fixtures.appendingPathComponent("Demo.cdg").path,rating:0,plays:0)
try player.load(song,preference:.init(pitch:2,tempo:1.5,rating:3))
XCTAssertEqual(player.pitch,2); XCTAssertEqual(player.tempo,1.5)
try await Task.sleep(nanoseconds:500_000_000)
XCTAssertGreaterThan(player.time,0.45); XCTAssertLessThan(player.time,1.3)
player.toggle(); let paused = player.time
try await Task.sleep(nanoseconds:100_000_000)
XCTAssertEqual(player.time,paused,accuracy:0.025)
player.seek(1.5); player.toggle()
try await Task.sleep(nanoseconds:200_000_000)
XCTAssertGreaterThan(player.time,1.6); XCTAssertNotNil(player.image)
}
func testNewTestMediaMetadataAndCDGPairImport() throws {
let root = FileManager.default.temporaryDirectory.appendingPathComponent(UUID().uuidString)
try FileManager.default.createDirectory(at:root,withIntermediateDirectories:true)
defer { try? FileManager.default.removeItem(at:root) }
let db = try Library(url:root.appendingPathComponent("db.sqlite"))
let fixtures = try XCTUnwrap(Bundle(for:Self.self).resourceURL?.appendingPathComponent("Fixtures"))
let importer = Importer(media:root.appendingPathComponent("Media"))
try importer.run([fixtures.appendingPathComponent("TestTrack.cdg")],library:db)
let song = try XCTUnwrap(db.songs().first)
XCTAssertEqual(song.title,"MP3 Plus G Test")
XCTAssertEqual(song.artist,"KJamsClone Test Generator")
XCTAssertNotNil(song.cdg)
let bytes = try Data(contentsOf:fixtures.appendingPathComponent("TestTrack.cdg"))
XCTAssertEqual(bytes.count,20*300*24)
var decoder = CDGDecoder(); decoder.render(bytes,at:2)
XCTAssertTrue(decoder.pixels.contains(1)); XCTAssertTrue(decoder.pixels.contains(2))
}
@MainActor func testAutomaticVenueQueueAdvancesAndRecordsSinger() async throws {
let root = FileManager.default.temporaryDirectory.appendingPathComponent(UUID().uuidString)
defer { try? FileManager.default.removeItem(at:root) }
let model = AppModel(storageURL:root); defer { model.player.stop() }
_ = try model.createEntity(.venue,name:"Test Hall")
_ = try model.createEntity(.singer,name:"Alex")
let fixtures = try XCTUnwrap(Bundle(for:Self.self).resourceURL?.appendingPathComponent("Fixtures"))
model.importFiles([fixtures.appendingPathComponent("Demo.zip")])
let song = try XCTUnwrap(model.songs.first)
model.enqueue(song.id); model.enqueue(song.id); model.playQueueNext()
XCTAssertEqual(model.queue.count,1); XCTAssertEqual(model.history.count,1)
model.player.seek(model.player.duration-0.1)
for _ in 0..<25 {
if model.queue.isEmpty { break }
try await Task.sleep(nanoseconds:100_000_000)
}
XCTAssertNil(model.error); XCTAssertTrue(model.queue.isEmpty)
XCTAssertEqual(model.history.count,2); XCTAssertEqual(model.history.first?.singer,"Alex")
}
func testWaveformRepresentsSilenceAndSignalInTimeOrder() throws {
let folder = FileManager.default.temporaryDirectory.appendingPathComponent(UUID().uuidString)
try FileManager.default.createDirectory(at:folder,withIntermediateDirectories:true)
defer { try? FileManager.default.removeItem(at:folder) }
let url = folder.appendingPathComponent("signal.wav")
let format = try XCTUnwrap(AVAudioFormat(standardFormatWithSampleRate:8000,channels:1))
do {
let file = try AVAudioFile(forWriting:url,settings:format.settings)
let buffer = try XCTUnwrap(AVAudioPCMBuffer(pcmFormat:format,frameCapacity:4096)); buffer.frameLength = 4096
let samples = try XCTUnwrap(buffer.floatChannelData?[0])
for i in 0..<4096 { samples[i] = i < 2048 ? 0 : Float(sin(Double(i)*0.2)*0.5) }
try file.write(from:buffer)
}
let envelope = try AudioWaveform.read(url:url,bins:32)
XCTAssertEqual(envelope.count,32)
XCTAssertTrue(envelope.prefix(16).allSatisfy { $0 == 0 })
XCTAssertTrue(envelope.suffix(16).allSatisfy { $0 > 0.8 && $0 <= 1 })
XCTAssertThrowsError(try AudioWaveform.read(url:url,cancelled:{true}))
}
@MainActor func testWaveformAnalysisAndStopClearsTrackData() async throws {
let fixtures = try XCTUnwrap(Bundle(for:Self.self).resourceURL?.appendingPathComponent("Fixtures"))
let player = Player(); defer { player.stop() }
try player.load(Song(id:1,title:"Demo",audio:fixtures.appendingPathComponent("Demo.mp3").path,cdg:nil,rating:0,plays:0))
player.toggle()
for _ in 0..<50 {
if !player.waveformLoading { break }
try await Task.sleep(nanoseconds:20_000_000)
}
XCTAssertEqual(player.waveform.count,4096)
XCTAssertFalse(player.waveformUnavailable)
player.stop()
XCTAssertTrue(player.waveform.isEmpty)
XCTAssertFalse(player.waveformLoading)
try await Task.sleep(nanoseconds:50_000_000)
XCTAssertTrue(player.waveform.isEmpty)
}
@MainActor func testConnectedSingerCreationAndSharedRepertoire() throws {
let root = FileManager.default.temporaryDirectory.appendingPathComponent(UUID().uuidString)
defer { try? FileManager.default.removeItem(at:root) }
let model = AppModel(storageURL:root)
let hall = try model.createEntity(.venue,name:"Hall")
try model.library?.add(title:"Song",audio:"/sample.mp3",cdg:nil);try model.refresh()
let song = try XCTUnwrap(model.songs.first?.id)
let alex = try model.createSinger(name:" Alex ",venue:hall,songs:[song])
XCTAssertEqual(model.selectedSinger,alex);XCTAssertEqual(model.currentVenue,hall)
XCTAssertEqual(model.venueSingers.map(\.id),[alex]);XCTAssertEqual(model.songs(for:alex).map(\.id),[song])
XCTAssertThrowsError(try model.createSinger(name:"Broken",venue:hall,songs:[999999]))
XCTAssertFalse(try XCTUnwrap(model.library).entities("singers").contains { $0.name == "Broken" })
let club = try model.createEntity(.venue,name:"Club");model.membership(singer:alex,included:true)
XCTAssertEqual(model.songs(for:alex).map(\.id),[song])
model.assign(song,to:alex);XCTAssertEqual(model.songs(for:alex).count,1)
let reopened = AppModel(storageURL:root)
XCTAssertEqual(reopened.currentVenue,club);XCTAssertEqual(reopened.songs(for:alex).map(\.id),[song])
reopened.assign(song,to:alex,included:false)
XCTAssertTrue(AppModel(storageURL:root).songs(for:alex).isEmpty)
}
func testQueueRemembersSingerSongWithoutDuplicatingAssignment() throws {
let root = FileManager.default.temporaryDirectory.appendingPathComponent(UUID().uuidString)
try FileManager.default.createDirectory(at:root,withIntermediateDirectories:true)
defer { try? FileManager.default.removeItem(at:root) }
let db = try Library(url:root.appendingPathComponent("db.sqlite"))
try db.addEntity("singers",name:"Alex");try db.addEntity("venues",name:"Hall")
try db.add(title:"Song",audio:"/a.mp3",cdg:nil)
let singer = try XCTUnwrap(db.entities("singers").first?.id),venue = try XCTUnwrap(db.entities("venues").first?.id),song = try XCTUnwrap(db.songs().first?.id)
try db.setMembership(singer:singer,venue:venue,included:true)
try db.enqueue(song:song,singer:singer,venue:venue);try db.enqueue(song:song,singer:singer,venue:venue)
XCTAssertEqual(try db.singerSongIDs()[singer],[song]);XCTAssertEqual(try db.queue(venue:venue).count,2)
try db.removeSingerSong(song,singer:singer)
XCTAssertNil(try db.singerSongIDs()[singer]);XCTAssertEqual(try db.songs().count,1)
}
func testFrequencyBandsDistinguishBassAndTreble() throws {
let root = FileManager.default.temporaryDirectory.appendingPathComponent(UUID().uuidString)
try FileManager.default.createDirectory(at:root,withIntermediateDirectories:true)
defer { try? FileManager.default.removeItem(at:root) }
let url = root.appendingPathComponent("bands.wav")
let format = try XCTUnwrap(AVAudioFormat(standardFormatWithSampleRate:16000,channels:1))
do {
let file = try AVAudioFile(forWriting:url,settings:format.settings)
let buffer = try XCTUnwrap(AVAudioPCMBuffer(pcmFormat:format,frameCapacity:8192));buffer.frameLength = 8192
for i in 0..<8192 { buffer.floatChannelData![0][i] = Float(sin(Double(i)*2*Double.pi*(i < 4096 ? 80 : 6000)/16000)*0.2) }
try file.write(from:buffer)
}
let analysis = try AudioWaveform.analyse(url:url,bins:32)
XCTAssertGreaterThan(analysis.bands[8].low,analysis.bands[8].high*3)
XCTAssertGreaterThan(analysis.bands[24].high,analysis.bands[24].low*3)
}
private func toneRMS(frequency: Double, low: Double = 0, filter: Double = 0, enabled: Bool = true) throws -> Double {
let engine = AVAudioEngine(),node = AVAudioPlayerNode(),eq = AVAudioUnitEQ(numberOfBands:4)
let format = try XCTUnwrap(AVAudioFormat(standardFormatWithSampleRate:44100,channels:1))
engine.attach(node);engine.attach(eq);engine.connect(node,to:eq,format:format);engine.connect(eq,to:engine.mainMixerNode,format:format)
AudioTone.configure(eq,sampleRate:44100,low:low,mid:0,high:0,filter:filter,enabled:enabled)
try engine.enableManualRenderingMode(.offline,format:format,maximumFrameCount:1024)
let input = try XCTUnwrap(AVAudioPCMBuffer(pcmFormat:format,frameCapacity:32768));input.frameLength = 32768
for i in 0..<32768 { input.floatChannelData![0][i] = Float(sin(Double(i)*2*Double.pi*frequency/44100)*0.1) }
node.scheduleBuffer(input);try engine.start();node.play();defer { node.stop();engine.stop() }
let output = try XCTUnwrap(AVAudioPCMBuffer(pcmFormat:format,frameCapacity:1024))
var energy: Double = 0,count = 0
for block in 0..<12 {
let status = try engine.renderOffline(1024,to:output)
XCTAssertEqual(status,.success)
if block >= 2 { for i in 0..<Int(output.frameLength) { let v = Double(output.floatChannelData![0][i]);energy += v*v;count += 1 } }
}
return sqrt(energy/Double(max(1,count)))
}
func testToneEQBoostAndBypassProcessActualAudio() throws {
let flat = try toneRMS(frequency:60)
let boosted = try toneRMS(frequency:60,low:12)
let bypassed = try toneRMS(frequency:60,low:12,enabled:false)
XCTAssertGreaterThan(flat,0.01);XCTAssertGreaterThan(boosted,flat*2)
XCTAssertEqual(bypassed/flat,1,accuracy:0.05)
}
func testLowPassAndHighPassFilterActualAudio() throws {
let high = try toneRMS(frequency:6000),low = try toneRMS(frequency:60)
XCTAssertLessThan(try toneRMS(frequency:6000,filter:-1),high*0.1)
XCTAssertLessThan(try toneRMS(frequency:60,filter:1),low*0.1)
}
func testVersionThreeMigrationBuildsSingerSongListsFromHistory() throws {
let root = FileManager.default.temporaryDirectory.appendingPathComponent(UUID().uuidString)
try FileManager.default.createDirectory(at:root,withIntermediateDirectories:true)
defer { try? FileManager.default.removeItem(at:root) }
let url = root.appendingPathComponent("db.sqlite")
var singer: Int64 = 0,song: Int64 = 0
do {
let db = try Library(url:url)
try db.addEntity("singers",name:"Alex");try db.add(title:"Song",audio:"/sample.mp3",cdg:nil)
singer = try XCTUnwrap(db.entities("singers").first?.id);song = try XCTUnwrap(db.songs().first?.id)
try db.record(song,singer:singer,venue:nil)
try db.execute("DROP TABLE singer_songs");try db.execute("PRAGMA user_version=3")
}
let migrated = try Library(url:url)
XCTAssertEqual(try migrated.singerSongIDs()[singer],[song])
XCTAssertEqual(try migrated.history(venue:nil).count,1)
}
func testMusicStoreDefinitionsValidateSearchAndPersist() throws {
let root = FileManager.default.temporaryDirectory.appendingPathComponent(UUID().uuidString)
try FileManager.default.createDirectory(at:root,withIntermediateDirectories:true)
defer { try? FileManager.default.removeItem(at:root) }
let url = root.appendingPathComponent("db.sqlite")
let db = try Library(url:url)
try db.saveStore(.init(id:0,name:"Example",url:"https://example.com",searchTemplate:"https://example.com/search?q={query}"))
let store = try XCTUnwrap(db.stores().first)
let destination = try store.destination(query:"ABBA & Queen")
XCTAssertEqual(URLComponents(url:destination,resolvingAgainstBaseURL:false)?.queryItems?.first?.value,"ABBA & Queen")
XCTAssertThrowsError(try db.saveStore(.init(id:0,name:"Bad",url:"file:///tmp/test",searchTemplate:"")))
XCTAssertThrowsError(try db.saveStore(.init(id:0,name:"Bad2",url:"https://example.com",searchTemplate:"https://example.com/search")))
XCTAssertEqual(try Library(url:url).stores().first?.name,"Example")
try db.saveStore(.init(id:store.id,name:"Renamed",url:"https://example.org",searchTemplate:""))
XCTAssertEqual(try db.stores().count,1);XCTAssertEqual(try db.stores().first?.name,"Renamed")
try db.deleteStore(store.id);XCTAssertTrue(try db.stores().isEmpty)
}
@MainActor func testEditableSongDefaultsAndSingerOverridesAreIndependent() throws {
let root = FileManager.default.temporaryDirectory.appendingPathComponent(UUID().uuidString)
defer { try? FileManager.default.removeItem(at:root) }
let model = AppModel(storageURL:root)
let db = try XCTUnwrap(model.library)
try db.add(title:"Song",audio:"/a.mp3",cdg:nil,duration:123.5);try model.refresh()
let song = try XCTUnwrap(model.songs.first?.id)
model.updateTuning(song,pitch:2,tempo:1.1)
XCTAssertEqual(try db.defaultPreference(song:song).pitch,2)
let venue = try model.createEntity(.venue,name:"Hall")
let singer = try model.createSinger(name:"Alex",venue:venue,songs:[song])
XCTAssertEqual(model.preference(song).tempo,1.1)
model.updateTuning(song,pitch:-3,tempo:0.9)
XCTAssertEqual(try db.preference(song:song,singer:singer).pitch,-3)
XCTAssertEqual(try db.defaultPreference(song:song).pitch,2)
model.setFavourite(song,singer:singer,included:true)
XCTAssertTrue(model.favourites[singer]?.contains(song) == true)
let reopened = AppModel(storageURL:root)
XCTAssertEqual(reopened.songs.first?.duration,123.5)
XCTAssertTrue(reopened.favourites[singer]?.contains(song) == true)
XCTAssertEqual(try XCTUnwrap(reopened.library).preference(song:song,singer:singer).tempo,0.9)
}
func testMetadataEditsPersistAndSurviveReimport() throws {
let root = FileManager.default.temporaryDirectory.appendingPathComponent(UUID().uuidString)
try FileManager.default.createDirectory(at:root,withIntermediateDirectories:true)
defer { try? FileManager.default.removeItem(at:root) }
let audio = root.appendingPathComponent("audio.mp3"),url = root.appendingPathComponent("db.sqlite")
let bytes = Data([1,2,3]);try bytes.write(to:audio)
let db = try Library(url:url)
try db.add(title:"Old",audio:audio.path,cdg:nil,artist:"Old artist")
let id = try XCTUnwrap(db.songs().first?.id)
try db.updateMetadata(song:id,title:" New Title ",artist:"New artist",album:"New album",label:"New label",rating:5)
XCTAssertThrowsError(try db.updateMetadata(song:id,title:" ",artist:"",album:"",label:"",rating:0))
try db.add(title:"Original tag",audio:audio.path,cdg:nil,artist:"Original artist",album:"Original album",label:"Original label")
let saved = try XCTUnwrap(Library(url:url).songs().first)
XCTAssertEqual(saved.title,"New Title");XCTAssertEqual(saved.artist,"New artist")
XCTAssertEqual(saved.album,"New album");XCTAssertEqual(saved.label,"New label");XCTAssertEqual(saved.rating,5)
XCTAssertEqual(try Data(contentsOf:audio),bytes)
}
func testWaveformCacheRejectsChangedFilesAndCorruption() throws {
let root = FileManager.default.temporaryDirectory.appendingPathComponent(UUID().uuidString)
try FileManager.default.createDirectory(at:root,withIntermediateDirectories:true)
defer { try? FileManager.default.removeItem(at:root) }
let source = try XCTUnwrap(Bundle(for:Self.self).resourceURL?.appendingPathComponent("Fixtures/Demo.mp3"))
let audio = root.appendingPathComponent("demo.mp3"),cache = root.appendingPathComponent("Waveforms")
try FileManager.default.copyItem(at:source,to:audio)
let analysis = try AudioWaveform.analyse(url:audio)
try WaveformCache.save(analysis,audio:audio,directory:cache)
XCTAssertEqual(try WaveformCache.load(audio:audio,directory:cache).levels,analysis.levels)
let first = try WaveformCache.location(audio:audio,directory:cache)
try FileManager.default.setAttributes([.modificationDate:Date(timeIntervalSince1970:123456)],ofItemAtPath:audio.path)
XCTAssertNotEqual(first,try WaveformCache.location(audio:audio,directory:cache))
XCTAssertThrowsError(try WaveformCache.load(audio:audio,directory:cache))
try WaveformCache.save(analysis,audio:audio,directory:cache)
try Data([0,1,2]).write(to:WaveformCache.location(audio:audio,directory:cache))
XCTAssertThrowsError(try WaveformCache.load(audio:audio,directory:cache))
}
@MainActor func testPlayerReusesSavedWaveformAndCanForceReanalysis() async throws {
let root = FileManager.default.temporaryDirectory.appendingPathComponent(UUID().uuidString)
defer { try? FileManager.default.removeItem(at:root) }
let audio = try XCTUnwrap(Bundle(for:Self.self).resourceURL?.appendingPathComponent("Fixtures/Demo.mp3"))
let player = Player(waveformCacheDirectory:root);player.volume = 0;defer { player.stop() }
let song = Song(id:1,title:"Demo",audio:audio.path,cdg:nil,rating:0,plays:0)
try player.load(song);player.toggle()
for _ in 0..<100 { if !player.waveformLoading { break };try await Task.sleep(nanoseconds:20_000_000) }
XCTAssertTrue(player.waveformSaved);XCTAssertFalse(player.waveformFromCache)
let first = player.waveform
player.stop();try player.load(song);player.toggle()
for _ in 0..<100 { if !player.waveformLoading { break };try await Task.sleep(nanoseconds:20_000_000) }
XCTAssertTrue(player.waveformFromCache);XCTAssertEqual(player.waveform,first)
player.reanalyseWaveform()
for _ in 0..<100 { if !player.waveformLoading { break };try await Task.sleep(nanoseconds:20_000_000) }
XCTAssertFalse(player.waveformFromCache);XCTAssertTrue(player.waveformSaved);XCTAssertEqual(player.waveform,first)
}
}