@testable import PureXML
import Testing
/// Per-rule isolation tests (Validation rules XSD).
@Suite("Validation rules XSD")
struct ValidationRuleXSDTests {
@Test("XSD.contentValidity locates a simple-type violation at the root element")
func test_xsdContentValidity() throws {
let xsd = """
"""
let compiled = try PureXML.Schema.XSDParser.parse(xsd)
let node = try PureXML.parse("x")
guard case let .document(children) = node, let root = children.compactMap(\.element).first else {
Issue.record("no root element")
return
}
let context = ValidationRuleTestSupport.XSDContext(
types: compiled.types,
constraints: compiled.constraints,
rootDeclaration: compiled.elements["n"],
)
// The validator is rooted at the document element, as Schema.Document does.
let errors = PureXML.Validation.Validator.blank
.validating(PureXML.Validation.XSD.contentValidity)
.errors(for: .element(root), in: context)
#expect(errors.count == 1)
#expect(errors.first?.reason.contains("n") == true)
#expect(errors.first.map(ValidationRuleTestSupport.path) == ["n"])
}
@Test("XSD.contentValidity accepts a valid integer at the boundary")
func test_xsdContentValidity_succeeds() throws {
let xsd = """
"""
let compiled = try PureXML.Schema.XSDParser.parse(xsd)
let node = try PureXML.parse("0")
guard case let .document(children) = node, let root = children.compactMap(\.element).first else {
Issue.record("no root element")
return
}
let context = ValidationRuleTestSupport.XSDContext(types: compiled.types, constraints: compiled.constraints, rootDeclaration: compiled.elements["n"])
let errors = PureXML.Validation.Validator.blank
.validating(PureXML.Validation.XSD.contentValidity)
.errors(for: .element(root), in: context)
#expect(errors.isEmpty)
}
@Test("XSD.identityConstraints reports a duplicate key field")
func test_xsdIdentityConstraints() throws {
let xsd = """
"""
let compiled = try PureXML.Schema.XSDParser.parse(xsd)
let node = try PureXML.parse("
")
guard case let .document(children) = node, let root = children.compactMap(\.element).first else {
Issue.record("no root element")
return
}
let context = ValidationRuleTestSupport.XSDContext(types: compiled.types, constraints: compiled.constraints, rootDeclaration: compiled.elements["list"])
let errors = PureXML.Validation.Validator.blank
.validating(PureXML.Validation.XSD.identityConstraints)
.errors(for: .element(root), in: context)
#expect(!errors.isEmpty)
}
@Test("XSD.identityConstraints accepts distinct field values")
func test_xsdIdentityConstraints_succeeds() throws {
let xsd = """
"""
let compiled = try PureXML.Schema.XSDParser.parse(xsd)
let node = try PureXML.parse("
")
guard case let .document(children) = node, let root = children.compactMap(\.element).first else { return }
let context = ValidationRuleTestSupport.XSDContext(types: compiled.types, constraints: compiled.constraints, rootDeclaration: compiled.elements["list"])
#expect(PureXML.Validation.Validator.blank.validating(PureXML.Validation.XSD.identityConstraints).errors(
for: .element(root),
in: context,
).isEmpty)
}
@Test("XSDSchema.finalRespected rejects a derivation forbidden by final")
func test_xsdFinalRespected() throws {
let xsd = """
"""
let compiled = try PureXML.Schema.XSDParser.parse(xsd)
let facts = PureXML.Schema.CompiledSchemaFacts(types: compiled.types, typeDerivation: compiled.typeDerivation, typeFinal: compiled.typeFinal)
let fact = PureXML.Schema.SchemaTypeFact(name: "CircleT", derivation: compiled.typeDerivation["CircleT"])
let errors = PureXML.Validation.BuiltinValidation.xsdFinalRespected.apply(to: fact, at: [.element("CircleT")], in: facts)
#expect(errors.count == 1)
}
@Test("XSDSchema.finalRespected accepts a derivation the base permits")
func test_xsdFinalRespected_succeeds() throws {
let xsd = """
"""
let compiled = try PureXML.Schema.XSDParser.parse(xsd)
let facts = PureXML.Schema.CompiledSchemaFacts(types: compiled.types, typeDerivation: compiled.typeDerivation, typeFinal: compiled.typeFinal)
let fact = PureXML.Schema.SchemaTypeFact(name: "ShapeT", derivation: nil)
#expect(PureXML.Validation.BuiltinValidation.xsdFinalRespected.apply(to: fact, at: [.element("ShapeT")], in: facts).isEmpty)
}
@Test("XSDSchema.restrictionsAreSubsets rejects an unfaithful restriction")
func test_xsdRestrictionsAreSubsets() throws {
let xsd = """
"""
let compiled = try PureXML.Schema.XSDParser.parse(xsd)
let facts = PureXML.Schema.CompiledSchemaFacts(types: compiled.types, typeDerivation: compiled.typeDerivation, typeFinal: compiled.typeFinal)
let fact = PureXML.Schema.SchemaTypeFact(name: "R", derivation: compiled.typeDerivation["R"])
#expect(!PureXML.Validation.BuiltinValidation.xsdRestrictionsAreSubsets.apply(to: fact, at: [.element("R")], in: facts).isEmpty)
}
@Test("XSDSchema.restrictionsAreSubsets accepts a faithful restriction")
func test_xsdRestrictionsAreSubsets_succeeds() throws {
let xsd = """
"""
let compiled = try PureXML.Schema.XSDParser.parse(xsd)
let facts = PureXML.Schema.CompiledSchemaFacts(types: compiled.types, typeDerivation: compiled.typeDerivation, typeFinal: compiled.typeFinal)
let fact = PureXML.Schema.SchemaTypeFact(name: "R", derivation: compiled.typeDerivation["R"])
#expect(PureXML.Validation.BuiltinValidation.xsdRestrictionsAreSubsets.apply(to: fact, at: [.element("R")], in: facts).isEmpty)
}
}