Come si afferma che un Iterable contiene elementi con una determinata proprietà?

Supponiamo di voler eseguire un test unitario di un metodo con questa firma:

List<MyItem> getMyItems();

Supponiamo che MyItemsia un Pojo che ha molte proprietà, una delle quali è "name"accessibile tramite getName().

Tutto quello che mi interessa verificare è che List<MyItem>, o any Iterable, contenga due MyItemistanze, le cui "name"proprietà hanno i valori "foo"e "bar". Se altre proprietà non corrispondono, non mi interessa davvero gli scopi di questo test. Se i nomi corrispondono, è un test di successo.

Vorrei che fosse una battuta, se possibile. Ecco un po 'di "pseudo-sintassi" del genere di cose che vorrei fare.

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

Hamcrest andrebbe bene per questo tipo di cose? In tal caso, quale sarebbe esattamente la versione hamcrest della mia pseudo-sintassi sopra?

Grazie @Razvan che mi ha indicato la giusta direzione. Sono stato in grado di ottenerlo in una riga e ho cercato con successo le importazioni per Hamcrest 1.3.

le importazioni:

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;

il codice:

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

Provare:

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

Non è particolarmente Hamcrest, ma penso che valga la pena menzionarlo qui. Quello che uso abbastanza spesso in Java8 è qualcosa del tipo:

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

(Modificato in base al leggero miglioramento di Rodrigo Manyari. È un po 'meno prolisso. Vedi i commenti.)

Potrebbe essere un po 'più difficile da leggere, ma mi piace il tipo e la sicurezza del refactoring. È anche utile per testare più proprietà dei fagioli in combinazione. ad esempio con un'espressione && simile a java nel filtro lambda.

Assertj è bravo in questo.

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

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

Un grande vantaggio per assertj rispetto a hamcrest è il facile utilizzo del completamento del codice.

AssertJ fornisce un'eccellente funzionalità in extracting(): puoi passare Functions per estrarre i campi. Fornisce un controllo in fase di compilazione.
Puoi anche affermare facilmente la dimensione prima.

Darebbe:

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

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

containsExactlyInAnyOrder() afferma che l'elenco contiene solo questi valori qualunque sia l'ordine.

Per affermare che l'elenco contiene questi valori qualunque sia l'ordine, ma può contenere anche altri valori, utilizzare contains():

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

Come nota a Listmargine : per affermare più campi da elementi di a , con AssertJ lo facciamo avvolgendo i valori attesi per ogni elemento in una tuple()funzione:

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")
           ); 

Finché la tua List è una classe concreta, puoi semplicemente chiamare il metodo contains () purché tu abbia implementato il tuo metodo equals () su MyItem.

// 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")));

Si presume che tu abbia implementato un costruttore che accetta i valori su cui vuoi affermare. Mi rendo conto che questo non è su una singola riga, ma è utile sapere quale valore manca piuttosto che controllarli entrambi contemporaneamente.

AssertJ 3.9.1 supporta l'utilizzo diretto del predicato nel anyMatchmetodo.

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

Questo è generalmente un caso d'uso adatto per condizioni arbitrariamente complesse.

Per le condizioni semplici preferisco usare il extractingmetodo (vedi sopra) perché l'iterable-under-test risultante potrebbe supportare la verifica del valore con una migliore leggibilità. Esempio: può fornire API specializzate come il containsmetodo nella risposta di Frank Neblung. Oppure puoi comunque richiamarlo anyMatchin un secondo momento e utilizzare riferimenti al metodo come "searchedvalue"::equals. Anche più estrattori possono essere inseriti nel extractingmetodo, risultato successivamente verificato utilizzando tuple().