Fixed getChild(NodePath)

Author: SQiShER

src/main/java/de/danielbechler/diff/DiffNode.java

@@ -17,12 +17,12 @@
 package de.danielbechler.diff;
 
 import de.danielbechler.diff.bean.BeanPropertyElementSelector;
-import de.danielbechler.diff.visitor.PropertyVisitor;
 import de.danielbechler.util.Assert;
 
 import java.lang.annotation.Annotation;
 import java.util.Collections;
 import java.util.LinkedHashMap;
+import java.util.List;
 import java.util.Map;
 import java.util.Set;
 import java.util.TreeSet;
@@ -238,14 +238,19 @@ public DiffNode getChild(final String propertyName)
 	/**
 	 * Retrieve a child that matches the given absolute path, starting from the current node.
 	 *
-	 * @param path The path from the object root to the requested child node.
+	 * @param nodePath The path from the object root to the requested child node.
 	 * @return The requested child node or <code>null</code>.
 	 */
-	public DiffNode getChild(final NodePath path)
+	public DiffNode getChild(final NodePath nodePath)
 	{
-		final PropertyVisitor visitor = new PropertyVisitor(path);
-		visitChildren(visitor);
-		return visitor.getNode();
+		if (parentNode != null)
+		{
+			return parentNode.getChild(nodePath.getElementSelectors());
+		}
+		else
+		{
+			return getChild(nodePath.getElementSelectors());
+		}
 	}
 
 	/**
@@ -259,6 +264,46 @@ public DiffNode getChild(final ElementSelector pathElementSelector)
 		return children.get(pathElementSelector);
 	}
 
+	/**
+	 * Retrieve a child that matches the given path element relative to this node.
+	 *
+	 * @param selectors The path element of the child node to get.
+	 * @return The requested child node or <code>null</code>.
+	 */
+	public DiffNode getChild(final List<ElementSelector> selectors)
+	{
+		Assert.notEmpty(selectors, "selectors");
+		final ElementSelector selector = selectors.get(0);
+		if (selectors.size() == 1)
+		{
+			if (selector == RootElementSelector.getInstance())
+			{
+				return isRootNode() ? this : null;
+			}
+			else
+			{
+				return getChild(selector);
+			}
+		}
+		else if (selectors.size() > 1)
+		{
+			final DiffNode child;
+			if (selector == RootElementSelector.getInstance())
+			{
+				child = isRootNode() ? this : null;
+			}
+			else
+			{
+				child = getChild(selector);
+			}
+			if (child != null)
+			{
+				return child.getChild(selectors.subList(1, selectors.size()));
+			}
+		}
+		return null;
+	}
+
 	/**
 	 * Adds a child to this node and sets this node as its parent node.
 	 *

src/test/java/de/danielbechler/diff/DiffNodeSpec.groovy

@@ -0,0 +1,39 @@
+/*
+ * Copyright 2014 Daniel Bechler
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package de.danielbechler.diff
+
+import de.danielbechler.diff.collection.CollectionItemAccessor
+import spock.lang.Specification
+
+/**
+ * Created by Daniel Bechler.
+ */
+class DiffNodeSpec extends Specification {
+	def rootNode = new DiffNode()
+	def childNodeA = new DiffNode(rootNode, new CollectionItemAccessor('A'), null)
+	def childNodeB = new DiffNode(rootNode, new CollectionItemAccessor('B'), null)
+
+	def setup() {
+		rootNode.addChild(childNodeA)
+		rootNode.addChild(childNodeB)
+	}
+
+	def 'getChild(NodePath) always starts at root node'() {
+		expect:
+		  childNodeA.getChild(NodePath.startBuilding().collectionItem('B').build()) == childNodeB
+	}
+}

src/test/java/de/danielbechler/diff/DiffNodeTest.java

@@ -22,8 +22,10 @@
 import de.danielbechler.diff.collection.CollectionItemElementSelector;
 import de.danielbechler.diff.helper.NodeAssertions;
 import de.danielbechler.diff.mock.ObjectDiffTest;
-import org.fest.assertions.api.Assertions;
+import org.hamcrest.MatcherAssert;
 import org.hamcrest.core.Is;
+import org.mockito.Mockito;
+import org.mockito.MockitoAnnotations;
 import org.testng.annotations.BeforeMethod;
 import org.testng.annotations.Test;
 
@@ -34,13 +36,7 @@
 import java.util.Set;
 
 import static org.fest.assertions.api.Assertions.assertThat;
-import static org.hamcrest.MatcherAssert.assertThat;
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.times;
-import static org.mockito.Mockito.verify;
-import static org.mockito.Mockito.when;
 import static org.mockito.MockitoAnnotations.Mock;
-import static org.mockito.MockitoAnnotations.initMocks;
 
 /**
  * @author Daniel Bechler
@@ -53,55 +49,55 @@ public class DiffNodeTest
 	@BeforeMethod
 	public void setUp()
 	{
-		initMocks(this);
+		MockitoAnnotations.initMocks(this);
 	}
 
 	@Test
 	public void hasChanges_returns_false_when_untouched()
 	{
 		final DiffNode node = new DiffNode(String.class);
 		node.setState(DiffNode.State.UNTOUCHED);
-		assertThat(node.hasChanges(), Is.is(false));
+		MatcherAssert.assertThat(node.hasChanges(), Is.is(false));
 	}
 
 	@Test
 	public void hasChanges_returns_false_when_ignored()
 	{
 		final DiffNode node = new DiffNode(String.class);
 		node.setState(DiffNode.State.IGNORED);
-		assertThat(node.hasChanges(), Is.is(false));
+		MatcherAssert.assertThat(node.hasChanges(), Is.is(false));
 	}
 
 	@Test
 	public void hasChanges_returns_false_when_circular()
 	{
 		final DiffNode node = new DiffNode(String.class);
 		node.setState(DiffNode.State.CIRCULAR);
-		assertThat(node.hasChanges(), Is.is(false));
+		MatcherAssert.assertThat(node.hasChanges(), Is.is(false));
 	}
 
 	@Test
 	public void hasChanges_returns_true_when_changed()
 	{
 		final DiffNode node = new DiffNode(String.class);
 		node.setState(DiffNode.State.CHANGED);
-		assertThat(node.hasChanges(), Is.is(true));
+		MatcherAssert.assertThat(node.hasChanges(), Is.is(true));
 	}
 
 	@Test
 	public void hasChanges_returns_true_when_removed()
 	{
 		final DiffNode node = new DiffNode(String.class);
 		node.setState(DiffNode.State.REMOVED);
-		assertThat(node.hasChanges(), Is.is(true));
+		MatcherAssert.assertThat(node.hasChanges(), Is.is(true));
 	}
 
 	@Test
 	public void hasChanges_returns_true_when_added()
 	{
 		final DiffNode node = new DiffNode(String.class);
 		node.setState(DiffNode.State.ADDED);
-		assertThat(node.hasChanges(), Is.is(true));
+		MatcherAssert.assertThat(node.hasChanges(), Is.is(true));
 	}
 
 	@Test
@@ -111,14 +107,14 @@ public void hasChanges_returns_true_when_child_has_changed()
 		final DiffNode child = new DiffNode(root, new CollectionItemAccessor("foo"), String.class);
 		root.addChild(child);
 		child.setState(DiffNode.State.ADDED);
-		assertThat(root.hasChanges(), Is.is(true));
+		MatcherAssert.assertThat(root.hasChanges(), Is.is(true));
 	}
 
 	@Test
 	public void getPropertyPath_with_parent_node_should_return_canonical_path()
 	{
 		final DiffNode parentNode = new DiffNode(RootAccessor.getInstance(), String.class);
-		when(accessor.getElementSelector()).thenReturn(new BeanPropertyElementSelector("foo"));
+		Mockito.when(accessor.getElementSelector()).thenReturn(new BeanPropertyElementSelector("foo"));
 
 		final DiffNode root = new DiffNode(parentNode, accessor, Object.class);
 
@@ -182,44 +178,44 @@ public void addChild_changes_node_state_to_changed_if_changed_child_node_gets_ad
 	@Test
 	public void should_return_property_annotations_of_property_accessor() throws Exception
 	{
-		final BeanPropertyAccessor propertyAccessor = mock(BeanPropertyAccessor.class);
-		final Annotation annotation = mock(Annotation.class);
-		when(propertyAccessor.getReadMethodAnnotations()).thenReturn(new LinkedHashSet<Annotation>(Arrays.asList(annotation)));
+		final BeanPropertyAccessor propertyAccessor = Mockito.mock(BeanPropertyAccessor.class);
+		final Annotation annotation = Mockito.mock(Annotation.class);
+		Mockito.when(propertyAccessor.getReadMethodAnnotations()).thenReturn(new LinkedHashSet<Annotation>(Arrays.asList(annotation)));
 		final DiffNode node = new DiffNode(propertyAccessor, Object.class);
 
 		final Set<Annotation> annotations = node.getPropertyAnnotations();
 
-		Assertions.assertThat(annotations).containsAll(Arrays.asList(annotation));
+		assertThat(annotations).containsAll(Arrays.asList(annotation));
 	}
 
 	@Test
 	public void should_return_empty_set_of_property_annotations_if_accessor_is_not_property_accessor() throws Exception
 	{
-		final BeanPropertyAccessor propertyAccessor = mock(BeanPropertyAccessor.class);
-		final Annotation annotation = mock(Annotation.class);
-		when(propertyAccessor.getReadMethodAnnotations()).thenReturn(new LinkedHashSet<Annotation>(Arrays.asList(annotation)));
+		final BeanPropertyAccessor propertyAccessor = Mockito.mock(BeanPropertyAccessor.class);
+		final Annotation annotation = Mockito.mock(Annotation.class);
+		Mockito.when(propertyAccessor.getReadMethodAnnotations()).thenReturn(new LinkedHashSet<Annotation>(Arrays.asList(annotation)));
 		final DiffNode node = new DiffNode(propertyAccessor, Object.class);
 
 		final Set<Annotation> annotations = node.getPropertyAnnotations();
 
-		Assertions.assertThat(annotations).containsAll(Arrays.asList(annotation));
+		assertThat(annotations).containsAll(Arrays.asList(annotation));
 	}
 
 	@Test
 	public void getPropertyAnnotation_should_delegate_call_to_property_accessor()
 	{
-		final BeanPropertyAccessor propertyAccessor = mock(BeanPropertyAccessor.class);
-		when(propertyAccessor.getReadMethodAnnotation(ObjectDiffTest.class)).thenReturn(null);
+		final BeanPropertyAccessor propertyAccessor = Mockito.mock(BeanPropertyAccessor.class);
+		Mockito.when(propertyAccessor.getReadMethodAnnotation(ObjectDiffTest.class)).thenReturn(null);
 
 		new DiffNode(propertyAccessor, Object.class).getPropertyAnnotation(ObjectDiffTest.class);
 
-		verify(propertyAccessor, times(1)).getReadMethodAnnotation(ObjectDiffTest.class);
+		Mockito.verify(propertyAccessor, Mockito.times(1)).getReadMethodAnnotation(ObjectDiffTest.class);
 	}
 
 	@Test
 	public void getPropertyAnnotation_should_return_null_if_accessor_is_not_property_accessor()
 	{
-		final Accessor propertyAccessor = mock(Accessor.class);
+		final Accessor propertyAccessor = Mockito.mock(Accessor.class);
 
 		final ObjectDiffTest annotation = new DiffNode(propertyAccessor, Object.class).getPropertyAnnotation(ObjectDiffTest.class);
 
@@ -230,8 +226,8 @@ public void getPropertyAnnotation_should_return_null_if_accessor_is_not_property
 	public void getPropertyName_returns_name_from_PropertyAwareAccessor()
 	{
 		final String expectedPropertyName = "foo";
-		final PropertyAwareAccessor accessor = mock(PropertyAwareAccessor.class);
-		when(accessor.getPropertyName()).thenReturn(expectedPropertyName);
+		final PropertyAwareAccessor accessor = Mockito.mock(PropertyAwareAccessor.class);
+		Mockito.when(accessor.getPropertyName()).thenReturn(expectedPropertyName);
 
 		final DiffNode diffNode = new DiffNode(accessor, Object.class);
 		final String actualPropertyName = diffNode.getPropertyName();
@@ -244,27 +240,27 @@ public void getPropertyName_returns_name_from_parentNode()
 	{
 		final String expectedPropertyName = "foo";
 
-		final PropertyAwareAccessor propertyAwareAccessor = mock(PropertyAwareAccessor.class);
-		when(propertyAwareAccessor.getPropertyName()).thenReturn(expectedPropertyName);
+		final PropertyAwareAccessor propertyAwareAccessor = Mockito.mock(PropertyAwareAccessor.class);
+		Mockito.when(propertyAwareAccessor.getPropertyName()).thenReturn(expectedPropertyName);
 
 		final DiffNode parentNodeWithPropertyAwareAccessor = new DiffNode(propertyAwareAccessor, Object.class);
-		final DiffNode node = new DiffNode(parentNodeWithPropertyAwareAccessor, mock(Accessor.class), Object.class);
+		final DiffNode node = new DiffNode(parentNodeWithPropertyAwareAccessor, Mockito.mock(Accessor.class), Object.class);
 
 		assertThat(node.getPropertyName()).isEqualTo(expectedPropertyName);
 	}
 
 	@Test
 	public void getPropertyName_returns_null_when_property_name_can_not_be_resolved()
 	{
-		final DiffNode node = new DiffNode(mock(Accessor.class), Object.class);
+		final DiffNode node = new DiffNode(Mockito.mock(Accessor.class), Object.class);
 
 		assertThat(node.getPropertyName()).isNull();
 	}
 
 	@Test
 	public void isPropertyAware_returns_true()
 	{
-		final PropertyAwareAccessor propertyAwareAccessor = mock(PropertyAwareAccessor.class);
+		final PropertyAwareAccessor propertyAwareAccessor = Mockito.mock(PropertyAwareAccessor.class);
 		final DiffNode node = new DiffNode(propertyAwareAccessor, Object.class);
 
 		assertThat(node.isPropertyAware()).isTrue();
@@ -273,7 +269,7 @@ public void isPropertyAware_returns_true()
 	@Test
 	public void isPropertyAware_returns_false()
 	{
-		final Accessor notAPropertyAwareAccessor = mock(Accessor.class);
+		final Accessor notAPropertyAwareAccessor = Mockito.mock(Accessor.class);
 
 		final DiffNode node = new DiffNode(notAPropertyAwareAccessor, Object.class);