Jak potwierdzić, że iterowalna zawiera elementy o określonej właściwości?

Załóżmy, że chcę przetestować jednostkowo metodę z tym podpisem:

List<MyItem> getMyItems();

Załóżmy, że MyItemjest to Pojo, które ma wiele właściwości, z których jedna jest "name"dostępna przez getName().

Jedyne, co mi zależy na weryfikacji, to to List<MyItem>, czy element lub any Iterablezawiera dwa MyItemwystąpienia, których "name"właściwości mają wartości "foo"i "bar". Jeśli jakiekolwiek inne właściwości nie pasują, nie obchodzą mnie cele tego testu. Jeśli nazwy pasują do siebie, jest to udany test.

Chciałbym, żeby to było jednowierszowe, jeśli to możliwe. Oto trochę „pseudo-składni” tego rodzaju, co chciałbym zrobić.

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

Czy Hamcrest byłby dobry do tego typu rzeczy? Jeśli tak, to jaka dokładnie byłaby wersja hamcrest powyższej pseudo-składni?

Dziękuję @Razvan, który wskazał mi właściwy kierunek. Udało mi się go zdobyć w jednej linii iz powodzeniem polowałem na import Hamcrest 1.3.

import:

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;

kod:

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

Próbować:

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

Nie jest to szczególnie Hamcrest, ale myślę, że warto o tym tutaj wspomnieć. To, czego często używam w Javie8, to coś takiego:

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

(Zredagowano zgodnie z niewielką poprawą Rodrigo Manyariego. Jest trochę mniej szczegółowa. Zobacz komentarze).

Może to być trochę trudniejsze do odczytania, ale podoba mi się typ i bezpieczeństwo refaktoryzacji. Jest również fajny do testowania wielu właściwości fasoli w połączeniu. np. z wyrażeniem && podobnym do języka java w filtrze lambda.

Assertj jest w tym dobry.

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

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

Dużym plusem assertj w porównaniu do hamcrest jest łatwość uzupełniania kodu.

AssertJ zapewnia doskonałą funkcję w extracting(): możesz podać Functions, aby wyodrębnić pola. Zapewnia kontrolę w czasie kompilacji.
Możesz również łatwo ustalić rozmiar jako pierwszy.

Dałoby to:

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

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

containsExactlyInAnyOrder() potwierdza, że ​​lista zawiera tylko te wartości, niezależnie od kolejności.

Aby potwierdzić, że lista zawiera te wartości niezależnie od kolejności, ale może również zawierać inne wartości, użyj contains():

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

Na marginesie: aby potwierdzić wiele pól z elementów a List, za pomocą AssertJ robimy to, opakowując oczekiwane wartości dla każdego elementu w tuple()funkcję:

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

Dopóki List jest klasą konkretną, możesz po prostu wywołać metodę zawiera (), o ile zaimplementowano metodę equals () w 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")));

Zakłada się, że zaimplementowano konstruktora, który akceptuje wartości, dla których chcesz potwierdzić. Zdaję sobie sprawę, że to nie jest w jednej linii, ale warto wiedzieć, której wartości brakuje, zamiast sprawdzać obie na raz.

AssertJ 3.9.1 obsługuje bezpośrednie użycie predykatów w anyMatchmetodzie.

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

Jest to ogólnie odpowiedni przypadek użycia dla dowolnie złożonych warunków.

W przypadku prostych warunków wolę używać extractingmetody (patrz powyżej), ponieważ wynikowe iterowalne testy mogą wspierać weryfikację wartości z lepszą czytelnością. Przykład: może zapewnić wyspecjalizowane API, takie jak containsmetoda w odpowiedzi Franka Neblunga. Lub możesz anyMatchgo później wywołać i użyć odwołania do metody, takiego jak "searchedvalue"::equals. Do extractingmetody można również wprowadzić wiele ekstraktorów , a następnie zweryfikować wynik za pomocą tuple().