@testable import PureYAML import Testing private struct Address: PureYAML.Validation.Validatable { var city: String } private struct Nickname: PureYAML.Validation.Validatable { var value: String } private struct Person: PureYAML.Validation.Validatable { var name: String var age: Int var address: Address var nickname: Nickname? } @Suite("Validation combinators") struct ValidationCombinatorTests { private typealias Context = PureYAML.Validation.ValidationContext private func context(name: String = "Ada", age: Int = 30, city: String = "Lovelace", nickname: String? = nil) -> Context { .init( document: .null, subject: Person(name: name, age: age, address: Address(city: city), nickname: nickname.map(Nickname.init)), path: .root, ) } private func failing(_ description: String) -> PureYAML.Validation.Validation { .init(description: description) { ctx in [PureYAML.Validation.ValidationError(severity: .error, reason: description, path: ctx.path)] } } private func passing(_ description: String) -> PureYAML.Validation.Validation { .init(description: description) { _ in [] } } @Test("Comparison operators lift a key path and a literal into a predicate") func test_comparisonOperators() { let isAdult = (\Context.subject.age) >= 18 #expect(isAdult(context(age: 30)) == true) #expect(isAdult(context(age: 17)) == false) let named = (\Context.subject.name) == "Ada" #expect(named(context(name: "Ada")) == true) #expect(named(context(name: "Bob")) == false) } @Test("take digs to a value and runs arbitrary logic") func test_take() { let cityIsSet: @Sendable (Context) -> Bool = PureYAML.Validation.take(\Person.address) { !$0.city.isEmpty } #expect(cityIsSet(context(city: "Lovelace")) == true) #expect(cityIsSet(context(city: "")) == false) } @Test("A Bool check built from an operator auto-formats its failure") func test_boolCheckFromOperator() { let adult = PureYAML.Validation.Validation( description: "Person is an adult", check: (\Context.subject.age) >= 18, ) #expect(adult.apply(context(age: 30)).isEmpty) let issues = adult.apply(context(age: 10)) #expect(issues.count == 1) #expect(issues.first?.reason == "Failed to satisfy: Person is an adult") } @Test("all applies every check to the same context, concatenating errors") func test_all() { let combined = PureYAML.Validation.all(failing("one"), passing("ok"), failing("two")) #expect(combined.apply(context()).map(\.reason) == ["one", "two"]) } @Test("&& concatenates both error lists") func test_andConcatenates() { let combined = failing("a") && failing("b") #expect(combined.apply(context()).map(\.reason) == ["a", "b"]) #expect((passing("a") && passing("b")).apply(context()).isEmpty) } @Test("|| short-circuits and errors only when both fail") func test_orShortCircuits() { #expect((passing("a") || failing("b")).apply(context()).isEmpty) #expect((failing("a") || passing("b")).apply(context()).isEmpty) #expect((failing("a") || failing("b")).apply(context()).map(\.reason) == ["a", "b"]) } @Test("lift runs child-typed checks against a value reached by key path") func test_lift() { let cityNotEmpty = PureYAML.Validation.Validation( description: "City is set", check: { !$0.subject.city.isEmpty }, ) let lifted = PureYAML.Validation.lift(\Person.address, into: cityNotEmpty) #expect(lifted.apply(context(city: "Lovelace")).isEmpty) #expect(lifted.apply(context(city: "")).count == 1) } @Test("unwrap errors on nil and otherwise runs child checks against the unwrapped value") func test_unwrap() { let notEmpty = PureYAML.Validation.Validation( description: "Nickname is not empty", check: { !$0.subject.value.isEmpty }, ) let unwrapped = PureYAML.Validation.unwrap(\Person.nickname, into: notEmpty) let onNil = unwrapped.apply(context(nickname: nil)) #expect(onNil.count == 1) #expect(onNil.first?.reason.contains("nil") == true) let onValid = unwrapped.apply(context(nickname: "Ada")) #expect(onValid.isEmpty) let onInvalid = unwrapped.apply(context(nickname: "")) #expect(onInvalid.count == 1) #expect(onInvalid.first?.reason == "Failed to satisfy: Nickname is not empty") } }