public bool ExecuteSchemaTestJson <TSchema>(Assembly assembly, string sampleResource, string rootNodeName,
string targetSchemaNamespace, out XmlDocument generatedDoc, string namespacePrefix = "ns0",
TestContext testContext = null) where TSchema : TestableSchemaBase, new()
{
TestableSchemaBase schemaToTest;
generatedDoc = null;
if (string.IsNullOrWhiteSpace(sampleResource))
{
return(false);
}
schemaToTest = new TSchema();
generatedDoc =
JsonParser.ConvertJsonToXmlDocument(
ResourceHelper.LoadAsString(assembly, sampleResource),
rootNodeName, targetSchemaNamespace, namespacePrefix);
var validationResult = new XmlValidationResult(new TSchema(), generatedDoc);
if (testContext != null)
{
testContext.WriteLine(
validationResult.IsValid
? "Test successful for {0} good sample message. {1}"
: "Test failed for {0} good sample message. {1}",
schemaToTest.ToString(),
validationResult.Message);
}
return(validationResult.IsValid);
}
/// <summary>
/// ExecuteMapTest
/// </summary>
/// <typeparam name="Map"></typeparam>
/// <param name="inputMessage"></param>
/// <param name="expectedResultReference"></param>
/// <param name="targetSchema"></param>
/// <param name="validateXmlOutput"></param>
/// <param name="extObjects"></param>
/// <param name="testContext"></param>
/// <returns></returns>
public string ExecuteMapTest <Map>(Assembly assembly, string inputMessage, string expectedResultReference, TestableSchemaBase targetSchema = null, bool validateXmlOutput = true, string extObjects = null, TestContext testContext = null, object[] expectedResultArguments = null, string[] ignoredLines = null)
where Map : TestableMapBase, new()
{
var mapTestHelper = new MapTestHelper();
TestableMapBase map = new Map();
// Execute the map and load the output.
string result = mapTestHelper.ExecuteMap(map, inputMessage, extObjects);
XmlDocument output = new XmlDocument();
output.LoadXml(result);
if (testContext != null)
{
testContext.WriteLine("{0}", output.OuterXml);
}
if (validateXmlOutput)
{
// Perform XML Schema validation on the output.
XmlValidationResult xmlValidationResult = new XmlValidationResult(targetSchema, output);
Assert.IsTrue(xmlValidationResult.IsValid, map.ToString() + " test failed. The output file was not valid. " + xmlValidationResult.Message);
}
Assert.IsFalse(mapTestHelper.IsXmlDifferent(assembly, output, expectedResultReference, arguments: expectedResultArguments, ignoredLines: ignoredLines), "Differences exist.");
return(result);
}
/// <summary>
/// ExecuteSchemaTestXml
/// </summary>
/// <typeparam name="TSchema"></typeparam>
/// <param name="assembly"></param>
/// <param name="sampleResource"></param>
/// <param name="generatedDoc"></param>
/// <param name="targetSchemaNamespace"></param>
/// <param name="testContext"></param>
/// <param name="arguments"></param>
/// <returns></returns>
public bool ExecuteSchemaTestXml <TSchema>(Assembly assembly, string sampleResource, out XmlDocument generatedDoc, string targetSchemaNamespace = null,
TestContext testContext = null, params object[] arguments) where TSchema : TestableSchemaBase, new()
{
TestableSchemaBase schemaToTest;
XmlTemplate xmlTemplate;
generatedDoc = new XmlDocument();
if (string.IsNullOrWhiteSpace(sampleResource))
{
return(false);
}
schemaToTest = new TSchema();
if (string.IsNullOrWhiteSpace(targetSchemaNamespace))
{
targetSchemaNamespace = schemaToTest.Schema.TargetNamespace;
}
xmlTemplate = new XmlTemplate(typeof(TSchema), targetSchemaNamespace);
xmlTemplate.LoadFromResource(assembly, sampleResource);
if (arguments == null)
{
xmlTemplate.Execute();
}
else
{
xmlTemplate.Execute(arguments);
}
var tempFile = new TempFile(xmlTemplate);
var xmlValidationResult = new XmlValidationResult(schemaToTest,
tempFile.FilePath);
if (testContext != null)
{
testContext.WriteLine(
xmlValidationResult.IsValid
? "Test successful for {0} good sample message. {1}"
: "Test failed for {0} good sample message. {1}",
schemaToTest.ToString(),
xmlValidationResult.Message);
}
generatedDoc.Load(tempFile.FilePath);
return(xmlValidationResult.IsValid);
}
/// <summary>
/// TestDisassembleXml
/// </summary>
/// <typeparam name="TSchema"></typeparam>
public bool TestDisassembleXml <TSchema>(Assembly assembly, string flatFile, out XmlDocument xmlDoc,
TestContext testContext = null, Action <XmlDocument> validationAction = null) where TSchema : TestableSchemaBase, new()
{
TestableSchemaBase schemaToTest;
FlatFileDasm flatFileDasm;
string message;
TempFile disassembledFile;
xmlDoc = null;
if (string.IsNullOrWhiteSpace(flatFile))
{
return(false);
}
schemaToTest = new TSchema();
flatFileDasm = new FlatFileDasm(schemaToTest);
message = ResourceHelper.LoadAsString(assembly, flatFile);
disassembledFile = flatFileDasm.Disassemble(message);
xmlDoc = new XmlDocument();
xmlDoc.Load(disassembledFile.FilePath);
if (testContext != null)
{
testContext.WriteLine("{0}", xmlDoc.OuterXml);
}
//schema validation
XmlValidationResult validationResult = new XmlValidationResult(schemaToTest, disassembledFile.FilePath);
if (testContext != null)
{
testContext.WriteLine(
validationResult.IsValid
? "Disassembly Test successful for {0} sample message. {1}"
: "Disassembly Test failed for {0} sample message. {1}",
schemaToTest.ToString(),
validationResult.Message);
}
if (validationResult.IsValid && (validationAction != null))
{
validationAction(xmlDoc);
}
return(validationResult.IsValid);
}
