Merge pull request #49 from xmlunit/xsi-type-and-placeholders

improve placehiolder usage with xsi:type attributes

Author: bodewig

RELEASE_NOTES.md

@@ -2,6 +2,13 @@
 
 ## XMLUnit.NET 2.11.1 - /Not Released, yet/
 
+* placeholders can now also be used inside of the local part of `xsi:type` attributes.
+  PR [#49](https://github.com/xmlunit/xmlunit.net/pull/49)
+
+* PlaceholderDifferenceEvaluator would cause InvalidCastException for documents with
+  differences in `xsi:type` attributes.
+  Equivalent of XMLUnit Java Issue [#xmlunit/276](https://github.com/xmlunit/xmlunit/issues/276)
+
 * added readme files for the nuget packages.
   Issue [#46](https://github.com/xmlunit/xmlunit.net/issues/46).
 

src/doc/monodoc/placeholders/ns-Org.XmlUnit.Placeholder.xml

@@ -73,6 +73,15 @@
       <c>org.xmlunit.diff.DifferenceEvaluator</c> and add it to the
       builder yourself.</para>
 
+      <para>Placeholder sequences must appear as values inside of
+      attribute values or nested textual content of elements - inside
+      the control document. As a special case they may also appear as
+      local part of a type name of xsi:type attributes of control
+      documents - i.e. <c>xsi:type="prefix:${xmlunit:ignore}"</c>. The
+      namepace URIs of the compared types must match with the test
+      document. Support for xsi:types has been added with XMLUnit.NET
+      2.11.1.</para>
+
     </remarks>
 
 

src/main/net-placeholders/PlaceholderDifferenceEvaluator.cs

@@ -238,10 +238,22 @@ public ComparisonResult Evaluate(Comparison comparison, ComparisonResult outcome
                 return EvaluateConsideringPlaceholders(controlTarget.Value, testTarget.Value, outcome);
 
             // comparing textual content of attributes
-            } else if (comparison.Type == ComparisonType.ATTR_VALUE) {
+            }
+            else if (comparison.Type == ComparisonType.ATTR_VALUE && controlDetails.Value is string &&
+                     testDetails.Value is string)
+            {
                 return EvaluateConsideringPlaceholders((string) controlDetails.Value,
                     (string) testDetails.Value, outcome);
 
+            }
+
+            // comparing QName content of attributes
+            else if (comparison.Type == ComparisonType.ATTR_VALUE && controlDetails.Value is XmlQualifiedName &&
+                     testDetails.Value is XmlQualifiedName)
+            {
+                return EvaluateConsideringPlaceholders((XmlQualifiedName) controlDetails.Value,
+                    (XmlQualifiedName) testDetails.Value, outcome);
+
             // "test document has no attribute but control document has"
             } else if (IsMissingAttributeDifference(comparison)) {
                 return EvaluateMissingAttributeConsideringPlaceholders(comparison, outcome);
@@ -335,6 +347,19 @@ private ComparisonResult EvaluateAttributeListLengthConsideringPlaceholders(Comp
             return ComparisonResult.EQUAL;
         }
 
+        private ComparisonResult EvaluateConsideringPlaceholders(XmlQualifiedName controlQName,
+            XmlQualifiedName testQName,
+            ComparisonResult outcome)
+        {
+            if (controlQName.Namespace == testQName.Namespace)
+            {
+                return EvaluateConsideringPlaceholders(controlQName.Name, testQName.Name,
+                    outcome);
+            }
+
+            return outcome;
+        }
+
         private ComparisonResult EvaluateConsideringPlaceholders(string controlText, string testText,
             ComparisonResult outcome) {
             Match placeholderMatch = placeholderRegex.Match(controlText);

src/tests/net-placeholders/PlaceholderDifferenceEvaluatorTest.cs

@@ -446,5 +446,83 @@ public void IsDateTimePlaceholder_Element_IsDateTime_CustomFormat() {
 
             Assert.IsFalse(diff.HasDifferences());
         }
+
+        [Test]
+        public void CanCompareDocmentsWithXsiTypes() {
+            string control = "<element"
+                + " xmlns:myns=\"https://example.org/some-ns\""
+                + " xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\""
+                + " xsi:type=\"myns:some-type\" />";
+            string test = "<element"
+                + " xmlns:myns=\"https://example.org/some-ns\""
+                + " xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\""
+                + " xsi:type=\"myns:some-other-type\" />";
+
+            var diff = DiffBuilder.Compare(control).WithTest(test)
+                .WithDifferenceEvaluator(new PlaceholderDifferenceEvaluator().Evaluate).Build();
+
+            Assert.IsTrue(diff.HasDifferences());
+            int count = 0;
+            foreach (Difference difference in diff.Differences) {
+                count++;
+                Assert.AreEqual(ComparisonResult.DIFFERENT, difference.Result);
+                Assert.AreEqual(ComparisonType.ATTR_VALUE, difference.Comparison.Type);
+            }
+            Assert.AreEqual(1, count);
+        }
+
+        [Test]
+        public void CanIgnoreXsiTypeDifference()
+        {
+            string control = "<element"
+                             + " xmlns:myns=\"https://example.org/some-ns\""
+                             + " xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\""
+                             + " xsi:type=\"myns:${xmlunit.ignore}\" />";
+            string test = "<element"
+                          + " xmlns:myns=\"https://example.org/some-ns\""
+                          + " xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\""
+                          + " xsi:type=\"myns:some-other-type\" />";
+
+            var diff = DiffBuilder.Compare(control).WithTest(test)
+                .WithDifferenceEvaluator(new PlaceholderDifferenceEvaluator().Evaluate).Build();
+
+            Assert.IsFalse(diff.HasDifferences());
+        }
+
+        [Test]
+        public void CantIgnoreXsiNamespaceDifference()
+        {
+            string control = "<element"
+                             + " xmlns:myns=\"https://example.org/some-other-ns\""
+                             + " xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\""
+                             + " xsi:type=\"myns:${xmlunit.ignore}\" />";
+            string test = "<element"
+                          + " xmlns:myns=\"https://example.org/some-ns\""
+                          + " xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\""
+                          + " xsi:type=\"myns:some-other-type\" />";
+
+            var diff = DiffBuilder.Compare(control).WithTest(test)
+                .WithDifferenceEvaluator(new PlaceholderDifferenceEvaluator().Evaluate).Build();
+
+            Assert.IsTrue(diff.HasDifferences());
+        }
+
+        [Test]
+        public void CanCompareXsiTypeWithhRegex()
+        {
+            string control = "<element"
+                             + " xmlns:myns=\"https://example.org/some-ns\""
+                             + " xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\""
+                             + " xsi:type=\"myns:${xmlunit.matchesRegex(.*-type)}\" />";
+            string test = "<element"
+                          + " xmlns:myns=\"https://example.org/some-ns\""
+                          + " xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\""
+                          + " xsi:type=\"myns:some-other-type\" />";
+
+            var diff = DiffBuilder.Compare(control).WithTest(test)
+                .WithDifferenceEvaluator(new PlaceholderDifferenceEvaluator().Evaluate).Build();
+
+            Assert.IsFalse(diff.HasDifferences());
+        }
     }
 }