125 lines
7.8 KiB
Swift
125 lines
7.8 KiB
Swift
import Foundation
|
|
import TerebiConfiguration
|
|
|
|
@main
|
|
struct ConfigurationChecks {
|
|
struct Failure: Error, CustomStringConvertible {
|
|
let description: String
|
|
}
|
|
|
|
static func require(_ condition: Bool, _ message: String) throws {
|
|
if !condition { throw Failure(description: "FAIL: " + message) }
|
|
}
|
|
|
|
static func requireLoadError(at url: URL, _ message: String) throws {
|
|
do {
|
|
_ = try PlayerConfiguration.load(from: url)
|
|
} catch let caught {
|
|
let diagnostic = caught.localizedDescription + " " + String(describing: caught)
|
|
try require(diagnostic.contains(url.path), message + " identifies the actual config path")
|
|
return
|
|
}
|
|
throw Failure(description: "FAIL: " + message + " was accepted")
|
|
}
|
|
|
|
static func main() throws {
|
|
let files = FileManager.default
|
|
let root = files.temporaryDirectory.appendingPathComponent("terebi.configuration-check.\(UUID().uuidString)")
|
|
try files.createDirectory(at: root, withIntermediateDirectories: true)
|
|
defer { try? files.removeItem(at: root) }
|
|
let home = root.appendingPathComponent("home")
|
|
let xdg = root.appendingPathComponent("xdg")
|
|
let fallback = home.appendingPathComponent(".config/terebi/config.toml")
|
|
let config = xdg.appendingPathComponent("terebi/config.toml")
|
|
let defaults = PlayerConfiguration()
|
|
try require(!defaults.showBufferInfo && !defaults.automaticQuality && defaults.snapToEdges,
|
|
"built-in defaults hide buffer info, disable automatic quality, and enable snapping")
|
|
try require(PlayerConfiguration.fileURL(environment: ["XDG_CONFIG_HOME": xdg.path], homeDirectory: home) == config,
|
|
"absolute XDG_CONFIG_HOME selects terebi/config.toml")
|
|
for environment in [[:], ["XDG_CONFIG_HOME": ""], ["XDG_CONFIG_HOME": "relative/config"]] {
|
|
try require(PlayerConfiguration.fileURL(environment: environment, homeDirectory: home) == fallback,
|
|
"unset, empty, and relative XDG_CONFIG_HOME fall back to ~/.config")
|
|
}
|
|
try require(try PlayerConfiguration.load(from: fallback) == defaults, "missing files use built-in defaults")
|
|
try require(try PlayerConfiguration.loadForApplication(arguments: [], environment: [:], homeDirectory: home) == defaults,
|
|
"application startup uses defaults when its resolved config is missing")
|
|
try require(!files.fileExists(atPath: home.path), "missing-file loading creates neither home, config directory, nor file")
|
|
|
|
try files.createDirectory(at: config.deletingLastPathComponent(), withIntermediateDirectories: true)
|
|
let original = Data("""
|
|
# Root keys can be quoted, with comments and whitespace.
|
|
"show_buffer_info" = true # session display default
|
|
'automatic_quality' = true
|
|
snap_to_edges = false
|
|
""".utf8)
|
|
try original.write(to: config)
|
|
let configured = PlayerConfiguration(showBufferInfo: true, automaticQuality: true, snapToEdges: false)
|
|
let environment = ["XDG_CONFIG_HOME": xdg.path]
|
|
try require(try PlayerConfiguration.load(from: config) == configured,
|
|
"TOML comments, whitespace, quoted root keys, and both boolean values load")
|
|
var session = try PlayerConfiguration.loadForApplication(arguments: [], environment: environment, homeDirectory: home)
|
|
try require(session == configured, "application startup automatically loads the XDG config")
|
|
session.showBufferInfo = false
|
|
session.automaticQuality = false
|
|
session.snapToEdges = true
|
|
try require(session == defaults, "controls can override all settings within the session")
|
|
try require(try Data(contentsOf: config) == original, "loading and session overrides do not change config bytes")
|
|
try require(try PlayerConfiguration.load(from: config) == configured, "a fresh load resets session overrides to file values")
|
|
|
|
let partial = root.appendingPathComponent("partial.toml")
|
|
try Data("automatic_quality = true\n".utf8).write(to: partial)
|
|
try require(try PlayerConfiguration.load(from: partial) == PlayerConfiguration(automaticQuality: true),
|
|
"partial configuration retains defaults for omitted settings")
|
|
let empty = root.appendingPathComponent("empty.toml")
|
|
try Data("# Defaults only\n\n".utf8).write(to: empty)
|
|
try require(try PlayerConfiguration.load(from: empty) == defaults, "empty/comment-only TOML uses defaults")
|
|
try require(try PlayerConfiguration.loadForApplication(arguments: ["--config-file", partial.absoluteString],
|
|
environment: environment, homeDirectory: home)
|
|
== PlayerConfiguration(automaticQuality: true), "explicit file URL overrides the resolved XDG config")
|
|
|
|
let invalid: [(String, String)] = [
|
|
("syntax", "show_buffer_info = [\n"),
|
|
("duplicate", "show_buffer_info = true\n\"show_buffer_info\" = false\n"),
|
|
("unknown", "unknown_setting = true\n"),
|
|
("string", "show_buffer_info = \"true\"\n"),
|
|
("integer", "automatic_quality = 1\n"),
|
|
("array", "snap_to_edges = [true]\n"),
|
|
("table", "[show_buffer_info]\nenabled = true\n")
|
|
]
|
|
for (name, text) in invalid {
|
|
let url = root.appendingPathComponent(name + ".toml")
|
|
let bytes = Data(text.utf8)
|
|
try bytes.write(to: url)
|
|
try requireLoadError(at: url, "invalid \(name) configuration")
|
|
try require(try Data(contentsOf: url) == bytes, "rejected \(name) config remains unchanged")
|
|
}
|
|
let invalidUTF8 = root.appendingPathComponent("invalid-utf8.toml")
|
|
let invalidBytes = Data([0xff, 0xfe, 0x80])
|
|
try invalidBytes.write(to: invalidUTF8)
|
|
try requireLoadError(at: invalidUTF8, "invalid UTF-8 configuration")
|
|
try require(try Data(contentsOf: invalidUTF8) == invalidBytes, "invalid UTF-8 config remains unchanged")
|
|
let directory = root.appendingPathComponent("directory.toml")
|
|
try files.createDirectory(at: directory, withIntermediateDirectories: false)
|
|
try requireLoadError(at: directory, "directory instead of config file")
|
|
|
|
let malformed = root.appendingPathComponent("syntax.toml")
|
|
let inaccessible = partial.appendingPathComponent("config.toml") // A regular file cannot be traversed as a directory.
|
|
for url in [malformed, inaccessible, directory] {
|
|
try require(try PlayerConfiguration.loadForApplication(arguments: ["--config-file", url.absoluteString, "--no-config"],
|
|
environment: environment, homeDirectory: home) == defaults,
|
|
"--no-config bypasses malformed, inaccessible, and directory config paths")
|
|
}
|
|
let badXDG = root.appendingPathComponent("bad-xdg")
|
|
let badConfig = badXDG.appendingPathComponent("terebi/config.toml")
|
|
try files.createDirectory(at: badConfig.deletingLastPathComponent(), withIntermediateDirectories: true)
|
|
let malformedBytes = Data("snap_to_edges =\n".utf8)
|
|
try malformedBytes.write(to: badConfig)
|
|
try require(try PlayerConfiguration.loadForApplication(arguments: ["--no-config"],
|
|
environment: ["XDG_CONFIG_HOME": badXDG.path], homeDirectory: home) == defaults,
|
|
"--no-config also bypasses automatic XDG loading")
|
|
try require(try Data(contentsOf: badConfig) == malformedBytes, "bypassing config never repairs or rewrites it")
|
|
try require(!files.fileExists(atPath: home.path), "all checks leave the isolated fallback home uncreated")
|
|
print("Configuration checks passed")
|
|
}
|
|
}
|