Как правильно писать ассерты

Поговорим теперь об ассертах

Ассерты — одна из само собой разумеющихся вещей, поэтому все тут, казалось бы, специалисты. Кто-то пользуется встроенными в Java или в Junit, кто-то пользуется продвинутыми библиотеками, кто-то сооружает собственную.

Но попробуем подойти к этому более серьезно. Как, на самом деле, правильно?

Во-первых, ассерты дублируют спецификацию. Если в спецификации указан shouldReturnValidOrder, то и проверять нужно именно это, а не assertNotNull.

Во-вторых, ассерты должно быть легко читать. Т.е., мгновенно, сопоставляя со спецификацией.

Если ассертов слишком много (на мой крайний вкус много это больше одного, но поставим ограничение хотя бы в пять-семь), то тест перестает быть понимаемым. По хорошему, у каждого теста должна быть только одна причина упасть.

Ассерты могут быть направлены на: примитивное поле, объект, коллекцию, редко функцию или thunk.

Чем сложнее объект, тем сложнее и разнообразнее будут ассерты, и тем сложнее их будет читать и находить ошибки.

Положительные утверждения читаются лучше двойных отрицательных.

Стандартные методы читаются лучше кастомных хелперов. (Кто знает, кто и где тестировал библиотеку хелперов). И ассерты должны находиться в теле тестового метода, а не где-то в глубине тестовых хелперов (сонар справедливо ругается на отсутствие ассертов).
Ассерты о полях понятнее, чем ассерты об объектах и уж тем более о коллекциях.

В случае вложенных полей имеет смысл тестировать полностью

не

assertNotNull(order.getCustomer().getName)

а

assertNotNull(order)
assertNotNull(order.getCustomer())
assertNotNull(order.getCustomer().getName())

Ассерты не просто тупо проверяют то, что возвращается из метода, а влияют на это. И если в наших силах это поменять, то нужно поменять.

Относительно сложно делать утверждения о коллекциях. Содержат ли они нули, отсортированы ли они, как именно отсортированы, как именно проверяется равенство элементов и т.д. — все это делает коллекции трудными объектами для ассертов, особенно когда в методе присутствует и логика относящаяся к элементам коллекций.

Поэтому метод типа

List<Order> getOrderList(List<OrderDao> orderDaoList){
        return orderDaoList.stream().map(orderDao=>order.name(orderDao.getName).build()).collect(Collectors.toList())
}

легко разбить на два, один трансформер orderDao=>order и протестировать его отдельно, а второй будет тестировать маппинг коллекций на абстрактном маппере, и мы сможем его простестировать на заглушке.

List<Order> getOrderList(List<OrderDao> orderDaoList, OrderDaoToOrderMapper mapper){
        return orderDaoList.stream().map(mapper::map).collect(Collectors.toList())
}

С другой стороны, коллекции хорошо поддаются типизации и расширению, т.е. мы относительно легко можем сделать коллекцию собственного типа со всеми проверенными свойствами, ко- и контравариантностью и тп. Поэтому вместо generic List мы могли бы сделать свой собственный OrderList, или OrderSet, или OrderSortedSet, и чем специфичнее, тем лучше. И тесты станут проще.

Делать утверждения о функциях не намного сложнее, чем об объектах, и они в некоторых языках хорошо типизируются, поэтому можно разве что посоветовать лучшую типизацию, т.е. вместо Func <Order,Order> возвращать какой-нибудь OrderComparator.

Автор: rudnevr

Источник ^[1]