PureYAML/Tests/ValidationCombinatorTests.swift
Mihaela M 1915a00fde feat(validation): add the combinator algebra for checks
Add the declarative combinators the validation idiom composes rules from,
as free functions returning closures: comparison operators (==, !=, <, <=,
>, >=) lifting a key path and a literal into a predicate; take to dig to a
value and run arbitrary logic; all to apply many checks to one context; lift
to run child-typed checks against a value reached by key path; and && / ||
to compose two checks (concatenating their errors, or short-circuiting so
errors surface only when both fail). Both the context-rooted and
subject-rooted key-path forms are provided so an author can pin the subject
type in either clause.

A key path is immutable and read-safe but not declared Sendable, so a
@Sendable predicate captures it through a small @unchecked Sendable box.
lookup is omitted: it resolves references against a component store the
generic model does not carry; a consumer with references supplies it.

Each combinator has a pure-function test against a hand-built context, per
the idiom's requirement to unit test the operators in isolation.
2026-06-28 09:27:17 +02:00

86 lines
3.5 KiB
Swift

@testable import PureYAML
import Testing
private struct Address: PureYAML.Validation.Validatable {
var city: String
}
private struct Person: PureYAML.Validation.Validatable {
var name: String
var age: Int
var address: Address
}
@Suite("Validation combinators")
struct ValidationCombinatorTests {
private typealias Context = PureYAML.Validation.SubjectContext<Person>
private func context(name: String = "Ada", age: Int = 30, city: String = "Lovelace") -> Context {
.init(document: .null, subject: Person(name: name, age: age, address: Address(city: city)), path: .root)
}
private func failing(_ description: String) -> PureYAML.Validation.Check<Person> {
.init(description: description) { ctx in
[PureYAML.Validation.Issue(severity: .error, reason: description, path: ctx.path)]
}
}
private func passing(_ description: String) -> PureYAML.Validation.Check<Person> {
.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 = 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.Check<Person>(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.Check<Address>(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)
}
}