Hamcrest Object Matchers

Hamcrest-Objektvergleicher

1. Überblick

Hamcrest provides matchers for making unit test assertions simpler and more legible. Sie können beginnen, einige der verfügbaren Matcherhere zu erkunden.

In diesem kurzen Tutorial werden wir uns eingehender mit Objekt-Matchern befassen.

2. Konfiguration

Um Hamcrest zu erhalten, müssen wir nuradd the following Maven dependency to our pom.xml:


    org.hamcrest
    java-hamcrest
    2.0.0.0
    test

Die neueste Hamcrest-Version finden Sie überMaven Central.

3. Objekt-Matcher

Object matchers are meant to perform checks over object’s properties.

Bevor wir uns die Matcher ansehen, werden wir ein paar Bohnen erstellen, um die Beispiele einfach zu verstehen.

Unser erstes Objekt heißtLocation und hat keine Eigenschaften:

public class Location {}

Wir werden unsere zweite BeanCity benennen und die folgende Implementierung hinzufügen:

public class City extends Location {

    String name;
    String state;

    // standard constructor, getters and setters

    @Override
    public String toString() {
        if (this.name == null && this.state == null) {
            return null;
        }
        StringBuilder sb = new StringBuilder();
        sb.append("[");
        sb.append("Name: ");
        sb.append(this.name);
        sb.append(", ");
        sb.append("State: ");
        sb.append(this.state);
        sb.append("]");
        return sb.toString();
    }
}

Beachten Sie, dassCityLocation erweitert. Wir werden später davon Gebrauch machen. Beginnen wir jetzt mit den Objekt-Matchern!

3.1. hasToString

Wie der Name schon sagt, sind diehasToString method verifies that certain object has a toString method that returns a specific String:

@Test
public void givenACity_whenHasToString_thenCorrect() {
    City city = new City("San Francisco", "CA");

    assertThat(city, hasToString("[Name: San Francisco, State: CA]"));
}

Wir erstellen also einCity und überprüfen, ob dietoString-Methode das gewünschteString zurückgibt. Wir können noch einen Schritt weiter gehen und anstatt auf Gleichheit zu prüfen, auf eine andere Bedingung prüfen:

@Test
public void givenACity_whenHasToStringEqualToIgnoringCase_thenCorrect() {
    City city = new City("San Francisco", "CA");

    assertThat(city, hasToString(
      equalToIgnoringCase("[NAME: SAN FRANCISCO, STATE: CA]")));
}

Wie wir sehen können,hasToString is overloaded and can receive both a String or a text matcher as a parameter. So können wir auch Dinge tun wie:

@Test
public void givenACity_whenHasToStringEmptyOrNullString_thenCorrect() {
    City city = new City(null, null);

    assertThat(city, hasToString(emptyOrNullString()));
}

Weitere Informationen zu Text-Matchernhere finden Sie hier. Fahren wir nun mit dem nächsten Objektvergleich fort.

3.2. typeCompatibleWith

Dieser Matcherrepresents an is-a relationship. Hier kommt die Superklasse vonLocationins Spiel:

@Test
public void givenACity_whenTypeCompatibleWithLocation_thenCorrect() {
    City city = new City("San Francisco", "CA");

    assertThat(city.getClass(), is(typeCompatibleWith(Location.class)));
}

Dies bedeutet, dassCity-aLocation, ist, was wahr ist und dieser Test bestehen sollte. Auch wenn wir den negativen Fall testen wollten:

@Test
public void givenACity_whenTypeNotCompatibleWithString_thenCorrect() {
    City city = new City("San Francisco", "CA");

    assertThat(city.getClass(), is(not(typeCompatibleWith(String.class))));
}

Natürlich ist unsereCity-Klasse keineString.

Beachten Sie schließlich, dass alle Java-Objekte den folgenden Test bestehen sollten:

@Test
public void givenACity_whenTypeCompatibleWithObject_thenCorrect() {
    City city = new City("San Francisco", "CA");

    assertThat(city.getClass(), is(typeCompatibleWith(Object.class)));
}

Bitte denken Sie daran, dassthe matcher is consists of a wrapper over another matcher with the purpose of making the whole assertion more readable.

4. Fazit

Hamcrest provides a simple and clean way of creating assertions. Es gibt eine Vielzahl von Matchern, die das Leben jedes Entwicklers vereinfachen und jedes Projekt besser lesbar machen.

Und Objekt-Matcher sind definitiv eine einfache Möglichkeit, Klasseneigenschaften zu überprüfen.

Wie immer finden Sie die vollständige Implementierung überthe GitHub project.

TOC