org.exparity.hamcrest.beans

Class TheSameAs<T>

java.lang.Object

org.hamcrest.BaseMatcher<T>

org.hamcrest.TypeSafeDiagnosingMatcher<T>

org.exparity.hamcrest.beans.TheSameAs<T>

All Implemented Interfaces:

org.hamcrest.Matcher<T>, org.hamcrest.SelfDescribing

public class TheSameAs<T>
extends org.hamcrest.TypeSafeDiagnosingMatcher<T>

Implementation of a Matcher for performing a deep comparison of two objects by testing getters which start with get, is, or has are the same on each instances.

When comparing elements in a collection or an array the Matcher orders a copy of the collection. If there is a default comparator then one will be used, or alternatively one will built using CompareToBuilder.reflectionCompare(Object, Object)

Author:

Stewart Bissett

Nested Class Summary

Nested Classes

Modifier and Type	Class and Description
static interface	TheSameAs.PropertyComparator<T> Interface to be implemented by classes which can compare two property values to confirm if they're equivalent
static class	TheSameAs.PropertyType Enumeration of the types of properties the matcher will check.

Constructor Summary

Constructors

Constructor and Description
TheSameAs(T object)
TheSameAs(T object, String name, TheSameAs.PropertyType propertyTypes)
TheSameAs(T object, TheSameAs.PropertyType propertyTypes)

Method Summary

Modifier and Type	Method and Description
<P> TheSameAs<T>	comparePath(String path, org.hamcrest.Matcher<P> matcher) Override the PropertyComparator used for a path to use a hamcrest Matcher.
TheSameAs<T>	comparePath(String path, TheSameAs.PropertyComparator<?> comparator) Override the PropertyComparator used for a path.
<P> TheSameAs<T>	compareProperty(String path, org.hamcrest.Matcher<P> matcher) Override the PropertyComparator used for a property to use a hamcrest matcher.
TheSameAs<T>	compareProperty(String path, TheSameAs.PropertyComparator<?> comparator) Override the PropertyComparator used for a property.
<P> TheSameAs<T>	compareType(Class<P> type, org.hamcrest.Matcher<P> matcher) Override the PropertyComparator used for a type to use a hamcrest Matcher.
<P> TheSameAs<T>	compareType(Class<P> type, TheSameAs.PropertyComparator<P> comparator) Override the PropertyComparator used for a type.
void	describeTo(org.hamcrest.Description description)
TheSameAs<T>	excludePath(String path) Exclude a property path from the comparison.
TheSameAs<T>	excludeProperty(String property) Exclude a property from the comparison.
TheSameAs<T>	excludeType(Class<?> type) Exclude a type from the comparison.
protected boolean	matchesSafely(T item, org.hamcrest.Description mismatchDesc)
static <T> TheSameAs<T>	theSameAs(T object) Creates a matcher that matches the full object graph for the given instance against another instance by comparing all getter properties For example:
static <T> TheSameAs<T>	theSameAs(T object, String name) Creates a matcher that matches the full object graph for the given instance against another instance For example:
static <T> TheSameAs<T>	theSameBeanAs(T object) Creates a matcher that matches the full object graph for the given instance against another instance by comparing bean properties i.e.
static <T> TheSameAs<T>	theSameBeanAs(T object, String name) Creates a matcher that matches the full object graph for the given instance against another instance by comparing bean properties i.e.

Methods inherited from class org.hamcrest.TypeSafeDiagnosingMatcher

describeMismatch, matches

Methods inherited from class org.hamcrest.BaseMatcher

_dont_implement_Matcher___instead_extend_BaseMatcher_, toString

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait

Constructor Detail

TheSameAs

public TheSameAs(T object)

TheSameAs

public TheSameAs(T object,
                 TheSameAs.PropertyType propertyTypes)

TheSameAs

public TheSameAs(T object,
                 String name,
                 TheSameAs.PropertyType propertyTypes)

Method Detail

theSameAs

public static <T> TheSameAs<T> theSameAs(T object)

Creates a matcher that matches the full object graph for the given instance against another instance by comparing all getter properties

For example:

 MyObject instance = new MyObject();
 dao.save(instance); // Save instance to persistent store
 assertThat(dao.getById(instance.getId()), theSameAs(instance);
 

Parameters:

object - the instance to match against

theSameBeanAs

public static <T> TheSameAs<T> theSameBeanAs(T object)

Creates a matcher that matches the full object graph for the given instance against another instance by comparing bean properties i.e. properties with both a getter and a setter

For example:

 MyObject instance = new MyObject();
 dao.save(instance); // Save instance to persistent store
 assertThat(dao.getById(instance.getId()), theSameBeanAs(instance);
 

Parameters:

object - the instance to match against

theSameAs

public static <T> TheSameAs<T> theSameAs(T object,
                                         String name)

Creates a matcher that matches the full object graph for the given instance against another instance

For example:

 MyObject instance = new MyObject();
 dao.save(instance); // Save instance to persistent store
 assertThat(dao.getById(instance.getId()), theSameAs(instance, "MyInstance");
 

Parameters:

object - the instance to match against

name - the name given to the root entity

theSameBeanAs

public static <T> TheSameAs<T> theSameBeanAs(T object,
                                             String name)

Creates a matcher that matches the full object graph for the given instance against another instance by comparing bean properties i.e. properties with both a getter and a setter

For example:

 MyObject instance = new MyObject();
 dao.save(instance); // Save instance to persistent store
 assertThat(dao.getById(instance.getId()), theSameBeanAs(instance, "MyInstance");
 

Parameters:

object - the instance to match against

name - the name given to the root entity

excludePath

public TheSameAs<T> excludePath(String path)

Exclude a property path from the comparison. For example

 class Person [
   private String firstName, lastName;
   public Person(final String firstName, final String lastName) {
     this.firstname = firstName;
     this.lastName = lastName;
    }
    public String getFirstName() { return firstName;};
    public String getLastName() { return lastName;};
 }
 
 // Testing a simple object is the same except for a property
 Person expected = new Person("Jane", "Doe");
 MatcherAssert.assertThat(new Person("John", "Doe"), BeanMatchers.theSameAs(expected).excludePath("Person.LastName"));
 

Parameters:

property - the path to exclude from the comparison e.g Person.LastName

Returns:

the current matcher

excludeProperty

public TheSameAs<T> excludeProperty(String property)

Exclude a property from the comparison. For example

 class Person [
   private String firstName, lastName;
   public Person(final String firstName, final String lastName) {
     this.firstname = firstName;
     this.lastName = lastName;
    }
    public String getFirstName() { return firstName;};
    public String getLastName() { return lastName;};
 }
 
 // Testing a simple object is the same except for a property
 Person expected = new Person("Jane", "Doe");
 MatcherAssert.assertThat(new Person("John", "Doe"), BeanMatchers.theSameAs(expected).excludeProperty("LastName"));
 

Parameters:

property - the property to exclude from the comparison e.g LastName

Returns:

the current matcher

excludeType

public TheSameAs<T> excludeType(Class<?> type)

Exclude a type from the comparison. For example

 class Person [
   private String firstName, lastName;
   public Person(final String firstName, final String lastName) {
     this.firstname = firstName;
     this.lastName = lastName;
    }
    public String getFirstName() { return firstName;};
    public String getLastName() { return lastName;};
 }
 
 // Testing a simple object is the same except for a property
 Person expected = new Person("Jane", "Doe");
 MatcherAssert.assertThat(new Person("John", "Doe"), BeanMatchers.theSameAs(expected).excludeType(String.class));
 

Parameters:

type - the type to exclude from the comparison e.g String.class

Returns:

the current matcher

comparePath

public TheSameAs<T> comparePath(String path,
                                TheSameAs.PropertyComparator<?> comparator)

Override the PropertyComparator used for a path. For example

 class Person [
   private String firstName, lastName;
   public Person(final String firstName, final String lastName) {
     this.firstname = firstName;
     this.lastName = lastName;
    }
    public String getFirstName() { return firstName;};
    public String getLastName() { return lastName;};
 }
 
 // Testing a simple object is the same except for a property
 Person expected = new Person("John", "Doe");
 MatcherAssert.assertThat(new Person("john", "doe"), BeanMatchers.theSameAs(expected).comparePath("Person.LastName", new IsEqualsIgnoreCase());
 

Parameters:

property - the property to exclude from the comparison e.g LastName

Returns:

the current matcher

compareProperty

public TheSameAs<T> compareProperty(String path,
                                    TheSameAs.PropertyComparator<?> comparator)

Override the PropertyComparator used for a property. For example

 class Person [
   private String firstName, lastName;
   public Person(final String firstName, final String lastName) {
     this.firstname = firstName;
     this.lastName = lastName;
    }
    public String getFirstName() { return firstName;};
    public String getLastName() { return lastName;};
 }
 
 // Testing a simple object is the same except for a property
 Person expected = new Person("John", "Doe");
 MatcherAssert.assertThat(new Person("john", "doe"), BeanMatchers.theSameAs(expected).comparePath("Person.LastName", new IsEqualsIgnoreCase());
 

Parameters:

path - the path to set the comparator for

comparator - the comparator to use

Returns:

the current matcher

compareType

public <P> TheSameAs<T> compareType(Class<P> type,
                                    TheSameAs.PropertyComparator<P> comparator)

Override the PropertyComparator used for a type. For example

 class Person [
   private String firstName, lastName;
   public Person(final String firstName, final String lastName) {
     this.firstname = firstName;
     this.lastName = lastName;
    }
    public String getFirstName() { return firstName;};
    public String getLastName() { return lastName;};
 }
 
 // Testing a simple object is the same except for a property
 Person expected = new Person("John", "Doe");
 MatcherAssert.assertThat(new Person("john", "doe"), BeanMatchers.theSameAs(expected).compareType(String.class, new IsEqualsIgnoreCase());
 

Parameters:

type - the type to set the comparator for

comparator - the comparator to use

Returns:

the current matcher

comparePath

public <P> TheSameAs<T> comparePath(String path,
                                    org.hamcrest.Matcher<P> matcher)

Override the PropertyComparator used for a path to use a hamcrest Matcher. For example

 class Person [
   private String firstName, lastName;
   public Person(final String firstName, final String lastName) {
     this.firstname = firstName;
     this.lastName = lastName;
    }
    public String getFirstName() { return firstName;};
    public String getLastName() { return lastName;};
 }
 
 // Testing a simple object is the same except for a property
 Person expected = new Person("John", "Doe");
 MatcherAssert.assertThat(new Person("John", "Deer"), BeanMatchers.theSameAs(expected).comparePath("Person.LastName", Matchers.startsWith("D")));
 

Parameters:

property - the property to exclude from the comparison e.g LastName

Returns:

the current matcher

compareProperty

public <P> TheSameAs<T> compareProperty(String path,
                                        org.hamcrest.Matcher<P> matcher)

Override the PropertyComparator used for a property to use a hamcrest matcher. For example

 class Person [
   private String firstName, lastName;
   public Person(final String firstName, final String lastName) {
     this.firstname = firstName;
     this.lastName = lastName;
    }
    public String getFirstName() { return firstName;};
    public String getLastName() { return lastName;};
 }
 
 // Testing a simple object is the same except for a property
 Person expected = new Person("John", "Doe");
 MatcherAssert.assertThat(new Person("John", "Deer"), BeanMatchers.theSameAs(expected).comparePath("Person.LastName", Matchers.startsWith("D")));
 

Parameters:

path - the path to set the comparator for

matcher - the matcher to use

Returns:

the current matcher

compareType

public <P> TheSameAs<T> compareType(Class<P> type,
                                    org.hamcrest.Matcher<P> matcher)

Override the PropertyComparator used for a type to use a hamcrest Matcher. For example

 class Person [
   private String firstName, lastName;
   public Person(final String firstName, final String lastName) {
     this.firstname = firstName;
     this.lastName = lastName;
    }
    public String getFirstName() { return firstName;};
    public String getLastName() { return lastName;};
 }
 
 // Testing a simple object is the same except for a property
 Person expected = new Person("John", "Doe");
 MatcherAssert.assertThat(new Person("John", "Doe"), BeanMatchers.theSameAs(expected).compareType(String.class, Matchers.startsWith("J")));
 

Parameters:

type - the type to set the comparator for

matcher - the matcher to use

Returns:

the current matcher

matchesSafely

protected boolean matchesSafely(T item,
                                org.hamcrest.Description mismatchDesc)

Specified by:

matchesSafely in class org.hamcrest.TypeSafeDiagnosingMatcher<T>

describeTo

public void describeTo(org.hamcrest.Description description)