208 lines
9.4 KiB
Swift
208 lines
9.4 KiB
Swift
import AppKit
|
|
import Testing
|
|
@testable import Conjure
|
|
|
|
@Test @MainActor
|
|
func livePaletteReloadsGeneratedColorsKeepsOverridesAndRetainsLastValidPalette() throws {
|
|
let original = ThemePalette.loaded
|
|
let directory = FileManager.default.temporaryDirectory.appendingPathComponent(UUID().uuidString)
|
|
try FileManager.default.createDirectory(at: directory, withIntermediateDirectories: true)
|
|
defer {
|
|
ThemePalette.loaded = original
|
|
try? FileManager.default.removeItem(at: directory)
|
|
}
|
|
let config = directory.appendingPathComponent("config.toml")
|
|
let theme = directory.appendingPathComponent("theme.json")
|
|
ThemePalette.reload(from: directory)
|
|
let white = NSColor(srgbRed: 1, green: 1, blue: 1, alpha: 1)
|
|
let black = NSColor(srgbRed: 0, green: 0, blue: 0, alpha: 1)
|
|
let changes = PaletteChanges()
|
|
let observer = NotificationCenter.default.addObserver(
|
|
forName: ThemePalette.didChangeNotification, object: nil, queue: .main
|
|
) { _ in
|
|
MainActor.assumeIsolated {
|
|
changes.count += 1
|
|
changes.background = ThemePalette.background
|
|
changes.accent = ThemePalette.accent
|
|
}
|
|
}
|
|
defer { NotificationCenter.default.removeObserver(observer) }
|
|
try Data("theme = 'tint'\ncolors.accent = '#ffffff'\n".utf8).write(to: config)
|
|
try Data(##"{"colors":{"background":"#123456","accent":"#ff0000","text":"#000000"}}"##.utf8)
|
|
.write(to: theme)
|
|
#expect(ThemePalette.reload(from: directory))
|
|
let firstBackground = ThemePalette.background
|
|
#expect(ThemePalette.accent == white)
|
|
#expect(ThemePalette.text == black)
|
|
#expect(changes.count == 1)
|
|
#expect(changes.background == ThemePalette.background)
|
|
#expect(changes.accent == ThemePalette.accent)
|
|
#expect(ThemePalette.background.alphaComponent == 0.55)
|
|
#expect(ThemePalette.selectionFill.alphaComponent == 0.12)
|
|
#expect(ThemePalette.selectionBorder.alphaComponent == 0.30)
|
|
#expect(ThemePalette.keyBackground.alphaComponent == 0.5)
|
|
#expect(!ThemePalette.reload(from: directory))
|
|
#expect(changes.count == 1)
|
|
|
|
try Data(##"{"colors":{"background":"#abcdef","accent":"#00ff00","text":"#ffffff"}}"##.utf8)
|
|
.write(to: theme, options: .atomic)
|
|
#expect(ThemePalette.reload(from: directory))
|
|
#expect(ThemePalette.background != firstBackground)
|
|
#expect(ThemePalette.accent == white)
|
|
#expect(ThemePalette.text == white)
|
|
#expect(changes.count == 2)
|
|
let lastBackground = ThemePalette.background
|
|
|
|
try Data("partial JSON".utf8).write(to: theme)
|
|
#expect(!ThemePalette.reload(from: directory))
|
|
#expect(ThemePalette.background == lastBackground)
|
|
#expect(ThemePalette.text == white)
|
|
#expect(changes.count == 2)
|
|
#expect(ThemePalette.configurationError?.contains(theme.path) == true)
|
|
|
|
try Data(##"{"colors":{"background":"#abcdef","text":"#ffffff"}}"##.utf8).write(to: theme)
|
|
#expect(!ThemePalette.reload(from: directory))
|
|
#expect(ThemePalette.configurationError == nil)
|
|
#expect(changes.count == 2)
|
|
|
|
try Data("colors.accent = '#invalid'\n".utf8).write(to: config)
|
|
#expect(!ThemePalette.reload(from: directory))
|
|
#expect(ThemePalette.background == lastBackground)
|
|
#expect(ThemePalette.configurationError?.contains(config.path) == true)
|
|
#expect(changes.count == 2)
|
|
|
|
try Data("theme = 'sunset'\n".utf8).write(to: config)
|
|
#expect(ThemePalette.reload(from: directory))
|
|
#expect(ThemePalette.background == ColorScheme.sunset.background.withAlphaComponent(0.55))
|
|
#expect(ThemePalette.accent == ColorScheme.sunset.accent)
|
|
#expect(changes.count == 3)
|
|
#expect(ThemePalette.configurationError == nil)
|
|
}
|
|
|
|
@MainActor private final class PaletteChanges {
|
|
var count = 0
|
|
var background: NSColor?
|
|
var accent: NSColor?
|
|
}
|
|
|
|
@Test(arguments: ["config.toml", "theme.json"]) @MainActor
|
|
func liveObservationDetectsInPlaceWritesAndRearmsAfterAtomicReplacement(_ filename: String) async throws {
|
|
let root = FileManager.default.temporaryDirectory.appendingPathComponent(UUID().uuidString)
|
|
let directory = root.appendingPathComponent("conjure")
|
|
try FileManager.default.createDirectory(at: directory, withIntermediateDirectories: true)
|
|
defer { try? FileManager.default.removeItem(at: root) }
|
|
let file = directory.appendingPathComponent(filename)
|
|
try Data("initial".utf8).write(to: file)
|
|
let events = AsyncStream<String>.makeStream()
|
|
let observation = ColorSchemeObservation(directory: directory) {
|
|
events.continuation.yield((try? String(contentsOf: file, encoding: .utf8)) ?? "<missing>")
|
|
}
|
|
defer {
|
|
events.continuation.finish()
|
|
withExtendedLifetime(observation) {}
|
|
}
|
|
|
|
try overwriteInPlace("in-place", at: file)
|
|
try await expectObserved("in-place", from: events.stream)
|
|
try Data("atomic".utf8).write(to: file, options: .atomic)
|
|
try await expectObserved("atomic", from: events.stream)
|
|
try overwriteInPlace("after-replacement", at: file)
|
|
try await expectObserved("after-replacement", from: events.stream)
|
|
}
|
|
|
|
@Test @MainActor
|
|
func liveObservationFindsInitiallyMissingDirectoriesAndRecoversAfterRemoval() async 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 missingAncestor = root.appendingPathComponent("missing")
|
|
let directory = missingAncestor.appendingPathComponent("conjure")
|
|
let file = directory.appendingPathComponent("theme.json")
|
|
let events = AsyncStream<String>.makeStream()
|
|
let observation = ColorSchemeObservation(directory: directory) {
|
|
events.continuation.yield((try? String(contentsOf: file, encoding: .utf8)) ?? "<missing>")
|
|
}
|
|
defer {
|
|
events.continuation.finish()
|
|
withExtendedLifetime(observation) {}
|
|
}
|
|
|
|
try FileManager.default.createDirectory(at: directory, withIntermediateDirectories: true)
|
|
try Data("created".utf8).write(to: file)
|
|
try await expectObserved("created", from: events.stream)
|
|
try overwriteInPlace("created-then-edited", at: file)
|
|
try await expectObserved("created-then-edited", from: events.stream)
|
|
|
|
try FileManager.default.removeItem(at: missingAncestor)
|
|
try await expectObserved("<missing>", from: events.stream)
|
|
try FileManager.default.createDirectory(at: directory, withIntermediateDirectories: true)
|
|
try Data("recreated".utf8).write(to: file, options: .atomic)
|
|
try await expectObserved("recreated", from: events.stream)
|
|
try overwriteInPlace("recreated-then-edited", at: file)
|
|
try await expectObserved("recreated-then-edited", from: events.stream)
|
|
}
|
|
|
|
private func overwriteInPlace(_ value: String, at url: URL) throws {
|
|
let handle = try FileHandle(forWritingTo: url)
|
|
defer { try? handle.close() }
|
|
try handle.truncate(atOffset: 0)
|
|
try handle.write(contentsOf: Data(value.utf8))
|
|
}
|
|
|
|
private struct ObservationTimeout: Error {}
|
|
|
|
private func expectObserved(_ expected: String, from events: AsyncStream<String>) async throws {
|
|
try await withThrowingTaskGroup(of: Void.self) { group in
|
|
group.addTask {
|
|
for await value in events {
|
|
if value == expected { return }
|
|
}
|
|
throw CancellationError()
|
|
}
|
|
group.addTask {
|
|
// Only a failure deadline: event delivery, not a sleep, advances the test.
|
|
try await Task.sleep(for: .seconds(5))
|
|
throw ObservationTimeout()
|
|
}
|
|
defer { group.cancelAll() }
|
|
_ = try await group.next()
|
|
}
|
|
}
|
|
|
|
@Test @MainActor
|
|
func liveBackgroundRebuildsCachedGradientsWithoutReplacingTheView() throws {
|
|
_ = NSApplication.shared
|
|
let original = ThemePalette.loaded
|
|
let directory = FileManager.default.temporaryDirectory.appendingPathComponent(UUID().uuidString)
|
|
try FileManager.default.createDirectory(at: directory, withIntermediateDirectories: true)
|
|
let window = NSWindow(contentRect: NSRect(x: 0, y: 0, width: 750, height: 480),
|
|
styleMask: .borderless, backing: .buffered, defer: false)
|
|
window.isReleasedWhenClosed = false
|
|
defer {
|
|
ThemePalette.loaded = original
|
|
window.orderOut(nil)
|
|
try? FileManager.default.removeItem(at: directory)
|
|
}
|
|
let config = directory.appendingPathComponent("config.toml")
|
|
try Data("colors.accent = '#ff0000'\ncolors.glow = '#ff0000'\n".utf8).write(to: config)
|
|
ThemePalette.reload(from: directory)
|
|
let background = LauncherBackground(frame: NSRect(x: 0, y: 0, width: 750, height: 480))
|
|
window.contentView?.addSubview(background)
|
|
func glowColor() throws -> NSColor {
|
|
let bitmap = try #require(background.bitmapImageRepForCachingDisplay(in: background.bounds))
|
|
background.cacheDisplay(in: background.bounds, to: bitmap)
|
|
return try #require(bitmap.colorAt(x: Int(CGFloat(bitmap.pixelsWide) * 0.58),
|
|
y: Int(CGFloat(bitmap.pixelsHigh) * 0.06))?.usingColorSpace(.deviceRGB))
|
|
}
|
|
let before = try glowColor()
|
|
let backgroundColor = ThemePalette.background
|
|
background.needsDisplay = false
|
|
try Data("colors.accent = '#00ff00'\ncolors.glow = '#00ff00'\n".utf8).write(to: config)
|
|
#expect(ThemePalette.reload(from: directory))
|
|
#expect(ThemePalette.background == backgroundColor)
|
|
#expect(background.needsDisplay)
|
|
let after = try glowColor()
|
|
#expect(before.redComponent > after.redComponent)
|
|
#expect(after.greenComponent > before.greenComponent)
|
|
}
|