1import AppKit2import Foundation3import Testing45@testable import Haven67private final class ManagerURLProtocol: URLProtocol, @unchecked Sendable {8 override class func canInit(with request: URLRequest) -> Bool { true }9 override class func canonicalRequest(for request: URLRequest) -> URLRequest { request }10 override func startLoading() {11 let path = request.url!.path12 let statusCode = path.contains("fail-http") ? 500 : 20013 let data: Data14 if path.contains("image.png") {15 data = onePixelPNG16 } else if path.contains("invalid.png") {17 data = Data("not an image".utf8)18 } else {19 data = Data("wallpaper".utf8)20 }21 let response = HTTPURLResponse(22 url: request.url!, statusCode: statusCode, httpVersion: nil, headerFields: nil)!23 client?.urlProtocol(self, didReceive: response, cacheStoragePolicy: .notAllowed)24 client?.urlProtocol(self, didLoad: data)25 client?.urlProtocolDidFinishLoading(self)26 }27 override func stopLoading() {}28}2930private func managerSession() -> URLSession {31 let configuration = URLSessionConfiguration.ephemeral32 configuration.protocolClasses = [ManagerURLProtocol.self]33 return URLSession(configuration: configuration)34}3536private let onePixelPNG = Data(37 base64Encoded:38 "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mNk+A8AAQUBAScY42YAAAAASUVORK5CYII="39)!4041@MainActor42private final class DesktopImageStub: DesktopImageSetting {43 var receivedURLs: [URL] = []4445 func setDesktopImageURL(46 _ url: URL, for screen: NSScreen, options: [NSWorkspace.DesktopImageOptionKey: Any]47 ) throws {48 receivedURLs.append(url)49 }50}5152@Suite("Favorites persistence", .serialized)53struct FavoritesManagerTests {54 private let defaultsKey = "favoriteWallpapers"5556 @Test("Toggling adds and removes a favorite")57 func toggleFavorite() {58 UserDefaults.standard.removeObject(forKey: defaultsKey)59 defer { UserDefaults.standard.removeObject(forKey: defaultsKey) }60 let manager = FavoritesManager()61 let wallpaper = makeWallpaper()6263 manager.toggleFavorite(wallpaper)64 #expect(manager.favorites == [wallpaper])65 #expect(manager.isFavorite(wallpaper))6667 manager.toggleFavorite(wallpaper)68 #expect(manager.favorites.isEmpty)69 #expect(!manager.isFavorite(wallpaper))70 }7172 @Test("Favorites survive manager recreation")73 func favoritesPersist() {74 UserDefaults.standard.removeObject(forKey: defaultsKey)75 defer { UserDefaults.standard.removeObject(forKey: defaultsKey) }76 let wallpaper = makeWallpaper()77 FavoritesManager().toggleFavorite(wallpaper)7879 let reloaded = FavoritesManager()8081 #expect(reloaded.favorites == [wallpaper])82 }83}8485@Suite("History persistence", .serialized)86struct HistoryManagerTests {87 private let defaultsKey = "wallpaperHistory"8889 @Test("History keeps newest items first and promotes duplicates")90 func orderingAndPromotion() {91 UserDefaults.standard.removeObject(forKey: defaultsKey)92 defer { UserDefaults.standard.removeObject(forKey: defaultsKey) }93 let manager = HistoryManager()94 let first = makeWallpaper(id: "first")95 let second = makeWallpaper(id: "second")9697 manager.addToHistory(first)98 manager.addToHistory(second)99 manager.addToHistory(first)100101 #expect(manager.history.map(\.id) == ["first", "second"])102 }103104 @Test("History is capped at fifty entries")105 func historyLimit() {106 UserDefaults.standard.removeObject(forKey: defaultsKey)107 defer { UserDefaults.standard.removeObject(forKey: defaultsKey) }108 let manager = HistoryManager()109110 for index in 0..<55 {111 manager.addToHistory(makeWallpaper(id: "item-\(index)"))112 }113114 #expect(manager.history.count == 50)115 #expect(manager.history.first?.id == "item-54")116 #expect(manager.history.last?.id == "item-5")117 }118119 @Test("History survives recreation and clear removes persisted data")120 func persistenceAndClear() {121 UserDefaults.standard.removeObject(forKey: defaultsKey)122 defer { UserDefaults.standard.removeObject(forKey: defaultsKey) }123 HistoryManager().addToHistory(makeWallpaper(id: "persisted"))124125 let reloaded = HistoryManager()126 #expect(reloaded.history.map(\.id) == ["persisted"])127128 reloaded.clearHistory()129 #expect(HistoryManager().history.isEmpty)130 }131}132133@Suite("Image cache")134struct ImageCacheTests {135 @Test("Inserted images are returned for the same URL")136 func insertAndRetrieve() {137 let url = URL(string: "https://example.com/\(UUID().uuidString).png")!138 let image = NSImage(size: NSSize(width: 10, height: 20))139140 ImageCache.shared.insertImage(image, for: url)141142 #expect(ImageCache.shared.image(for: url) === image)143 }144145 @Test("Different URLs do not collide")146 func keysDoNotCollide() {147 let base = UUID().uuidString148 let firstURL = URL(string: "https://example.com/\(base)-first.png")!149 let secondURL = URL(string: "https://example.com/\(base)-second.png")!150151 ImageCache.shared.insertImage(NSImage(size: NSSize(width: 1, height: 1)), for: firstURL)152153 #expect(ImageCache.shared.image(for: secondURL) == nil)154 }155156 @Test("Fetch decodes and caches successful image responses")157 func fetchAndCache() async throws {158 let cache = ImageCache(session: managerSession())159 let url = URL(string: "https://example.com/image.png")!160161 let first = try await cache.fetchImage(url: url)162 let second = try await cache.fetchImage(url: url)163164 #expect(first === second)165 }166167 @Test("Fetch rejects HTTP errors and invalid image bytes")168 func fetchFailures() async {169 let cache = ImageCache(session: managerSession())170 let httpError = URL(string: "https://example.com/fail-http.png")!171 let invalid = URL(string: "https://example.com/invalid.png")!172 await #expect(throws: WallhavenError.self) { try await cache.fetchImage(url: httpError) }173 await #expect(throws: WallhavenError.self) { try await cache.fetchImage(url: invalid) }174 }175}176177@Suite("Wallpaper file management", .serialized)178@MainActor179struct WallpaperManagerTests {180 @Test("Download validates HTTP status and writes response data")181 func download() async throws {182 let manager = WallpaperManager(session: managerSession())183 let url = URL(string: "https://example.com/\(UUID().uuidString).jpg")!184 let downloaded = try await manager.download(from: url)185 defer { try? FileManager.default.removeItem(at: downloaded) }186187 #expect(try Data(contentsOf: downloaded) == Data("wallpaper".utf8))188189 let errorURL = URL(string: "https://example.com/fail-http.jpg")!190 await #expect(throws: WallhavenError.self) { try await manager.download(from: errorURL) }191 }192193 @Test("Desktop setter receives explicit and default screens")194 @MainActor195 func desktopSetter() throws {196 guard let screen = NSScreen.screens.first else { return }197 var received: [NSScreen] = []198 let manager = WallpaperManager(desktopSetter: { _, target in received.append(target) })199 let url = URL(fileURLWithPath: "/tmp/test-wallpaper.jpg")200201 try manager.setDesktopImage(from: url, screen: screen)202 try manager.setDesktopImage(from: url)203204 #expect(received.count == 2)205 #expect(received[0] === screen)206 }207208 @Test("Default desktop adapter forwards the image to its workspace")209 func defaultDesktopAdapter() throws {210 guard let screen = NSScreen.screens.first else { return }211 let workspace = DesktopImageStub()212 let manager = WallpaperManager(workspace: workspace)213 let url = URL(fileURLWithPath: "/tmp/test-wallpaper.jpg")214215 try manager.setDesktopImage(from: url, screen: screen)216217 #expect(workspace.receivedURLs == [url])218 }219220 @Test("Set wallpaper composes download and desktop update")221 @MainActor222 func setWallpaper() async throws {223 guard let screen = NSScreen.screens.first else { return }224 var receivedURL: URL?225 let manager = WallpaperManager(226 session: managerSession(), desktopSetter: { url, _ in receivedURL = url })227 let remote = URL(string: "https://example.com/\(UUID().uuidString).jpg")!228229 try await manager.setWallpaper(from: remote, screen: screen)230 defer { if let receivedURL { try? FileManager.default.removeItem(at: receivedURL) } }231232 #expect(receivedURL?.lastPathComponent == remote.lastPathComponent)233 }234235 @Test("Saving creates the destination folder and copies the file")236 func saveCreatesFolderAndCopies() throws {237 let root = FileManager.default.temporaryDirectory.appendingPathComponent(UUID().uuidString)238 defer { try? FileManager.default.removeItem(at: root) }239 let source = root.appendingPathComponent("source/wallpaper.jpg")240 let destination = root.appendingPathComponent("nested/destination")241 try FileManager.default.createDirectory(242 at: source.deletingLastPathComponent(), withIntermediateDirectories: true)243 try Data("first".utf8).write(to: source)244245 try WallpaperManager.shared.saveToFolder(from: source, to: destination)246247 let copied = try Data(contentsOf: destination.appendingPathComponent("wallpaper.jpg"))248 #expect(copied == Data("first".utf8))249 }250251 @Test("Saving replaces an existing file with fresh data")252 func saveReplacesExistingFile() throws {253 let root = FileManager.default.temporaryDirectory.appendingPathComponent(UUID().uuidString)254 defer { try? FileManager.default.removeItem(at: root) }255 let source = root.appendingPathComponent("source/wallpaper.jpg")256 let destination = root.appendingPathComponent("destination")257 try FileManager.default.createDirectory(258 at: source.deletingLastPathComponent(), withIntermediateDirectories: true)259 try FileManager.default.createDirectory(at: destination, withIntermediateDirectories: true)260 try Data("new".utf8).write(to: source)261 try Data("old".utf8).write(to: destination.appendingPathComponent("wallpaper.jpg"))262263 try WallpaperManager.shared.saveToFolder(from: source, to: destination)264265 let copied = try Data(contentsOf: destination.appendingPathComponent("wallpaper.jpg"))266 #expect(copied == Data("new".utf8))267 }268}269270@Suite("Autostart persistence", .serialized)271@MainActor272struct AutostartManagerTests {273 @Test("Enable writes a launch agent and disable removes it")274 func enableAndDisable() throws {275 let root = FileManager.default.temporaryDirectory.appendingPathComponent(UUID().uuidString)276 defer { try? FileManager.default.removeItem(at: root) }277 let manager = AutostartManager(278 libraryDirectory: root, executablePath: { "/Applications/Haven.app/Contents/MacOS/Haven" })279280 #expect(!manager.isEnabled)281 manager.isEnabled = true282 #expect(manager.isEnabled)283 manager.isEnabled = true284285 let plist = root.appendingPathComponent("LaunchAgents/com.june.Haven.plist")286 let contents =287 try PropertyListSerialization.propertyList(288 from: Data(contentsOf: plist), format: nil) as? [String: Any]289 #expect(contents?["Label"] as? String == "com.june.Haven")290 #expect(291 contents?["ProgramArguments"] as? [String]292 == ["/Applications/Haven.app/Contents/MacOS/Haven"])293 #expect(contents?["RunAtLoad"] as? Bool == true)294295 manager.isEnabled = false296 #expect(!manager.isEnabled)297 manager.isEnabled = false298 }299300 @Test("Missing executable leaves autostart disabled")301 func missingExecutable() {302 let root = FileManager.default.temporaryDirectory.appendingPathComponent(UUID().uuidString)303 defer { try? FileManager.default.removeItem(at: root) }304 let manager = AutostartManager(libraryDirectory: root, executablePath: { nil })305306 manager.isEnabled = true307308 #expect(!manager.isEnabled)309 }310311 @Test("Default executable provider writes only inside the injected library")312 func defaultExecutableProvider() {313 let root = FileManager.default.temporaryDirectory.appendingPathComponent(UUID().uuidString)314 defer { try? FileManager.default.removeItem(at: root) }315 let manager = AutostartManager(libraryDirectory: root)316 manager.isEnabled = true317 #expect(manager.isEnabled)318 manager.isEnabled = false319 }320321 @Test("Unwritable launch-agent roots do not enable autostart")322 func writeFailure() throws {323 let file = FileManager.default.temporaryDirectory.appendingPathComponent(UUID().uuidString)324 defer { try? FileManager.default.removeItem(at: file) }325 try Data("not a directory".utf8).write(to: file)326 let manager = AutostartManager(libraryDirectory: file, executablePath: { "/tmp/Haven" })327 manager.isEnabled = true328 #expect(!manager.isEnabled)329 }330331 @Test("Removal failures leave the launch agent enabled")332 func removalFailure() {333 let root = FileManager.default.temporaryDirectory.appendingPathComponent(UUID().uuidString)334 defer { try? FileManager.default.removeItem(at: root) }335 let manager = AutostartManager(336 libraryDirectory: root, executablePath: { "/tmp/Haven" },337 removePlist: { _ in throw CocoaError(.fileWriteNoPermission) })338 manager.isEnabled = true339 manager.isEnabled = false340 #expect(manager.isEnabled)341 }342}343344@Suite("Local wallpaper library", .serialized)345@MainActor346struct LocalWallpapersManagerTests {347 private func waitForScan(_ manager: LocalWallpapersManager) async {348 for _ in 0..<100 where manager.isLoading {349 try? await Task.sleep(nanoseconds: 10_000_000)350 }351 }352353 @Test("Scan filters files, reads metadata, and deletes wallpapers")354 func scanAndDelete() async throws {355 let defaults = UserDefaults.standard356 let oldPath = defaults.string(forKey: "saveFolderPath")357 defaults.removeObject(forKey: "saveFolderPath")358 defer {359 if let oldPath {360 defaults.set(oldPath, forKey: "saveFolderPath")361 } else {362 defaults.removeObject(forKey: "saveFolderPath")363 }364 }365 let root = FileManager.default.temporaryDirectory.appendingPathComponent(UUID().uuidString)366 defer { try? FileManager.default.removeItem(at: root) }367 try FileManager.default.createDirectory(at: root, withIntermediateDirectories: true)368 try onePixelPNG.write(to: root.appendingPathComponent("wallpaper.png"))369 try Data("broken".utf8).write(to: root.appendingPathComponent("broken.png"))370 try Data("ignored".utf8).write(to: root.appendingPathComponent("notes.txt"))371 let manager = LocalWallpapersManager()372373 manager.scanFolder(path: root.path)374 manager.scanFolder(path: root.path)375 await waitForScan(manager)376377 let wallpaper = try #require(manager.wallpapers.first)378 #expect(manager.wallpapers.count == 1)379 #expect(wallpaper.thumbnailURL == wallpaper.url)380 #expect(wallpaper.filename == "wallpaper.png")381 #expect(wallpaper.resolution == "1x1")382 #expect(LocalWallpapersManager.wallpaper(at: root.appendingPathComponent("broken.png")) == nil)383 #expect(LocalWallpapersManager.wallpaper(at: root.appendingPathComponent("missing.png")) == nil)384385 manager.deleteWallpaper(wallpaper)386 #expect(manager.wallpapers.isEmpty)387 manager.deleteWallpaper(wallpaper)388 #expect(manager.errorMessage?.hasPrefix("Failed to delete") == true)389 }390391 @Test("Invalid scan roots surface an error")392 func scanError() async throws {393 let defaults = UserDefaults.standard394 defaults.removeObject(forKey: "saveFolderPath")395 let file = FileManager.default.temporaryDirectory.appendingPathComponent(UUID().uuidString)396 defer { try? FileManager.default.removeItem(at: file) }397 try Data("file".utf8).write(to: file)398 let manager = LocalWallpapersManager()399400 manager.scanFolder(path: file.path)401 await waitForScan(manager)402403 #expect(manager.errorMessage?.hasPrefix("Failed to scan folder") == true)404 #expect(!manager.isLoading)405 }406407 @Test("Monitoring configured folders observes filesystem changes and stops")408 func monitoring() async throws {409 let defaults = UserDefaults.standard410 let oldPath = defaults.string(forKey: "saveFolderPath")411 let root = FileManager.default.temporaryDirectory.appendingPathComponent(UUID().uuidString)412 try FileManager.default.createDirectory(at: root, withIntermediateDirectories: true)413 defaults.set(root.path, forKey: "saveFolderPath")414 defer {415 try? FileManager.default.removeItem(at: root)416 if let oldPath {417 defaults.set(oldPath, forKey: "saveFolderPath")418 } else {419 defaults.removeObject(forKey: "saveFolderPath")420 }421 }422 let manager = LocalWallpapersManager()423 await waitForScan(manager)424425 try onePixelPNG.write(to: root.appendingPathComponent("observed.png"))426 try? await Task.sleep(nanoseconds: 100_000_000)427 await waitForScan(manager)428 #expect(manager.wallpapers.contains(where: { $0.filename == "observed.png" }))429430 manager.stopMonitoring()431 try? await Task.sleep(nanoseconds: 500_000_000)432433 let invalidMonitor = FolderMonitor(folderPath: root.appendingPathComponent("missing").path) {}434 invalidMonitor.start()435 invalidMonitor.closeFileDescriptor()436437 let descriptor = open("/dev/null", O_RDONLY)438 let descriptorMonitor = FolderMonitor(439 folderPath: "/dev/null", fileDescriptor: descriptor, callback: {})440 descriptorMonitor.closeFileDescriptor()441 #expect(fcntl(descriptor, F_GETFD) == -1)442 }443}