public void When_asserting_an_xml_node_is_the_same_as_the_same_xml_node_it_should_succeed() { //------------------------------------------------------------------------------------------------------------------- // Arrange //------------------------------------------------------------------------------------------------------------------- var doc = new XmlDocument(); //------------------------------------------------------------------------------------------------------------------- // Act //------------------------------------------------------------------------------------------------------------------- Action act = () => doc.Should().BeSameAs(doc); //------------------------------------------------------------------------------------------------------------------- // Assert //------------------------------------------------------------------------------------------------------------------- act.ShouldNotThrow(); }
public void When_asserting_an_xml_node_is_same_as_a_different_xml_node_it_should_fail_with_descriptive_message_and_truncate_xml() { //------------------------------------------------------------------------------------------------------------------- // Arrange //------------------------------------------------------------------------------------------------------------------- var doc = new XmlDocument(); doc.LoadXml("<doc>Some very long text that should be truncated.</doc>"); var otherNode = new XmlDocument(); otherNode.LoadXml("<otherDoc/>"); //------------------------------------------------------------------------------------------------------------------- // Act //------------------------------------------------------------------------------------------------------------------- Action act = () => doc.Should().BeSameAs(otherNode, "we want to test the failure {0}", "message"); //------------------------------------------------------------------------------------------------------------------- // Assert //------------------------------------------------------------------------------------------------------------------- act.ShouldThrow<AssertFailedException>() .WithMessage("Expected Xml Node to refer to <otherDoc /> because we want to test the failure message, but found <doc>Some very long...."); }
public void When_asserting_an_xml_node_is_equivalent_to_different_xml_node_with_different_insignificant_whitespace_it_should_succeed() { //------------------------------------------------------------------------------------------------------------------- // Arrange //------------------------------------------------------------------------------------------------------------------- var subject = new XmlDocument() { PreserveWhitespace = true }; subject.LoadXml("<xml><a><b/></a></xml>"); var expected = new XmlDocument() { PreserveWhitespace = true }; expected.LoadXml("<xml>\n<a> \n <b/></a>\r\n</xml>"); //------------------------------------------------------------------------------------------------------------------- // Act //------------------------------------------------------------------------------------------------------------------- Action act = () => subject.Should().BeEquivalentTo(expected); //------------------------------------------------------------------------------------------------------------------- // Assert //------------------------------------------------------------------------------------------------------------------- act.ShouldNotThrow(); }
public void When_asserting_an_xml_node_is_equivalent_to_different_xml_node_with_different_comments_it_should_succeed() { //------------------------------------------------------------------------------------------------------------------- // Arrange //------------------------------------------------------------------------------------------------------------------- var subject = new XmlDocument(); subject.LoadXml("<xml><!--Comment--><a/></xml>"); var expected = new XmlDocument(); expected.LoadXml("<xml><a/><!--Comment--></xml>"); //------------------------------------------------------------------------------------------------------------------- // Act //------------------------------------------------------------------------------------------------------------------- Action act = () => subject.Should().BeEquivalentTo(expected); //------------------------------------------------------------------------------------------------------------------- // Assert //------------------------------------------------------------------------------------------------------------------- act.ShouldNotThrow(); }
public void When_asserting_an_xml_node_is_equivalent_to_different_xml_node_which_has_different_text_contents_it_should_fail_with_descriptive_message() { //------------------------------------------------------------------------------------------------------------------- // Arrange //------------------------------------------------------------------------------------------------------------------- var subject = new XmlDocument(); subject.LoadXml("<xml>a</xml>"); var expected = new XmlDocument(); expected.LoadXml("<xml>b</xml>"); //------------------------------------------------------------------------------------------------------------------- // Act //------------------------------------------------------------------------------------------------------------------- Action act = () => subject.Should().BeEquivalentTo(expected, "we want to test the failure {0}", "message"); //------------------------------------------------------------------------------------------------------------------- // Assert //------------------------------------------------------------------------------------------------------------------- act.ShouldThrow<AssertFailedException>(). WithMessage("Expected content to be \"b\" at \"/xml\" because we want to test the failure message, but found \"a\"."); }
public void When_asserting_an_xml_node_is_equivalent_to_different_xml_node_which_has_attribute_with_different_namespace_it_should_fail_with_descriptive_message() { //------------------------------------------------------------------------------------------------------------------- // Arrange //------------------------------------------------------------------------------------------------------------------- var subject = new XmlDocument(); subject.LoadXml("<xml><element xmlns:ns=\"urn:a\" ns:a=\"b\"/></xml>"); var expected = new XmlDocument(); expected.LoadXml("<xml><element a=\"b\"/></xml>"); //------------------------------------------------------------------------------------------------------------------- // Act //------------------------------------------------------------------------------------------------------------------- Action act = () => subject.Should().BeEquivalentTo(expected, "we want to test the failure {0}", "message"); //------------------------------------------------------------------------------------------------------------------- // Assert //------------------------------------------------------------------------------------------------------------------- act.ShouldThrow<AssertFailedException>(). WithMessage("Didn't expect to find attribute \"ns:a\" at \"/xml/element\" because we want to test the failure message."); }
public void When_asserting_an_xml_node_is_equivalent_to_a_different_xml_node_which_differs_on_a_child_element_namespace_it_should_fail_with_descriptive_message() { //------------------------------------------------------------------------------------------------------------------- // Arrange //------------------------------------------------------------------------------------------------------------------- var subject = new XmlDocument(); subject.LoadXml("<a:xml xmlns:a=\"urn:a\"><a:child><a:data/></a:child></a:xml>"); var expected = new XmlDocument(); expected.LoadXml("<xml xmlns=\"urn:a\"><child><data xmlns=\"urn:b\"/></child></xml>"); //------------------------------------------------------------------------------------------------------------------- // Act //------------------------------------------------------------------------------------------------------------------- Action act = () => subject.Should().BeEquivalentTo(expected, "we want to test the failure {0}", "message"); //------------------------------------------------------------------------------------------------------------------- // Assert //------------------------------------------------------------------------------------------------------------------- act.ShouldThrow<AssertFailedException>(). WithMessage("Expected namespace of element \"data\" at \"/xml/child\" to be \"urn:b\" because we want to test the failure message, but found \"urn:a\"."); }
public void When_asserting_an_xml_node_is_null_but_it_is_not_it_should_fail_with_descriptive_message() { //------------------------------------------------------------------------------------------------------------------- // Arrange //------------------------------------------------------------------------------------------------------------------- var xmlDoc = new XmlDocument(); xmlDoc.LoadXml("<xml/>"); //------------------------------------------------------------------------------------------------------------------- // Act //------------------------------------------------------------------------------------------------------------------- Action act = () => xmlDoc.Should().BeNull("because we want to test the failure {0}", "message"); //------------------------------------------------------------------------------------------------------------------- // Assert //------------------------------------------------------------------------------------------------------------------- act.ShouldThrow<AssertFailedException>() .WithMessage("Expected XML Node to be <null> because we want to test the failure message," + " but found <xml />."); }
public void When_asserting_an_xml_node_is_equivalent_to_a_different_xml_node_which_differs_only_on_unused_namespace_declaration_it_should_succeed() { //------------------------------------------------------------------------------------------------------------------- // Arrange //------------------------------------------------------------------------------------------------------------------- var subject = new XmlDocument(); subject.LoadXml("<xml xmlns:a=\"urn:a\"/>"); var expected = new XmlDocument(); expected.LoadXml("<xml/>"); //------------------------------------------------------------------------------------------------------------------- // Act //------------------------------------------------------------------------------------------------------------------- Action act = () => subject.Should().BeEquivalentTo(expected); //------------------------------------------------------------------------------------------------------------------- // Assert //------------------------------------------------------------------------------------------------------------------- act.ShouldNotThrow(); }
public void When_asserting_an_xml_node_is_equivalent_to_a_different_xml_node_with_same_contents_it_should_succeed() { //------------------------------------------------------------------------------------------------------------------- // Arrange //------------------------------------------------------------------------------------------------------------------- var xml = "<root><a xmlns=\"urn:a\"><data>data</data></a><ns:b xmlns:ns=\"urn:b\"><data>data</data></ns:b></root>"; var subject = new XmlDocument(); subject.LoadXml(xml); var expected = new XmlDocument(); expected.LoadXml(xml); //------------------------------------------------------------------------------------------------------------------- // Act //------------------------------------------------------------------------------------------------------------------- Action act = () => subject.Should().BeEquivalentTo(expected); //------------------------------------------------------------------------------------------------------------------- // Assert //------------------------------------------------------------------------------------------------------------------- act.ShouldNotThrow(); }
public void When_asserting_an_xml_node_is_not_equivalent_to_same_xml_node_it_should_fail_with_descriptive_message() { //------------------------------------------------------------------------------------------------------------------- // Arrange //------------------------------------------------------------------------------------------------------------------- var subject = new XmlDocument(); subject.LoadXml("<xml>a</xml>"); //------------------------------------------------------------------------------------------------------------------- // Act //------------------------------------------------------------------------------------------------------------------- Action act = () => subject.Should().NotBeEquivalentTo(subject, "we want to test the failure {0}", "message"); //------------------------------------------------------------------------------------------------------------------- // Assert //------------------------------------------------------------------------------------------------------------------- act.ShouldThrow<AssertFailedException>(). WithMessage("Did not expect Xml to be equivalent because we want to test the failure message, but it is."); }
public void When_asserting_an_xml_node_is_not_equivalent_to_som_other_xml_node_it_should_succeed() { //------------------------------------------------------------------------------------------------------------------- // Arrange //------------------------------------------------------------------------------------------------------------------- var subject = new XmlDocument(); subject.LoadXml("<xml>a</xml>"); var unexpected = new XmlDocument(); unexpected.LoadXml("<xml>b</xml>"); //------------------------------------------------------------------------------------------------------------------- // Act //------------------------------------------------------------------------------------------------------------------- Action act = () => subject.Should().NotBeEquivalentTo(unexpected); //------------------------------------------------------------------------------------------------------------------- // Assert //------------------------------------------------------------------------------------------------------------------- act.ShouldNotThrow(); }
public void When_asserting_a_non_null_xml_node_is_not_null_it_should_succeed() { //------------------------------------------------------------------------------------------------------------------- // Arrange //------------------------------------------------------------------------------------------------------------------- var xmlDoc = new XmlDocument(); xmlDoc.LoadXml("<xml/>"); //------------------------------------------------------------------------------------------------------------------- // Act //------------------------------------------------------------------------------------------------------------------- Action act = () => xmlDoc.Should().NotBeNull(); //------------------------------------------------------------------------------------------------------------------- // Assert //------------------------------------------------------------------------------------------------------------------- act.ShouldNotThrow(); }
public void When_asserting_an_xml_node_is_equivalent_that_contains_an_unsupported_node_it_should_throw_a_descriptive_message() { //------------------------------------------------------------------------------------------------------------------- // Arrange //------------------------------------------------------------------------------------------------------------------- var subject = new XmlDocument(); subject.LoadXml("<xml><![CDATA[Text]]></xml>"); //------------------------------------------------------------------------------------------------------------------- // Act //------------------------------------------------------------------------------------------------------------------- Action act = () => subject.Should().BeEquivalentTo(subject); //------------------------------------------------------------------------------------------------------------------- // Assert //------------------------------------------------------------------------------------------------------------------- act.ShouldThrow<NotSupportedException>() .WithMessage("CDATA found at /xml is not supported for equivalency comparison."); }
public void When_asserting_an_xml_node_is_equivalent_to_a_different_XmlDcoument_which_differs_on_a_child_element_name_it_should_fail_with_descriptive_message() { //------------------------------------------------------------------------------------------------------------------- // Arrange //------------------------------------------------------------------------------------------------------------------- var subject = new XmlDocument(); subject.LoadXml("<xml><child><subject/></child></xml>"); var expected = new XmlDocument(); expected.LoadXml("<xml><child><expected/></child></xml>"); //------------------------------------------------------------------------------------------------------------------- // Act //------------------------------------------------------------------------------------------------------------------- Action act = () => subject.Should().BeEquivalentTo(expected, "we want to test the failure {0}", "message"); //------------------------------------------------------------------------------------------------------------------- // Assert //------------------------------------------------------------------------------------------------------------------- act.ShouldThrow<AssertFailedException>(). WithMessage("Expected local name of element at \"/xml/child\" to be \"expected\" because we want to test the failure message, but found \"subject\"."); }
public void When_asserting_an_xml_node_is_equivalent_that_isnt_it_should_include_the_right_location_in_the_descriptive_message() { //------------------------------------------------------------------------------------------------------------------- // Arrange //------------------------------------------------------------------------------------------------------------------- var subject = new XmlDocument(); subject.LoadXml("<xml><a/><b c=\"d\"/></xml>"); var expected = new XmlDocument(); expected.LoadXml("<xml><a/><b c=\"e\"/></xml>"); //------------------------------------------------------------------------------------------------------------------- // Act //------------------------------------------------------------------------------------------------------------------- Action act = () => subject.Should().BeEquivalentTo(expected); //------------------------------------------------------------------------------------------------------------------- // Assert //------------------------------------------------------------------------------------------------------------------- act.ShouldThrow<AssertFailedException>() .WithMessage("Expected attribute \"c\" at \"/xml/b\" to have value \"e\", but found \"d\"."); }
public void When_asserting_an_xml_node_is_null_but_it_is_not_it_should_fail() { //------------------------------------------------------------------------------------------------------------------- // Arrange //------------------------------------------------------------------------------------------------------------------- var xmlDoc = new XmlDocument(); xmlDoc.LoadXml("<xml/>"); //------------------------------------------------------------------------------------------------------------------- // Act //------------------------------------------------------------------------------------------------------------------- Action act = () => xmlDoc.Should().BeNull(); //------------------------------------------------------------------------------------------------------------------- // Assert //------------------------------------------------------------------------------------------------------------------- act.ShouldThrow<AssertFailedException>(); }