Хабрахабр

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

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

Кто-то пользуется встроенными в 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. Делать утверждения о функциях не намного сложнее, чем об объектах, и они в некоторых языках хорошо типизируются, поэтому можно разве что посоветовать лучшую типизацию, т.е.

Теги
Показать больше

Похожие статьи

Добавить комментарий

Ваш e-mail не будет опубликован. Обязательные поля помечены *

Кнопка «Наверх»
Закрыть