Files
KMix_Pro/backups/before-tonight-fix-20261103-092811/KJamsCloneTests/KJamsCloneTests.swift
T
2026-11-03 12:53:05 +00:00

456 lines
30 KiB
Swift

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)
}
}