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 233 234 #expect(receivedURL?.pathExtension == remote.pathExtension)235 #expect(receivedURL?.lastPathComponent.hasPrefix("haven-") == true)236 #expect(receivedURL?.lastPathComponent != remote.lastPathComponent)237 #expect(try Data(contentsOf: receivedURL!) == Data("wallpaper".utf8))238 }239240 @Test("Saving creates the destination folder and copies the file")241 func saveCreatesFolderAndCopies() throws {242 let root = FileManager.default.temporaryDirectory.appendingPathComponent(UUID().uuidString)243 defer { try? FileManager.default.removeItem(at: root) }244 let source = root.appendingPathComponent("source/wallpaper.jpg")245 let destination = root.appendingPathComponent("nested/destination")246 try FileManager.default.createDirectory(247 at: source.deletingLastPathComponent(), withIntermediateDirectories: true)248 try Data("first".utf8).write(to: source)249250 try WallpaperManager.shared.saveToFolder(from: source, to: destination)251252 let copied = try Data(contentsOf: destination.appendingPathComponent("wallpaper.jpg"))253 #expect(copied == Data("first".utf8))254 }255256 @Test("Saving replaces an existing file with fresh data")257 func saveReplacesExistingFile() throws {258 let root = FileManager.default.temporaryDirectory.appendingPathComponent(UUID().uuidString)259 defer { try? FileManager.default.removeItem(at: root) }260 let source = root.appendingPathComponent("source/wallpaper.jpg")261 let destination = root.appendingPathComponent("destination")262 try FileManager.default.createDirectory(263 at: source.deletingLastPathComponent(), withIntermediateDirectories: true)264 try FileManager.default.createDirectory(at: destination, withIntermediateDirectories: true)265 try Data("new".utf8).write(to: source)266 try Data("old".utf8).write(to: destination.appendingPathComponent("wallpaper.jpg"))267268 try WallpaperManager.shared.saveToFolder(from: source, to: destination)269270 let copied = try Data(contentsOf: destination.appendingPathComponent("wallpaper.jpg"))271 #expect(copied == Data("new".utf8))272 }273274 @Test("Saving the same logical wallpaper leaves the existing file untouched")275 func saveSameContentIsIdempotent() throws {276 let root = FileManager.default.temporaryDirectory.appendingPathComponent(UUID().uuidString)277 defer { try? FileManager.default.removeItem(at: root) }278 let source = root.appendingPathComponent("source/wallpaper.jpg")279 let destination = root.appendingPathComponent("destination")280 try FileManager.default.createDirectory(281 at: source.deletingLastPathComponent(), withIntermediateDirectories: true)282 try FileManager.default.createDirectory(at: destination, withIntermediateDirectories: true)283 try Data("identical".utf8).write(to: source)284 let existingURL = destination.appendingPathComponent("wallpaper.jpg")285 try Data("identical".utf8).write(to: existingURL)286 let originalAttributes = try FileManager.default.attributesOfItem(atPath: existingURL.path)287288 try WallpaperManager.shared.saveToFolder(from: source, to: destination)289290 let updatedAttributes = try FileManager.default.attributesOfItem(atPath: existingURL.path)291 #expect(try Data(contentsOf: existingURL) == Data("identical".utf8))292 #expect(updatedAttributes[.modificationDate] as? Date == originalAttributes[.modificationDate] as? Date)293 }294295 @Test("Saving into the same path as the source does not destroy data")296 func saveSamePathAsSource() throws {297 let root = FileManager.default.temporaryDirectory.appendingPathComponent(UUID().uuidString)298 defer { try? FileManager.default.removeItem(at: root) }299 try FileManager.default.createDirectory(at: root, withIntermediateDirectories: true)300 let source = root.appendingPathComponent("wallpaper.jpg")301 try Data("payload".utf8).write(to: source)302303 try WallpaperManager.shared.saveToFolder(from: source, to: root)304305 #expect(try Data(contentsOf: source) == Data("payload".utf8))306 }307308 @Test("Distinct URLs sharing a lastPathComponent produce distinct temp files")309 func distinctDownloadsDoNotCollide() async throws {310 let manager = WallpaperManager(session: managerSession())311 let first = URL(string: "https://example.com/aaa/wallpaper.jpg")!312 let second = URL(string: "https://example.com/bbb/wallpaper.jpg")!313314 let firstFile = try await manager.download(from: first)315 let secondFile = try await manager.download(from: second)316 defer {317 try? FileManager.default.removeItem(at: firstFile)318 try? FileManager.default.removeItem(at: secondFile)319 }320321 #expect(firstFile.path != secondFile.path)322 #expect(firstFile.lastPathComponent != secondFile.lastPathComponent)323 #expect(try Data(contentsOf: firstFile) == Data("wallpaper".utf8))324 #expect(try Data(contentsOf: secondFile) == Data("wallpaper".utf8))325 }326327 @Test("Repeated downloads of the same URL produce independent temp files")328 func repeatedDownloadsAreIndependent() async throws {329 let manager = WallpaperManager(session: managerSession())330 let remote = URL(string: "https://example.com/\(UUID().uuidString).jpg")!331332 let first = try await manager.download(from: remote)333 let second = try await manager.download(from: remote)334 defer {335 try? FileManager.default.removeItem(at: first)336 try? FileManager.default.removeItem(at: second)337 }338339 #expect(first.path != second.path)340 #expect(try Data(contentsOf: first) == Data("wallpaper".utf8))341 #expect(try Data(contentsOf: second) == Data("wallpaper".utf8))342 }343344 @Test("makeTempURL preserves the source extension when present")345 func makeTempURLPreservesExtension() {346 let withExtension = URL(string: "https://example.com/foo/wallpaper.png")!347 let withoutExtension = URL(string: "https://example.com/foo/wallpaper")!348349 #expect(WallpaperManager.makeTempURL(for: withExtension).pathExtension == "png")350 #expect(WallpaperManager.makeTempURL(for: withoutExtension).pathExtension == "img")351 #expect(352 WallpaperManager.makeTempURL(for: withExtension).path353 != WallpaperManager.makeTempURL(for: withExtension).path)354 }355}356357@Suite("Autostart persistence", .serialized)358@MainActor359struct AutostartManagerTests {360 @Test("Enable writes a launch agent and disable removes it")361 func enableAndDisable() throws {362 let root = FileManager.default.temporaryDirectory.appendingPathComponent(UUID().uuidString)363 defer { try? FileManager.default.removeItem(at: root) }364 let manager = AutostartManager(365 libraryDirectory: root, executablePath: { "/Applications/Haven.app/Contents/MacOS/Haven" })366367 #expect(!manager.isEnabled)368 manager.isEnabled = true369 #expect(manager.isEnabled)370 manager.isEnabled = true371372 let plist = root.appendingPathComponent("LaunchAgents/com.june.Haven.plist")373 let contents =374 try PropertyListSerialization.propertyList(375 from: Data(contentsOf: plist), format: nil) as? [String: Any]376 #expect(contents?["Label"] as? String == "com.june.Haven")377 #expect(378 contents?["ProgramArguments"] as? [String]379 == ["/Applications/Haven.app/Contents/MacOS/Haven"])380 #expect(contents?["RunAtLoad"] as? Bool == true)381382 manager.isEnabled = false383 #expect(!manager.isEnabled)384 manager.isEnabled = false385 }386387 @Test("Missing executable leaves autostart disabled")388 func missingExecutable() {389 let root = FileManager.default.temporaryDirectory.appendingPathComponent(UUID().uuidString)390 defer { try? FileManager.default.removeItem(at: root) }391 let manager = AutostartManager(libraryDirectory: root, executablePath: { nil })392393 manager.isEnabled = true394395 #expect(!manager.isEnabled)396 }397398 @Test("Default executable provider writes only inside the injected library")399 func defaultExecutableProvider() {400 let root = FileManager.default.temporaryDirectory.appendingPathComponent(UUID().uuidString)401 defer { try? FileManager.default.removeItem(at: root) }402 let manager = AutostartManager(libraryDirectory: root)403 manager.isEnabled = true404 #expect(manager.isEnabled)405 manager.isEnabled = false406 }407408 @Test("Unwritable launch-agent roots do not enable autostart")409 func writeFailure() throws {410 let file = FileManager.default.temporaryDirectory.appendingPathComponent(UUID().uuidString)411 defer { try? FileManager.default.removeItem(at: file) }412 try Data("not a directory".utf8).write(to: file)413 let manager = AutostartManager(libraryDirectory: file, executablePath: { "/tmp/Haven" })414 manager.isEnabled = true415 #expect(!manager.isEnabled)416 }417418 @Test("Removal failures leave the launch agent enabled")419 func removalFailure() {420 let root = FileManager.default.temporaryDirectory.appendingPathComponent(UUID().uuidString)421 defer { try? FileManager.default.removeItem(at: root) }422 let manager = AutostartManager(423 libraryDirectory: root, executablePath: { "/tmp/Haven" },424 removePlist: { _ in throw CocoaError(.fileWriteNoPermission) })425 manager.isEnabled = true426 manager.isEnabled = false427 #expect(manager.isEnabled)428 }429}430431@Suite("Local wallpaper library", .serialized)432@MainActor433struct LocalWallpapersManagerTests {434 private func waitForScan(_ manager: LocalWallpapersManager) async {435 for _ in 0..<100 where manager.isLoading {436 try? await Task.sleep(nanoseconds: 10_000_000)437 }438 }439440 @Test("Scan filters files, reads metadata, and deletes wallpapers")441 func scanAndDelete() async throws {442 let defaults = UserDefaults.standard443 let oldPath = defaults.string(forKey: "saveFolderPath")444 defaults.removeObject(forKey: "saveFolderPath")445 defer {446 if let oldPath {447 defaults.set(oldPath, forKey: "saveFolderPath")448 } else {449 defaults.removeObject(forKey: "saveFolderPath")450 }451 }452 let root = FileManager.default.temporaryDirectory.appendingPathComponent(UUID().uuidString)453 defer { try? FileManager.default.removeItem(at: root) }454 try FileManager.default.createDirectory(at: root, withIntermediateDirectories: true)455 try onePixelPNG.write(to: root.appendingPathComponent("wallpaper.png"))456 try Data("broken".utf8).write(to: root.appendingPathComponent("broken.png"))457 try Data("ignored".utf8).write(to: root.appendingPathComponent("notes.txt"))458 let manager = LocalWallpapersManager()459460 manager.scanFolder(path: root.path)461 manager.scanFolder(path: root.path)462 await waitForScan(manager)463464 let wallpaper = try #require(manager.wallpapers.first)465 #expect(manager.wallpapers.count == 1)466 #expect(wallpaper.thumbnailURL == wallpaper.url)467 #expect(wallpaper.filename == "wallpaper.png")468 #expect(wallpaper.resolution == "1x1")469 #expect(LocalWallpapersManager.wallpaper(at: root.appendingPathComponent("broken.png")) == nil)470 #expect(LocalWallpapersManager.wallpaper(at: root.appendingPathComponent("missing.png")) == nil)471472 manager.deleteWallpaper(wallpaper)473 #expect(manager.wallpapers.isEmpty)474 manager.deleteWallpaper(wallpaper)475 #expect(manager.errorMessage?.hasPrefix("Failed to delete") == true)476 }477478 @Test("Invalid scan roots surface an error")479 func scanError() async throws {480 let defaults = UserDefaults.standard481 defaults.removeObject(forKey: "saveFolderPath")482 let file = FileManager.default.temporaryDirectory.appendingPathComponent(UUID().uuidString)483 defer { try? FileManager.default.removeItem(at: file) }484 try Data("file".utf8).write(to: file)485 let manager = LocalWallpapersManager()486487 manager.scanFolder(path: file.path)488 await waitForScan(manager)489490 #expect(manager.errorMessage?.hasPrefix("Failed to scan folder") == true)491 #expect(!manager.isLoading)492 }493494 @Test("Monitoring configured folders observes filesystem changes and stops")495 func monitoring() async throws {496 let defaults = UserDefaults.standard497 let oldPath = defaults.string(forKey: "saveFolderPath")498 let root = FileManager.default.temporaryDirectory.appendingPathComponent(UUID().uuidString)499 try FileManager.default.createDirectory(at: root, withIntermediateDirectories: true)500 defaults.set(root.path, forKey: "saveFolderPath")501 defer {502 try? FileManager.default.removeItem(at: root)503 if let oldPath {504 defaults.set(oldPath, forKey: "saveFolderPath")505 } else {506 defaults.removeObject(forKey: "saveFolderPath")507 }508 }509 let manager = LocalWallpapersManager()510 await waitForScan(manager)511512 try onePixelPNG.write(to: root.appendingPathComponent("observed.png"))513 try? await Task.sleep(nanoseconds: 100_000_000)514 await waitForScan(manager)515 #expect(manager.wallpapers.contains(where: { $0.filename == "observed.png" }))516517 manager.stopMonitoring()518 try? await Task.sleep(nanoseconds: 500_000_000)519520 let invalidMonitor = FolderMonitor(folderPath: root.appendingPathComponent("missing").path) {}521 invalidMonitor.start()522 invalidMonitor.closeFileDescriptor()523524 let descriptor = open("/dev/null", O_RDONLY)525 let descriptorMonitor = FolderMonitor(526 folderPath: "/dev/null", fileDescriptor: descriptor, callback: {})527 descriptorMonitor.closeFileDescriptor()528 #expect(fcntl(descriptor, F_GETFD) == -1)529 }530}