Merge branch 'master' of https://github.com/eugenp/tutorials

rest-assured-tutorial/src/test/java/com/baeldung/restassured/RestAssuredTest.java

@@ -45,7 +45,7 @@ public class RestAssuredTest {
 	}
 
 	@Test
-	public void givenUrl_whenSuccessOnGetsResponse_andJsonHasRequiredKV_thenCorrect() {
+	public void givenUrl_whenSuccessOnGetsResponseAndJsonHasRequiredKV_thenCorrect() {
 
 		get("/events?id=390").then().statusCode(200).assertThat()
 				.body("id", equalTo("390"));

xmlunit2-tutorial/pom.xml

@@ -0,0 +1,46 @@
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
+	<modelVersion>4.0.0</modelVersion>
+	<groupId>com.baeldung</groupId>
+	<artifactId>xmlunit2-tutorial</artifactId>
+	<version>1.0</version>
+	<name>XMLUnit-2</name>
+   <build>
+    <plugins>
+      <plugin>
+        <groupId>org.apache.maven.plugins</groupId>
+        <artifactId>maven-compiler-plugin</artifactId>
+        <version>3.3</version>
+        <configuration>
+          <source>7</source>
+          <target>7</target>
+        </configuration>
+      </plugin>
+    </plugins>
+  </build>
+	<dependencies>
+		<dependency>
+			<groupId>junit</groupId>
+			<artifactId>junit</artifactId>
+			<version>4.3</version>
+			<scope>test</scope>
+		</dependency>
+		<dependency>
+			<groupId>org.hamcrest</groupId>
+			<artifactId>hamcrest-all</artifactId>
+			<version>1.3</version>
+		</dependency>
+<dependency>
+    <groupId>org.xmlunit</groupId>
+    <artifactId>xmlunit-matchers</artifactId>
+    <version>2.2.1</version>
+</dependency>
+
+<dependency>
+    <groupId>org.xmlunit</groupId>
+    <artifactId>xmlunit-core</artifactId>
+    <version>2.2.1</version>
+</dependency>
+
+	</dependencies>
+</project>

xmlunit2-tutorial/src/main/java/com/baeldung/xmlunit/IgnoreAttributeDifferenceEvaluator.java

@@ -0,0 +1,31 @@
+package com.baeldung.xmlunit;
+
+import org.w3c.dom.Attr;
+import org.w3c.dom.Node;
+import org.xmlunit.diff.Comparison;
+import org.xmlunit.diff.ComparisonResult;
+import org.xmlunit.diff.DifferenceEvaluator;
+
+public class IgnoreAttributeDifferenceEvaluator implements DifferenceEvaluator {
+
+	private String attributeName;
+
+	public IgnoreAttributeDifferenceEvaluator(String attributeName) {
+		this.attributeName = attributeName;
+	}
+
+	@Override
+	public ComparisonResult evaluate(Comparison comparison,
+			ComparisonResult outcome) {
+		if (outcome == ComparisonResult.EQUAL)
+			return outcome;
+		final Node controlNode = comparison.getControlDetails().getTarget();
+		if (controlNode instanceof Attr) {
+			Attr attr = (Attr) controlNode;
+			if (attr.getName().equals(attributeName)) {
+				return ComparisonResult.SIMILAR;
+			}
+		}
+		return outcome;
+	}
+}

xmlunit2-tutorial/src/test/java/com/baeldung/xmlunit/XMLUnitTest.java

@@ -0,0 +1,290 @@
+package com.baeldung.xmlunit;
+
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.equalTo;
+import static org.hamcrest.Matchers.greaterThan;
+import static org.hamcrest.core.IsNot.not;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertTrue;
+import static org.xmlunit.matchers.CompareMatcher.isIdenticalTo;
+import static org.xmlunit.matchers.CompareMatcher.isSimilarTo;
+import static org.xmlunit.matchers.HasXPathMatcher.hasXPath;
+
+import java.io.File;
+import java.util.Iterator;
+
+import org.junit.Test;
+import org.w3c.dom.NamedNodeMap;
+import org.w3c.dom.Node;
+import org.xmlunit.builder.DiffBuilder;
+import org.xmlunit.builder.Input;
+import org.xmlunit.diff.ComparisonControllers;
+import org.xmlunit.diff.DefaultNodeMatcher;
+import org.xmlunit.diff.Diff;
+import org.xmlunit.diff.Difference;
+import org.xmlunit.diff.ElementSelectors;
+import org.xmlunit.validation.Languages;
+import org.xmlunit.validation.ValidationProblem;
+import org.xmlunit.validation.ValidationResult;
+import org.xmlunit.validation.Validator;
+import org.xmlunit.xpath.JAXPXPathEngine;
+
+public class XMLUnitTest {
+	@Test
+	public void givenWrongXml_whenValidateFailsAgainstXsd_thenCorrect() {
+		Validator v = Validator.forLanguage(Languages.W3C_XML_SCHEMA_NS_URI);
+		v.setSchemaSource(Input.fromStream(
+				new XMLUnitTest().getClass().getResourceAsStream(
+						"/students.xsd")).build());
+		ValidationResult r = v.validateInstance(Input.fromStream(
+				new XMLUnitTest().getClass().getResourceAsStream(
+						"/students_with_error.xml")).build());
+		assertFalse(r.isValid());
+	}
+
+	@Test
+	public void givenXmlWithErrors_whenReturnsValidationProblems_thenCorrect() {
+		Validator v = Validator.forLanguage(Languages.W3C_XML_SCHEMA_NS_URI);
+		v.setSchemaSource(Input.fromStream(
+				new XMLUnitTest().getClass().getResourceAsStream(
+						"/students.xsd")).build());
+		ValidationResult r = v.validateInstance(Input.fromStream(
+				new XMLUnitTest().getClass().getResourceAsStream(
+						"/students_with_error.xml")).build());
+		Iterator<ValidationProblem> probs = r.getProblems().iterator();
+		int count = 0;
+		while (probs.hasNext()) {
+			count++;
+			probs.next().toString();
+		}
+		assertTrue(count > 0);
+	}
+
+	@Test
+	public void givenXml_whenValidatesAgainstXsd_thenCorrect() {
+		Validator v = Validator.forLanguage(Languages.W3C_XML_SCHEMA_NS_URI);
+		v.setSchemaSource(Input.fromStream(
+				new XMLUnitTest().getClass().getResourceAsStream(
+						"/students.xsd")).build());
+		ValidationResult r = v.validateInstance(Input.fromStream(
+				new XMLUnitTest().getClass().getResourceAsStream(
+						"/students.xml")).build());
+		Iterator<ValidationProblem> probs = r.getProblems().iterator();
+		while (probs.hasNext()) {
+			System.out.println(probs.next().toString());
+		}
+		assertTrue(r.isValid());
+	}
+
+	@Test
+	public void givenXPath_whenAbleToRetrieveNodes_thenCorrect() {
+		ClassLoader classLoader = getClass().getClassLoader();
+
+		Iterable<Node> i = new JAXPXPathEngine().selectNodes(
+				"//teacher",
+				Input.fromFile(
+						new File(classLoader.getResource("teachers.xml")
+								.getFile())).build());
+		assertNotNull(i);
+		int count = 0;
+		for (Iterator<Node> it = i.iterator(); it.hasNext();) {
+			count++;
+			Node node = it.next();
+			assertEquals("teacher", node.getNodeName());
+			NamedNodeMap map = node.getAttributes();
+			assertEquals("department", map.item(0).getNodeName());
+			assertEquals("id", map.item(1).getNodeName());
+			assertEquals("teacher", node.getNodeName());
+		}
+		assertEquals(2, count);
+	}
+
+	@Test
+	public void givenXmlSource_whenAbleToValidateExistingXPath_thenCorrect() {
+		ClassLoader classLoader = getClass().getClassLoader();
+		assertThat(Input.fromFile(new File(classLoader.getResource(
+				"teachers.xml").getFile())), hasXPath("//teachers"));
+		assertThat(Input.fromFile(new File(classLoader.getResource(
+				"teachers.xml").getFile())), hasXPath("//teacher"));
+		assertThat(Input.fromFile(new File(classLoader.getResource(
+				"teachers.xml").getFile())), hasXPath("//subject"));
+		assertThat(Input.fromFile(new File(classLoader.getResource(
+				"teachers.xml").getFile())), hasXPath("//@department"));
+	}
+
+	@Test
+	public void givenXmlSource_whenFailsToValidateInExistentXPath_thenCorrect() {
+		ClassLoader classLoader = getClass().getClassLoader();
+
+		assertThat(Input.fromFile(new File(classLoader.getResource(
+				"teachers.xml").getFile())), not(hasXPath("//sujet")));
+	}
+
+	@Test
+	public void given2XMLs_whenSimilarWithDiff_thenCorrect() throws Exception {
+		String myControlXML = "<struct><int>3</int><boolean>false</boolean></struct>";
+		String myTestXML = "<struct><boolean>false</boolean><int>3</int></struct>";
+
+		Diff myDiffSimilar = DiffBuilder
+				.compare(myControlXML)
+				.withTest(myTestXML)
+				.withNodeMatcher(
+						new DefaultNodeMatcher(ElementSelectors.byName))
+				.checkForSimilar().build();
+		assertFalse("XML similar " + myDiffSimilar.toString(),
+				myDiffSimilar.hasDifferences());
+
+	}
+
+	@Test
+	public void given2XMLsWithDifferences_whenTestsSimilarWithDifferenceEvaluator_thenCorrect() {
+		final String control = "<a><b attr=\"abc\"></b></a>";
+		final String test = "<a><b attr=\"xyz\"></b></a>";
+		Diff myDiff = DiffBuilder
+				.compare(control)
+				.withTest(test)
+				.withDifferenceEvaluator(
+						new IgnoreAttributeDifferenceEvaluator("attr"))
+				.checkForSimilar().build();
+
+		assertFalse(myDiff.toString(), myDiff.hasDifferences());
+	}
+
+	@Test
+	public void given2XMLsWithDifferences_whenTestsDifferentWithoutDifferenceEvaluator_thenCorrect() {
+		final String control = "<a><b attr=\"abc\"></b></a>";
+		final String test = "<a><b attr=\"xyz\"></b></a>";
+
+		Diff myDiff = DiffBuilder.compare(control).withTest(test)
+				.checkForSimilar().build();
+
+		assertTrue(myDiff.toString(), myDiff.hasDifferences());
+	}
+
+	@Test
+	public void given2XMLS_whenSimilarWithCustomElementSelector_thenCorrect() {
+		String controlXml = "<struct><int>3</int><boolean>false</boolean></struct>";
+		String testXml = "<struct><boolean>false</boolean><int>3</int></struct>";
+		assertThat(
+				testXml,
+				isSimilarTo(controlXml).withNodeMatcher(
+						new DefaultNodeMatcher(ElementSelectors.byName)));
+
+	}
+
+	@Test
+	public void givenFileSourceAsObject_whenAbleToInput_thenCorrect() {
+		ClassLoader classLoader = getClass().getClassLoader();
+		assertThat(Input.from(new File(classLoader.getResource("test.xml")
+				.getFile())), isSimilarTo(Input.from(new File(classLoader
+				.getResource("control.xml").getFile()))));
+
+	}
+
+	@Test
+	public void givenStreamAsSource_whenAbleToInput_thenCorrect() {
+		assertThat(Input.fromStream(new XMLUnitTest().getClass()
+				.getResourceAsStream("/test.xml")),
+				isSimilarTo(Input.fromStream(new XMLUnitTest().getClass()
+						.getResourceAsStream("/control.xml"))));
+
+	}
+
+	@Test
+	public void givenStreamAsObject_whenAbleToInput_thenCorrect() {
+		assertThat(Input.from(new XMLUnitTest().getClass().getResourceAsStream(
+				"/test.xml")), isSimilarTo(Input.from(new XMLUnitTest()
+				.getClass().getResourceAsStream("/control.xml"))));
+
+	}
+
+	@Test
+	public void givenStringSourceAsObject_whenAbleToInput_thenCorrect() {
+		assertThat(
+				Input.from("<struct><int>3</int><boolean>false</boolean></struct>"),
+				isSimilarTo(Input
+						.from("<struct><int>3</int><boolean>false</boolean></struct>")));
+
+	}
+
+	@Test
+	public void givenFileSource_whenAbleToInput_thenCorrect() {
+		ClassLoader classLoader = getClass().getClassLoader();
+		String testPath = classLoader.getResource("test.xml").getPath();
+		String controlPath = classLoader.getResource("control.xml").getPath();
+		assertThat(Input.fromFile(testPath),
+				isSimilarTo(Input.fromFile(controlPath)));
+
+	}
+
+	@Test
+	public void givenStringSource_whenAbleToInput_thenCorrect() {
+		String controlXml = "<struct><int>3</int><boolean>false</boolean></struct>";
+		String testXml = "<struct><int>3</int><boolean>false</boolean></struct>";
+		assertThat(Input.fromString(testXml),
+				isSimilarTo(Input.fromString(controlXml)));
+
+	}
+
+	@Test
+	public void givenSource_whenAbleToInput_thenCorrect() {
+		String controlXml = "<struct><int>3</int><boolean>false</boolean></struct>";
+		String testXml = "<struct><int>3</int><boolean>false</boolean></struct>";
+		assertThat(Input.fromString(testXml),
+				isSimilarTo(Input.fromString(controlXml)));
+
+	}
+
+	@Test
+	public void given2XMLS_whenIdentical_thenCorrect() {
+		String controlXml = "<struct><int>3</int><boolean>false</boolean></struct>";
+		String testXml = "<struct><int>3</int><boolean>false</boolean></struct>";
+		assertThat(testXml, isIdenticalTo(controlXml));
+
+	}
+
+	@Test
+	public void given2XMLSWithSimilarNodesButDifferentSequence_whenNotIdentical_thenCorrect() {
+		String controlXml = "<struct><int>3</int><boolean>false</boolean></struct>";
+		String testXml = "<struct><boolean>false</boolean><int>3</int></struct>";
+		assertThat(testXml, not(isIdenticalTo(controlXml)));
+
+	}
+
+	@Test
+	public void given2XMLS_whenGeneratesDifferences_thenCorrect()
+			throws Exception {
+		String controlXml = "<struct><int>3</int><boolean>false</boolean></struct>";
+		String testXml = "<struct><boolean>false</boolean><int>3</int></struct>";
+		Diff myDiff = DiffBuilder.compare(controlXml).withTest(testXml).build();
+		Iterator<Difference> iter = myDiff.getDifferences().iterator();
+		int size = 0;
+		while (iter.hasNext()) {
+			iter.next().toString();
+			size++;
+		}
+		assertThat(size, greaterThan(1));
+	}
+
+	@Test
+	public void given2XMLS_whenGeneratesOneDifference_thenCorrect()
+			throws Exception {
+		String myControlXML = "<struct><int>3</int><boolean>false</boolean></struct>";
+		String myTestXML = "<struct><boolean>false</boolean><int>3</int></struct>";
+		Diff myDiff = DiffBuilder
+				.compare(myControlXML)
+				.withTest(myTestXML)
+				.withComparisonController(
+						ComparisonControllers.StopWhenDifferent).build();
+		Iterator<Difference> iter = myDiff.getDifferences().iterator();
+		int size = 0;
+		while (iter.hasNext()) {
+			iter.next().toString();
+			size++;
+		}
+		assertThat(size, equalTo(1));
+	}
+
+}

xmlunit2-tutorial/src/test/resources/control.xml

@@ -0,0 +1,4 @@
+<struct>
+	<int>3</int>
+	<boolean>false</boolean>
+</struct>

xmlunit2-tutorial/src/test/resources/students.xml

@@ -0,0 +1,11 @@
+<?xml version = "1.0"?>
+<class>
+	<student id="393">
+		<name>Rajiv</name>
+		<age>18</age>
+	</student>
+	<student id="493">
+		<name>Candie</name>
+		<age>19</age>
+	</student>
+</class>

xmlunit2-tutorial/src/test/resources/students.xsd

@@ -0,0 +1,18 @@
+<?xml version = "1.0"?>
+<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
+	<xs:element name='class'>
+		<xs:complexType>
+			<xs:sequence>
+				<xs:element name='student' type='StudentObject'
+					minOccurs='0' maxOccurs='unbounded' />
+			</xs:sequence>
+		</xs:complexType>
+	</xs:element>
+	<xs:complexType name="StudentObject">
+		<xs:sequence>
+			<xs:element name="name" type="xs:string" />
+			<xs:element name="age" type="xs:positiveInteger" />
+		</xs:sequence>
+		<xs:attribute name='id' type='xs:positiveInteger' />
+	</xs:complexType>
+</xs:schema>

xmlunit2-tutorial/src/test/resources/students_with_error.xml

@@ -0,0 +1,12 @@
+<?xml version = "1.0"?>
+<class>
+	<studet id="393">
+		<name>Rajiv</name>
+		<age>18</age>
+	</student>
+
+		<studet id="493">
+			<name>Candie</name>
+			<age>19</age>
+		</student>
+</class>

xmlunit2-tutorial/src/test/resources/teachers.xml

@@ -0,0 +1,10 @@
+<teachers>
+	<teacher department="science" id='309'>
+		<subject>math</subject>
+		<subject>physics</subject>
+	</teacher>
+	<teacher department="arts" id='310'>
+		<subject>political education</subject>
+		<subject>english</subject>
+	</teacher>
+</teachers>

xmlunit2-tutorial/src/test/resources/test.xml

@@ -0,0 +1,4 @@
+<struct>
+	<int>3</int>
+	<boolean>false</boolean>
+</struct>