Làm cách nào để khẳng định một Lặp có thể chứa các phần tử với một thuộc tính nhất định?

Giả sử tôi muốn kiểm tra đơn vị một phương pháp với chữ ký này:

List<MyItem> getMyItems();

Giả sử MyItemlà một Pojo có nhiều thuộc tính, một trong số đó là "name", được truy cập qua getName().

Tất cả những gì tôi quan tâm khi xác minh là List<MyItem>, hoặc bất kỳ Iterable, chứa hai MyItemphiên bản, mà "name"thuộc tính của chúng có giá trị "foo"và "bar". Nếu bất kỳ thuộc tính nào khác không khớp, tôi không thực sự quan tâm đến mục đích của bài kiểm tra này. Nếu tên trùng khớp, đó là một thử nghiệm thành công.

Tôi muốn nó là một lớp lót nếu có thể. Đây là một số "cú pháp giả" của loại điều tôi muốn làm.

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

Hamcrest có tốt cho loại điều này không? Nếu vậy, chính xác thì phiên bản hamcrest của cú pháp giả của tôi ở trên là gì?

Cảm ơn bạn @Razvan đã chỉ cho tôi đúng hướng. Tôi đã có thể lấy nó trong một dòng và tôi đã săn lùng thành công hàng nhập khẩu cho Hamcrest 1.3.

nhập khẩu:

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;

mật mã:

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

Thử:

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

Nó không đặc biệt là Hamcrest, nhưng tôi nghĩ nó đáng được đề cập ở đây. Những gì tôi sử dụng khá thường xuyên trong Java8 là một cái gì đó như:

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

(Đã chỉnh sửa để cải thiện một chút của Rodrigo Manyari. Nó ít dài dòng hơn một chút. Xem nhận xét.)

Nó có thể hơi khó đọc hơn một chút, nhưng tôi thích sự an toàn của kiểu và cấu trúc lại. Nó cũng mát mẻ để thử nghiệm nhiều đặc tính của đậu kết hợp. ví dụ với biểu thức && giống java trong lambda bộ lọc.

Assertj rất giỏi trong việc này.

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

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

Điểm cộng lớn nhất của khẳng định so với hamcrest là dễ dàng sử dụng hoàn thành mã.

AssertJ cung cấp một tính năng tuyệt vời extracting(): bạn có thể chuyển Functions để trích xuất các trường. Nó cung cấp một kiểm tra tại thời điểm biên dịch.
Bạn cũng có thể xác nhận kích thước đầu tiên một cách dễ dàng.

Nó sẽ cho:

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

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

containsExactlyInAnyOrder() khẳng định rằng danh sách chỉ chứa các giá trị này bất kể thứ tự.

Để khẳng định rằng danh sách chứa các giá trị này bất kể thứ tự nhưng cũng có thể chứa các giá trị khác, hãy sử dụng contains():

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

Lưu ý thêm: để xác nhận nhiều trường từ các phần tử của a List, với AssertJ, chúng tôi thực hiện điều đó bằng cách gói các giá trị mong đợi cho mỗi phần tử vào một tuple()hàm:

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

Miễn là Danh sách của bạn là một lớp cụ thể, bạn có thể chỉ cần gọi phương thức chứa () miễn là bạn đã triển khai phương thức equals () của mình trên 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")));

Giả sử bạn đã triển khai một hàm tạo chấp nhận các giá trị mà bạn muốn xác nhận. Tôi nhận thấy điều này không nằm trên một dòng duy nhất, nhưng sẽ hữu ích khi biết giá trị nào bị thiếu hơn là kiểm tra cả hai cùng một lúc.

AssertJ 3.9.1 hỗ trợ việc sử dụng vị từ trực tiếp trong anyMatchphương thức.

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

Đây thường là trường hợp sử dụng thích hợp cho tình trạng phức tạp tùy ý.

Đối với các điều kiện đơn giản, tôi thích sử dụng extractingphương pháp (xem ở trên) vì kết quả thử nghiệm có thể lặp lại có thể hỗ trợ xác minh giá trị với khả năng đọc tốt hơn. Ví dụ: nó có thể cung cấp API chuyên biệt như containsphương thức trong câu trả lời của Frank Neblung. Hoặc bạn có thể gọi anyMatchnó sau bằng mọi cách và sử dụng tham chiếu phương thức chẳng hạn như "searchedvalue"::equals. Ngoài ra, nhiều bộ giải nén có thể được đưa vào extractingphương pháp, kết quả sau đó được xác minh bằng cách sử dụng tuple().