public void ExtendsRule1()
{
SchematronValidator validator = new SchematronValidator(SchematronReader.ReadSchematron("Schematron/Samples/All.sch"));
XmlDocument doc = new XmlDocument();
doc.LoadXml("<fixed-element name='x1' xmlns='urn:testing'>bad value</fixed-element>");
ExceptionAssert.Throws<SchematronValidationException>(() => validator.Validate(doc), "/fixed-element must be 'fixed");
}
public void Validate(XmlDocument document)
{
try
{
this.logger.Trace("SchematronValidation");
if (document == null)
{
throw new SchematronValidationInterceptionEmptyBodyException();
}
DocumentTypeConfig documentType = searcher.FindUniqueDocumentType(document);
SchematronStore store = new SchematronStore();
SchematronValidationConfig[] schematronValidationConfigCollection = documentType.SchematronValidationConfigs;
foreach (SchematronValidationConfig schematronValidationConfig in schematronValidationConfigCollection)
{
CompiledXslt compiledXsltEntry = store.GetCompiledSchematron(schematronValidationConfig.SchematronDocumentPath);
SchematronValidator validator = new SchematronValidator(schematronValidationConfig.ErrorXPath, schematronValidationConfig.ErrorMessageXPath);
validator.SchematronValidateXmlDocument(document, compiledXsltEntry);
}
}
catch (SchematronErrorException ex)
{
this.logger.Info("XmlDocument rejected, as it contant at least one schematron error.");
throw new SchematronValidateDocumentFailedException(ex);
}
catch (Exception ex)
{
this.logger.Error("Schematron validation failed", ex);
throw new SchematronValidateDocumentFailedException(ex);
}
}
public void NameErrorMessage_NoPrefix()
{
SchematronValidator validator = new SchematronValidator(SchematronReader.ReadSchematron("Schematron/Samples/All.sch"));
XmlDocument doc = new XmlDocument();
doc.LoadXml("<dummy xmlns='urn:testing'/>");
ExceptionAssert.Throws<SchematronValidationException>(() => validator.Validate(doc), "The element /dummy is not allowed.");
}
public void Validate_NonIsoDocument_OnText()
{
string nonIsoDocument = _fileResolver.GetResourceStream("Generic_CDA_Document_OldSchematron.xml").GetText();
var res = new SchematronValidator(nonIsoDocument, convertToIsoNamespace: true).Validate(_fileResolver.GetResourceStream("POCD_EX150001UK06_05.xml").GetText());
Assert.True(res.Status);
}
public void ExtendsRule2()
{
SchematronValidator validator = new SchematronValidator(SchematronReader.ReadSchematron("Schematron/Samples/All.sch"));
XmlDocument doc = new XmlDocument();
doc.LoadXml("<fixed-element name='X1' xmlns='urn:testing'>fixed</fixed-element>");
ExceptionAssert.Throws<SchematronValidationException>(() => validator.Validate(doc), "The attribute 'name', of element /fixed-element, is required and must start with 'x'");
}
private void Validate(string xmlDocumentPath, DocumentTypeConfig documentType)
{
Console.WriteLine("{0} Schematron validation started ", DateTime.Now);
SchematronValidationConfig[] SchematronValidationConfig = documentType.SchematronValidationConfigs;
XmlDocument document = new XmlDocument();
Console.WriteLine("{0} Loading Xml Document '{1}'", DateTime.Now, xmlDocumentPath);
document.Load(xmlDocumentPath);
Console.WriteLine("{0} Instanciating the validator ", DateTime.Now);
foreach (SchematronValidationConfig schematronValidationConfig in SchematronValidationConfig)
{
try
{
SchematronValidator validator = new SchematronValidator(schematronValidationConfig);
Console.WriteLine("{0} Schematron validation", DateTime.Now);
validator.SchematronValidateXmlDocument(document);
}
catch (Exception ex)
{
Debug.Fail("Something is wrong:" + ex.Message);
throw;
}
}
Console.WriteLine("{0} Schematron validation completed", DateTime.Now);
}
private void InitFromConfiguration(IPreloadedConverterConfiguration configuration)
{
if (configuration.TransformStylesheetPath == null)
{
throw new ArgumentNullException("configuration.TransformStylesheetPath");
}
try {
XsltSettings xsltSettings = new XsltSettings(true, true);
XmlUrlResolver resolver = new XmlUrlResolver();
_closeSourceStream = configuration.CloseSourceStream;
_transform = new XslCompiledTransform();
//Tries to load the transformation path, if the path is not absolute and the file
//does not exists then try with the appdomain base directory as root folder
string transformationPath = configuration.TransformStylesheetPath;
if (!Path.IsPathRooted(transformationPath) && !File.Exists(transformationPath))
{
transformationPath = AppDomain.CurrentDomain.BaseDirectory + Path.DirectorySeparatorChar + transformationPath;
transformationPath = Path.GetFullPath(transformationPath);
}
_transform.Load(transformationPath, xsltSettings, resolver);
IValidator resultSchemaValidator = null;
if (TryInitSchemaValidator(configuration.ResultSchemaConfiguration, out resultSchemaValidator))
{
_resultValidators.Add(resultSchemaValidator);
}
IValidator sourceSchemaValidator = null;
if (TryInitSchemaValidator(configuration.SourceSchemaConfiguration, out sourceSchemaValidator))
{
_sourceValidators.Add(sourceSchemaValidator);
}
IEnumerable <ISchematronValidatorConfiguration> resultSchematrons = configuration.GetResultSchematronConfigurations();
if (resultSchematrons != null)
{
foreach (ISchematronValidatorConfiguration schematronConfiguration in resultSchematrons)
{
SchematronValidator validator = new SchematronValidator(schematronConfiguration);
_resultValidators.Add(validator);
}
}
IEnumerable <ISchematronValidatorConfiguration> sourceSchematrons = configuration.GetSourceSchematronConfigurations();
if (sourceSchematrons != null)
{
foreach (ISchematronValidatorConfiguration schematronConfiguration in sourceSchematrons)
{
SchematronValidator validator = new SchematronValidator(schematronConfiguration);
_sourceValidators.Add(validator);
}
}
}
catch (Exception ex) {
throw new ConverterException("Initiation of the Converter failed, used stylesheetpath=" + configuration.TransformStylesheetPath, ex);
}
}
public void ElementMissing()
{
SchematronValidator validator = new SchematronValidator("Schematron/Samples/Person.Xml.Com.sch");
XmlDocument doc = new XmlDocument();
doc.LoadXml(
@"<Person Title='Mr'>
<Name>Eddie</Name>
</Person>");
ExceptionAssert.Throws<SchematronValidationException>(() => validator.Validate(doc), "The element Person should have the child elements Name and Gender.");
}
// this is likely to be moved to a "cda transformer" when the other renaming issue (MBG-184) is resolved
public virtual void PerformAdditionalCdaValidation(VersionNumber version, XmlDocument xmlDocument, Hl7Errors errorContainer
)
{
SchematronValidator schematronValidator = new SchematronValidator(this.service.GetAllSchematronContexts(version));
schematronValidator.Validate(xmlDocument, errorContainer);
ContainedTemplateValidator containedTemplateValidator = new ContainedTemplateValidator(this.service.GetAllPackageLocations
(version));
containedTemplateValidator.Validate(xmlDocument, errorContainer);
}
public void ElementOrder()
{
SchematronValidator validator = new SchematronValidator("Schematron/Samples/Person.Xml.Com.sch");
XmlDocument doc = new XmlDocument();
doc.LoadXml(
@"<Person Title='Mr'>
<Gender>Male</Gender>
<Name>Eddie</Name>
</Person>");
ExceptionAssert.Throws<SchematronValidationException>(() => validator.Validate(doc), "The element Name must appear before element Gender.");
}
public void Annotation()
{
SchematronValidator validator = new SchematronValidator(SchematronReader.ReadSchematron("Schematron/Samples/All.sch"));
XmlDocument doc = new XmlDocument();
doc.LoadXml("<document><a><foobar>x-1</foobar><foobar>x-2</foobar></a></document>");
errors.Clear();
validator.Validate(doc, new SchematronValidationEventHandler(handler));
Assert.AreEqual(2, errors.Count);
Assert.AreEqual("'x-1' is not an allowed value.", errors[0].Diagnostics[0]);
Assert.AreEqual("'x-2' is not an allowed value.", errors[1].Diagnostics[0]);
}
public void TitleMissing()
{
SchematronValidator validator = new SchematronValidator("Schematron/Samples/Person.Xml.Com.sch");
XmlDocument doc = new XmlDocument();
doc.LoadXml(
@"<Person>
<Gender>Male</Gender>
<Name>Eddie</Name>
</Person>");
ExceptionAssert.Throws<SchematronValidationException>(() => validator.Validate(doc), "The element Person must have a Title attribute");
}
public void GenderTitle()
{
SchematronValidator validator = new SchematronValidator("Schematron/Samples/Person.Xml.Com.sch");
XmlDocument doc = new XmlDocument();
doc.LoadXml(
@"<Person Title='Mr'>
<Name>Eddie</Name>
<Gender>Female</Gender>
</Person>");
ExceptionAssert.Throws<SchematronValidationException>(() => validator.Validate(doc), "If the Title is \"Mr\" then the gender of the person must be \"Male\".");
}
public bool TryValidating(SchematronValidator validator, XmlDocument instance)
{
try
{
validator.Validate(instance);
return true;
}
catch (SchematronValidationException)
{
return false;
}
}
public void OverrideDocumentLet()
{
SchematronDocument schema = Load("Schematron/Samples/Let.sch");
SchematronValidator validator = new SchematronValidator(schema);
validator.Parameters.Add("maxSec", "10");
XmlDocument doc = new XmlDocument();
doc.LoadXml("<times><time>23:10:00</time><time>23:10:50</time></times>");
errors.Clear();
validator.Validate(doc, new SchematronValidationEventHandler(handler));
Assert.AreEqual(1, errors.Count);
Assert.AreEqual("The second (50) must be a value between 0 and 10.", errors[0].Message);
}
public void PhaseAssertions()
{
SchematronDocument schema = Load("Schematron/Samples/Let.sch");
SchematronValidator validator = new SchematronValidator(schema);
XmlDocument doc = new XmlDocument();
doc.LoadXml("<times><time>23:10:00</time><time>23:10:50</time></times>");
errors.Clear();
validator.ValidationPhase = "no-seconds";
validator.Validate(doc, new SchematronValidationEventHandler(handler));
Assert.AreEqual(1, errors.Count);
Assert.AreEqual("The second (50) must be a value between 0 and 0.", errors[0].Message);
}
public void DoggieReportNoError()
{
XmlDocument dogs = new XmlDocument();
dogs.LoadXml(@"
<dogs>
<dog petname='spot'><nose/><ear/><bone/><ear/></dog>
</dogs>");
StringBuilder svrl = new StringBuilder();
SchematronValidator validator = new SchematronValidator("Schematron/Samples/Dog.sch");
ValidationReport report = new ValidationReport(validator, svrl);
validator.Validate(dogs);
Assert.IsFalse(report.HasValidationErrors);
}
public void Valid()
{
SchematronValidator validator = new SchematronValidator("Schematron/Samples/Person.Xml.Com.sch");
XmlDocument doc = new XmlDocument();
doc.LoadXml(
@"<Person Title='Mr'>
<Name>Eddie</Name>
<Gender>Male</Gender>
</Person>");
errors.Clear();
validator.Validate(doc, new SchematronValidationEventHandler(handler));
Assert.AreEqual(0, errors.Count);
}
public void DoggieConsoleReport()
{
XmlDocument dogs = new XmlDocument();
dogs.LoadXml(@"
<dogs>
<dog petname='spot'><nose/><ear/><bone/><ear/></dog>
<dog petname='hungry'><nose/><ear/><ear/></dog>
<dog petname='emanon'><nose/><ear/><bone/></dog>
<dog petname='smelly'><ear/><bone/><ear/></dog>
</dogs>");
SchematronValidator validator = new SchematronValidator("Schematron/Samples/Dog.sch");
ValidationReport report = new ValidationReport(validator, Console.Out);
validator.Validate(dogs);
}
public void Abstract()
{
SchematronDocument schema = Load("Schematron/Samples/AbstractPattern.sch");
SchematronWriter writer = new SchematronWriter();
writer.WriteDocument(schema.CompiledDocument, Console.Out);
SchematronValidator validator = new SchematronValidator(schema);
XmlDocument doc = new XmlDocument();
doc.LoadXml("<doc><foo id='a' bar='x'/><foo id='b'/><foo bar='x'/><foo/></doc>");
errors.Clear();
validator.Validate(doc, new SchematronValidationEventHandler(handler));
Assert.AreEqual(4, errors.Count);
Assert.AreEqual("The /doc/foo[3] element is missing a required attribute.", errors[0].Message);
Assert.AreEqual("The /doc/foo[4] element is missing a required attribute.", errors[1].Message);
Assert.AreEqual("The /doc/foo[2] element is missing a required attribute.", errors[2].Message);
Assert.AreEqual("The /doc/foo[4] element is missing a required attribute.", errors[3].Message);
}
public void MinimalIsValid()
{
SchematronDocument full = SchematronReader.ReadSchematron("Schematron/Samples/All.sch");
SchematronDocument minimal = new Compiler().Compile(full);
StringBuilder schematron = new StringBuilder();
minimal.Save(schematron);
XmlDocument minimalDocument = new XmlDocument();
minimalDocument.LoadXml(schematron.ToString());
SchematronValidator validator = new SchematronValidator(Schematron.Default.IsoSchematronSchema);
validator.ValidationPhase = "minimal";
validator.Validate(minimalDocument);
SchematronDocument minimal2 = new SchematronDocument();
minimal2.Load(schematron);
}
public void Math()
{
SchematronDocument schema = Load("Schematron/Samples/Exslt.sch");
SchematronValidator validator = new SchematronValidator(schema);
XmlDocument doc = new XmlDocument();
doc.LoadXml("<prices><price>10</price><price>0</price></prices>");
errors.Clear();
validator.Validate(doc, new SchematronValidationEventHandler(handler));
Assert.AreEqual(1, errors.Count);
Assert.AreEqual("All prices must be greater than zero.", errors[0].Message);
doc.LoadXml("<prices><price>10</price><price>2</price></prices>");
errors.Clear();
validator.Validate(doc, new SchematronValidationEventHandler(handler));
Assert.AreEqual(0, errors.Count);
}
public void DoggieReport()
{
XmlDocument dogs = new XmlDocument();
dogs.LoadXml(@"
<dogs>
<dog petname='spot'><nose/><ear/><bone/><ear/></dog>
<dog petname='hungry'><nose/><ear/><ear/></dog>
<dog petname='emanon'><nose/><ear/><bone/></dog>
<dog petname='smelly'><ear/><bone/><ear/></dog>
</dogs>");
StringBuilder svrl = new StringBuilder();
SchematronValidator validator = new SchematronValidator("Schematron/Samples/Dog.sch");
ValidationReport report = new ValidationReport(validator, svrl);
validator.Validate(dogs);
Console.WriteLine(svrl.ToString());
XmlDocument doggieReport = new XmlDocument();
doggieReport.LoadXml(svrl.ToString());
validator = new SchematronValidator(Schematron.Default.ValidationReportLanguage);
validator.Validate(doggieReport);
}
public void Assertions()
{
SchematronDocument schema = Load("Schematron/Samples/Let.sch");
SchematronValidator validator = new SchematronValidator(schema);
XmlDocument doc = new XmlDocument();
doc.LoadXml(
@"<times>
<time>23:10:50</time>
<time>11:10:50 PM</time>
<time>24:10:50</time>
<time>23:60:50</time>
<time>23:10:60</time>
</times>");
errors.Clear();
validator.Validate(doc, new SchematronValidationEventHandler(handler));
Assert.AreEqual(4, errors.Count);
Assert.AreEqual("The time element should contain a time in the format HH:MM:SS.", errors[0].Message);
Assert.AreEqual("The hour (24) be a value between 0 and 23.", errors[1].Message);
Assert.AreEqual("The minutes (60) must be a value between 0 and 59.", errors[2].Message);
Assert.AreEqual("The second (60) must be a value between 0 and 59.", errors[3].Message);
}
public void Validate_IsoDocument_OnText(string filename, bool result)
{
var res = SchematronValidator.Create(SchematronDocument.GenericCda).Validate(_fileResolver.GetResourceStream(filename).GetText());
Assert.Equal(result, res.Status);
}
