Wie kann ich behaupten, dass eine Iterable Elemente mit einer bestimmten Eigenschaft enthält?

Angenommen, ich möchte eine Methode mit dieser Signatur testen:

List<MyItem> getMyItems();

Angenommen, es MyItemhandelt sich um ein Pojo mit vielen Eigenschaften, auf die "name"über zugegriffen werden kann getName().

Ich möchte nur überprüfen, ob die List<MyItem>oder eine Iterableder beiden MyItemInstanzen zwei Instanzen enthält , deren "name"Eigenschaften die Werte "foo"und haben "bar". Wenn andere Eigenschaften nicht übereinstimmen, interessieren mich die Zwecke dieses Tests nicht wirklich. Wenn die Namen übereinstimmen, ist dies ein erfolgreicher Test.

Ich möchte, dass es wenn möglich einzeilig ist. Hier ist eine "Pseudo-Syntax", wie ich sie gerne machen würde.

assert(listEntriesMatchInAnyOrder(myClass.getMyItems(), property("name"), new String[]{"foo", "bar"});

Wäre Hamcrest gut für so etwas? Wenn ja, was genau wäre die Hamcrest-Version meiner obigen Pseudosyntax?

Vielen Dank an @Razvan, der mich in die richtige Richtung gelenkt hat. Ich konnte es in einer Zeile bekommen und habe die Importe für Hamcrest 1.3 erfolgreich gejagt.

die Importe:

import static org.hamcrest.CoreMatchers.is;
import static org.hamcrest.Matchers.contains;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.hamcrest.beans.HasPropertyWithValue.hasProperty;

der Code:

assertThat( myClass.getMyItems(), contains(
    hasProperty("name", is("foo")), 
    hasProperty("name", is("bar"))
));

Versuchen:

assertThat(myClass.getMyItems(),
                          hasItem(hasProperty("YourProperty", is("YourValue"))));

Es ist nicht besonders Hamcrest, aber ich denke, es ist erwähnenswert, hier zu erwähnen. Was ich in Java8 ziemlich oft benutze, ist wie folgt:

assertTrue(myClass.getMyItems().stream().anyMatch(item -> "foo".equals(item.getName())));

(Bearbeitet zu Rodrigo Manyaris leichter Verbesserung. Es ist etwas weniger ausführlich. Siehe Kommentare.)

Es ist vielleicht etwas schwieriger zu lesen, aber ich mag den Typ und die Refactoring-Sicherheit. Es ist auch cool, um mehrere Bohneneigenschaften in Kombination zu testen. zB mit einem Java-ähnlichen && Ausdruck im Filter Lambda.

Assertj ist gut darin.

import static org.assertj.core.api.Assertions.assertThat;

    assertThat(myClass.getMyItems()).extracting("name").contains("foo", "bar");

Ein großes Plus für assertj im Vergleich zu hamcrest ist die einfache Verwendung der Code-Vervollständigung.

AssertJ bietet eine hervorragende Funktion in extracting(): Sie können Functions übergeben, um Felder zu extrahieren. Es bietet eine Überprüfung zur Kompilierungszeit.
Sie können die Größe auch einfach zuerst festlegen.

Es würde geben:

import static org.assertj.core.api.Assertions;

Assertions.assertThat(myClass.getMyItems())
          .hasSize(2)
          .extracting(MyItem::getName)
          .containsExactlyInAnyOrder("foo", "bar"); 

containsExactlyInAnyOrder() behauptet, dass die Liste unabhängig von der Reihenfolge nur diese Werte enthält.

Um zu behaupten, dass die Liste diese Werte unabhängig von der Reihenfolge enthält, aber auch andere Werte enthalten kann, verwenden Sie contains():

.contains("foo", "bar"); 

Als Randnotiz: ListUm mehrere Felder aus Elementen von a zu aktivieren, tun wir dies mit AssertJ, indem wir die erwarteten Werte für jedes Element in eine tuple()Funktion einschließen :

import static org.assertj.core.api.Assertions;
import static org.assertj.core.groups.Tuple;

Assertions.assertThat(myClass.getMyItems())
          .hasSize(2)
          .extracting(MyItem::getName, MyItem::getOtherValue)
          .containsExactlyInAnyOrder(
               tuple("foo", "OtherValueFoo"),
               tuple("bar", "OtherValueBar")
           ); 

Solange Ihre Liste eine konkrete Klasse ist, können Sie einfach die Methode includes () aufrufen, solange Sie Ihre Methode equals () in MyItem implementiert haben.

// given 
// some input ... you to complete

// when
List<MyItems> results = service.getMyItems();

// then
assertTrue(results.contains(new MyItem("foo")));
assertTrue(results.contains(new MyItem("bar")));

Angenommen, Sie haben einen Konstruktor implementiert, der die Werte akzeptiert, für die Sie eine Bestätigung erstellen möchten. Mir ist klar, dass dies nicht in einer einzelnen Zeile steht, aber es ist nützlich zu wissen, welcher Wert fehlt, anstatt beide gleichzeitig zu überprüfen.

AssertJ 3.9.1 unterstützt die direkte Verwendung von Prädikaten in anyMatchMethoden.

assertThat(collection).anyMatch(element -> element.someProperty.satisfiesSomeCondition())

Dies ist im Allgemeinen ein geeigneter Anwendungsfall für beliebig komplexe Zustände.

Für einfache Bedingungen bevorzuge ich extracting Methode (siehe oben), da die daraus resultierende iterierbare Prüfung die Wertüberprüfung mit besserer Lesbarkeit unterstützen kann. Beispiel: Es kann eine spezielle API wie die containsMethode in Frank Neblungs Antwort bereitstellen . Oder Sie können anyMatches später trotzdem aufrufen und Methodenreferenzen wie z "searchedvalue"::equals. Es können auch mehrere Extraktoren in extractingMethode gebracht werden, deren Ergebnis anschließend mit überprüft wird tuple().