public void XmlCompareConstrainsSimpleSimilarTest()
{
var expected = XmlSamples.GetContent("elements");
var actual = XmlSamples.GetContent("elements-with-different-order");
Assert.That(expected, IsXml.Similar(actual));
}
public void WriteCollectionWithDifferentItemTypeTest()
{
var value = GetCollection(new List <Foo>
{
new Foo {
Id = 1, Name = "foo"
},
new FooBar {
Id = 2, Name = "foo-bar"
}
});
var actual = CreateConverter().ToXml(value.GetType(), value);
var expected = string.Format(
@"<xml>
<foo>
<id>1</id>
<name>foo</name>
</foo>
<foo xsi:type=""{0}"" xmlns:xsi=""http://www.w3.org/2001/XMLSchema-instance"">
<id>2</id>
<name>foo-bar</name>
</foo>
</xml>",
typeof(FooBar));
Assert.That(actual, IsXml.Equals(expected).WithIgnore(XmlComparisonType.NamespacePrefix));
}
public void Serialize_IsXml_NoDefaultAndSettings()
{
var isXml = new IsXml();
isXml.Value = "decimal(10,2)";
var testXml = new TestXml();
testXml.Constraints.Add(isXml);
var serializer = new XmlSerializer(typeof(TestXml));
var stream = new MemoryStream();
var writer = new StreamWriter(stream, Encoding.UTF8);
serializer.Serialize(writer, testXml);
var content = Encoding.UTF8.GetString(stream.ToArray());
writer.Close();
stream.Close();
Debug.WriteLine(content);
Assert.That(content, Is.StringContaining("<is"));
Assert.That(content, Is.StringContaining(">decimal(10,2)<"));
Assert.That(content, Is.Not.StringContaining("efault"));
Assert.That(content, Is.Not.StringContaining("eference"));
}
public void IsXml_Invoke_IsXml_ReturnsTrue()
{
const string xmlFragment = @"<InnerError>Index #0
Message: Login failed for user 'testuser2'.
LineNumber: 65536
Source: .Net SqlClient Data Provider
Procedure:
</InnerError><InnerError>ExecuteReader requires an open and available Connection. The connection's current state is closed.
at System.Data.SqlClient.SqlCommand.ValidateCommand(String method, Boolean async)
at System.Data.SqlClient.SqlCommand.RunExecuteReader(CommandBehavior cmdBehavior, RunBehavior runBehavior, Boolean returnStream, String method, TaskCompletionSource`1 completion, Int32 timeout, Task& task, Boolean asyncWrite)
at System.Data.SqlClient.SqlCommand.RunExecuteReader(CommandBehavior cmdBehavior, RunBehavior runBehavior, Boolean returnStream, String method)
at System.Data.SqlClient.SqlCommand.ExecuteReader(CommandBehavior behavior, String method)
at System.Data.SqlClient.SqlCommand.ExecuteReader(CommandBehavior behavior)
at Dev2.Services.Sql.SqlServer.ExecuteReader[T](SqlCommand command, CommandBehavior commandBehavior, Func`2 handler) in c:\Development\Dev\Dev2.Services.Sql\SqlServer.cs:line 121
at Dev2.Services.Sql.SqlServer.FetchDataTable(SqlParameter[] parameters) in c:\Development\Dev\Dev2.Services.Sql\SqlServer.cs:line 61
at Dev2.Services.Execution.DatabaseServiceExecution.SqlExecution(ErrorResultTO errors, Object& executeService) in c:\Development\Dev\Dev2.Services.Execution\DatabaseServiceExecution.cs:line 118</InnerError>";
//------------Setup for test--------------------------
var notStartsWith = new IsXml();
var cols = new string[2];
cols[0] = xmlFragment;
//------------Execute Test---------------------------
var result = notStartsWith.Invoke(cols);
Assert.IsTrue(result);
}
public void XmlCompareConstraintSimpleEqualsTest()
{
var expected = XmlSamples.GetContent("attr");
var actual = XmlSamples.GetContent("attr-with-another-order");
Assert.That(expected, IsXml.Equals(actual));
}
public void XmlCompareConstrainsXDocumentEqual()
{
var expected = XDocument.Parse(XmlSamples.GetContent("elements"));
var actual = XDocument.Parse(XmlSamples.GetContent("elements-with-comment"));
Assert.That(expected, IsXml.Equals(actual).WithIgnoreComment());
}
public void CompareNamespacesWithDifferentPrefixesIsSimilarTest()
{
var actual = XmlSamples.GetContent("ns");
var expected = XmlSamples.GetContent("ns-with-another-prefix");
Assert.That(expected, IsXml.Similar(actual));
}
public void WriteAttributeTest(BasicSample sample)
{
var expected = string.Format("<xml value=\"{0}\" />", sample.StringValue);
var actual = GetConverter().ToXml(sample.Value, member: GetAttributeMember());
Assert.That(actual, IsXml.Equals(expected));
}
public void WriteElementTest(BasicSample sample)
{
var expected = string.Format("<xml>{0}</xml>", sample.StringValue);
var actual = GetConverter().ToXml(sample.Value);
Assert.That(actual, IsXml.Equals(expected));
}
public void XmlCompareConstrainUseNUnitFormatter()
{
var actual = XmlSamples.GetContent("elements");
var expected = XmlSamples.GetContent("elements-with-comment");
Assert.That(expected, IsXml.Different(actual).WithIgnoreComment(false));
}
public void SerializeEnumerableTest()
{
var value = new List <Foo>
{
new Foo {
Id = 1
},
new Foo {
Id = 2
}
};
var actual = GetSerializer().ToXml <IEnumerable <Foo> >(value);
var expected = string.Format(@"
<ienumerable xmlns:xsi=""http://www.w3.org/2001/XMLSchema-instance"" xsi:type=""{0}"">
<foo>
<id>1</id>
</foo>
<foo>
<id>2</id>
</foo>
</ienumerable>", value.GetType().FullName);
Assert.That(actual, IsXml.Equals(expected).WithIgnoreDeclaration());
}
public void WriteNullableTest()
{
var converter = new XmlNullableConverter();
var actual = converter.ToXml <int?>(1);
var expected = "<xml>1</xml>";
Assert.That(actual, IsXml.Equals(expected));
}
public void WriteNullableAttributeTest()
{
var converter = new XmlOptionalConverter();
var actual = converter.ToXml <Optional <int?> >(1, member: GetAttributeMember <int?>());
var expected = "<xml value=\"1\" />";
Assert.That(actual, IsXml.Equals(expected));
}
public void WriteNullAttributeTest()
{
var serializer = new XmlSerializer();
var actual = serializer.ToXml(new TestClass2());
var expected = "<TestClass2 />";
Assert.That(actual, IsXml.Equals(expected).WithIgnoreDeclaration());
}
public void WriteNullTest()
{
var converter = new XmlOptionalConverter();
var actual = converter.ToXml <Optional <int?> >(null);
var expected = "<xml />";
Assert.That(actual, IsXml.Equals(expected));
}
protected NBiConstraint InstantiateConstraint(IsXml ctrXml, DataTypeXml sutXml)
{
var expected = ctrXml.Value;
var ctr = new IsConstraint(expected);
return(ctr);
}
public void XmlCompareConstrainsEqualsWithDifferentOrder()
{
var expected = XmlSamples.GetContent("elements");
var actual = XmlSamples.GetContent("elements-with-different-order");
Assert.That(
expected,
IsXml.Equals(actual).UseAnalizer(XmlAnalyzer.Custom().SetEqual(XmlComparisonType.NodeListSequence)));
}
public void XmlValidationConstraintSchemaWithNamespaceTest()
{
var document = XmlSamples.GetContent("ns");
var emptyNamespaceSchemaPath = XmlSamples.GetFullPathByName(@"Xsd/ns.xsd");
var namespaceSchemaPath = XmlSamples.GetFullPathByName(@"Xsd/ns_app1.xsd");
string nameSpace = @"http://example.org";
Assert.That(document, IsXml.Valid().WithSchema(emptyNamespaceSchemaPath).WithSchema(nameSpace, namespaceSchemaPath));
}
public void XmlValidationConstraintTextReaderSchema()
{
var document = XmlSamples.GetContent("ns-without-namespace");
var namespaceSchemaPath = XmlSamples.GetFullPathByName(@"Xsd/ns-without-namespace.xsd");
Assert.That(
document,
IsXml.Valid().WithSchema(namespaceSchemaPath));
}
public void WriteInt32CollectionTest()
{
var value = GetCollection(new List <int> {
1, 2, 3
});
var actual = CreateConverter().ToXml(value.GetType(), value);
var expected = "<xml><int>1</int><int>2</int><int>3</int></xml>";
Assert.That(actual, IsXml.Equals(expected));
}
public void XmlCompareConstrainWithXsdReference()
{
var actual = XmlSamples.GetContent("with-xsd-reference");
var expected = XmlSamples.GetContent("with-xsd-another-reference");
Assert.That(
expected,
IsXml.Equals(actual)
.UseAnalizer(XmlAnalyzer.Custom().SetEqual(XmlComparisonType.SchemaLocation)));
}
public void IsHandling_DataTypeIs_True()
{
var sutXml = new DataTypeXml();
var ctrXml = new IsXml();
var testCaseFactory = new TestCaseFactory();
var actual = testCaseFactory.IsHandling(sutXml.GetType(), ctrXml.GetType());
Assert.That(actual, Is.True);
}
public void IsXml_HandlesType_ReturnsIsXmlType()
{
var decisionType = enDecisionType.IsXML;
//------------Setup for test--------------------------
var isXml = new IsXml();
//------------Execute Test---------------------------
//------------Assert Results-------------------------
Assert.AreEqual(decisionType, isXml.HandlesType());
}
public void WriteNullWithNullIncludeHandlingTest()
{
var serializer = new XmlSerializer();
serializer.Settings.OmitXmlDeclaration = true;
serializer.Settings.NullValueHandling = XmlNullValueHandling.Include;
var actual = serializer.ToXml(new TestClass());
var expected = @"<TestClass xmlns:xsi=""http://www.w3.org/2001/XMLSchema-instance""><Value xsi:nil=""true"" /></TestClass>";
Assert.That(actual, IsXml.Equals(expected));
}
public void SerializeNullTest()
{
var serializer = GetSerializer();
serializer.Settings.NullValueHandling = XmlNullValueHandling.Include;
var actual = serializer.ToXml <Foo>(null);
var expected = @"<?xml version=""1.0"" encoding=""utf-16""?>
<foo xsi:nil=""true"" xmlns:xsi=""http://www.w3.org/2001/XMLSchema-instance"" />";
Assert.That(actual, IsXml.Equals(expected));
}
public void XmlCompareConstrainCustomAnalyzerIgnoreNodeMissing()
{
var expected = XmlSamples.GetContent("elements");
var actual = XmlSamples.GetContent("elements-with-comment");
Assert.That(
expected,
IsXml.Equals(actual)
.WithIgnoreComment(false)
.UseAnalizer(XmlAnalyzer.Custom()
.SetEqual(XmlComparisonType.NodeList)
.SetEqual(XmlComparisonType.NodeListLookup)));
}
public void WriteFooTest()
{
var value = new Foo
{
Id = 1,
Name = "test"
};
var actual = GetConverter().ToXml(value);
var expected = "<xml><id>1</id><name>test</name></xml>";
Assert.That(actual, IsXml.Equals(expected));
}
public void GivenSomeString_IsXml_Invoke_ReturnsFalse()
{
//------------Setup for test--------------------------
var isXml = new IsXml();
var cols = new string[2];
cols[0] = "Eight";
//------------Execute Test---------------------------
var result = isXml.Invoke(cols);
//------------Assert Results-------------------------
Assert.IsFalse(result);
}
public void WriteFooWithIgnoreNullHandlingTest()
{
var value = new Foo
{
Id = 1,
Name = null
};
var contract = GetContractWithIgnoreNull();
var actual = GetConverter().ToXml(value, contract: contract);
var expected = "<xml><id>1</id></xml>";
Assert.That(actual, IsXml.Equals(expected));
}
public void WriteFooWithIncludeNullHandlingTest()
{
var value = new Foo
{
Id = 1,
Name = null
};
var contract = GetContractWithIncludeNull();
var actual = GetConverter().ToXml(value, contract: contract);
var expected = @"<xml><id>1</id><name xsi:nil=""true"" xmlns:xsi=""http://www.w3.org/2001/XMLSchema-instance"" /></xml>";
Assert.That(actual, IsXml.Equals(expected).WithIgnore(XmlComparisonType.NamespacePrefix));
}
