Advocating against the use of mocks in tests

Why mocks should not be used in tests

Transcript

1. Strong opinions (almost) weekly held
2. Advocating against mocks
3. Example
4. Example interface CreditCardTransactor {c fun checkCreditCardState(creditCard: String): CreditCardState fun pay( transaction: Transaction, creditCard: String, dollars: BigDecimal ): Payment fun beginTransaction(): Transaction fun rollBack(transaction: Transaction) fun competeTransaction(transaction: Transaction) }cc
5. Example interface PaymentProcessor {c fun processPayment(creditCard: String, amount: BigDecimal) }c
6. Example class CardPaymentsProcessor( private val creditCardTransactor: CreditCardTransactor ) : PaymentProcessor {c override fun processPayment(creditCard: String, amount: BigDecimal) { when (creditCardTransactor.checkCreditCardState(creditCard)) { CreditCardState.Gucci -> transact(creditCard, amount) CreditCardState.Stolen -> callPolice() }c }c }c
7. Example class CardPaymentsProcessor( private val creditCardTransactor: CreditCardTransactor ) : PaymentProcessor {c override fun processPayment(creditCard: String, amount: BigDecimal) { when (creditCardTransactor.checkCreditCardState(creditCard)) { CreditCardState.Gucci -> transact(creditCard, amount) CreditCardState.Stolen -> callPolice() }c }c }c
8. Example private fun transact(creditCard: String, amount: BigDecimal) {c val transaction = creditCardTransactor.beginTransaction() val payment = creditCardTransactor.pay(transaction, creditCard, amount) if (payment.isOvercharge()) {c creditCardTransactor.rollBack(transaction) }cc creditCardTransactor.competeTransaction(transaction) }cc
9. Test @Test fun spendingMoneyLikeNoTomorrow() {c }c
10. Test @Test fun spendingMoneyLikeNoTomorrow() {c }c c override fun processPayment(creditCard: String, amount: BigDecimal) {c when (creditCardTransactor.checkCreditCardState(creditCard)) {c CreditCardState.Gucci -> transact(creditCard, amount) CreditCardState.Stolen -> callPolice() }b }b
11. Test override fun processPayment(creditCard: String, amount: BigDecimal) {c when (creditCardTransactor.checkCreditCardState(creditCard)) {c CreditCardState.Gucci -> transact(creditCard, amount) CreditCardState.Stolen -> callPolice() }b }b @Test fun spendingMoneyLikeNoTomorrow() {c }c
12. Test override fun processPayment(creditCard: String, amount: BigDecimal) {c when (creditCardTransactor.checkCreditCardState(creditCard)) {c CreditCardState.Gucci -> transact(creditCard, amount) CreditCardState.Stolen -> callPolice() }b }b @Test fun spendingMoneyLikeNoTomorrow() {c val transactor = mock<CreditCardTransactor>() val subject = CardPaymentProcessor(transactor) }c
13. Test override fun processPayment(creditCard: String, amount: BigDecimal) {c when (creditCardTransactor.checkCreditCardState(creditCard)) {c CreditCardState.Gucci -> transact(creditCard, amount) CreditCardState.Stolen -> callPolice() }b }b @Test fun spendingMoneyLikeNoTomorrow() {c val transactor = mock<CreditCardTransactor>() val subject = CardPaymentProcessor(transactor) whenever(transactor.checkCreditCardState("not-even-real")) .thenReturn(CreditCardState.Gucci) }c
14. Test override fun processPayment(creditCard: String, amount: BigDecimal) {c when (creditCardTransactor.checkCreditCardState(creditCard)) {c CreditCardState.Gucci -> transact(creditCard, amount) CreditCardState.Stolen -> callPolice() }b }b @Test fun spendingMoneyLikeNoTomorrow() {c val transactor = mock<CreditCardTransactor>() val subject = CardPaymentProcessor(transactor) whenever(transactor.checkCreditCardState("not-even-real")) .thenReturn(CreditCardState.Gucci) }c
15. Test private fun transact(creditCard: String, amount: BigDecimal) {c val transaction = creditCardTransactor.beginTransaction() val payment = creditCardTransactor.pay(transaction, creditCard, amount) if (payment.isOvercharge()) {c creditCardTransactor.rollBack(transaction) }c creditCardTransactor.competeTransaction(transaction) }c @Test fun spendingMoneyLikeNoTomorrow() {c val transactor = mock<CreditCardTransactor>() val subject = CardPaymentProcessor(transactor) whenever(transactor.checkCreditCardState("not-even-real")) .thenReturn(CreditCardState.Gucci) }c
16. Test private fun transact(creditCard: String, amount: BigDecimal) {c val transaction = creditCardTransactor.beginTransaction() val payment = creditCardTransactor.pay(transaction, creditCard, amount) if (payment.isOvercharge()) {c creditCardTransactor.rollBack(transaction) }c creditCardTransactor.competeTransaction(transaction) }c @Test fun spendingMoneyLikeNoTomorrow() {c val transactor = mock<CreditCardTransactor>() val subject = CardPaymentProcessor(transactor) whenever(transactor.checkCreditCardState("not-even-real")) .thenReturn(CreditCardState.Gucci) val transaction = mock<Transaction>() whenever(transactor.beginTransaction()).thenReturn(transaction) }c
17. Test private fun transact(creditCard: String, amount: BigDecimal) {c val transaction = creditCardTransactor.beginTransaction() val payment = creditCardTransactor.pay(transaction, creditCard, amount) if (payment.isOvercharge()) {c creditCardTransactor.rollBack(transaction) }c creditCardTransactor.competeTransaction(transaction) }c @Test fun spendingMoneyLikeNoTomorrow() {c val transactor = mock<CreditCardTransactor>() val subject = CardPaymentProcessor(transactor) whenever(transactor.checkCreditCardState("not-even-real")) .thenReturn(CreditCardState.Gucci) val transaction = mock<Transaction>() whenever(transactor.beginTransaction()).thenReturn(transaction) val payment = mock<Payment>() whenever(transactor.pay(any(), any(), any())).thenReturn(payment) }c
18. Test private fun transact(creditCard: String, amount: BigDecimal) {c val transaction = creditCardTransactor.beginTransaction() val payment = creditCardTransactor.pay(transaction, creditCard, amount) if (payment.isOvercharge()) {c creditCardTransactor.rollBack(transaction) }c creditCardTransactor.competeTransaction(transaction) }c @Test fun spendingMoneyLikeNoTomorrow() {c val transactor = mock<CreditCardTransactor>() val subject = CardPaymentProcessor(transactor) whenever(transactor.checkCreditCardState("not-even-real")) .thenReturn(CreditCardState.Gucci) val transaction = mock<Transaction>() whenever(transactor.beginTransaction()).thenReturn(transaction) val payment = mock<Payment>() whenever(transactor.pay(any(), any(), any())).thenReturn(payment) }c
19. Test private fun transact(creditCard: String, amount: BigDecimal) {c val transaction = creditCardTransactor.beginTransaction() val payment = creditCardTransactor.pay(transaction, creditCard, amount) if (payment.isOvercharge()) {c creditCardTransactor.rollBack(transaction) }c creditCardTransactor.competeTransaction(transaction) }c @Test fun spendingMoneyLikeNoTomorrow() {c val transactor = mock<CreditCardTransactor>() val subject = CardPaymentProcessor(transactor) whenever(transactor.checkCreditCardState("not-even-real")) .thenReturn(CreditCardState.Gucci) val transaction = mock<Transaction>() whenever(transactor.beginTransaction()).thenReturn(transaction) val payment = mock<Payment>() whenever(transactor.pay(any(), any(), any())).thenReturn(payment) }c
20. Test private fun transact(creditCard: String, amount: BigDecimal) {c val transaction = creditCardTransactor.beginTransaction() val payment = creditCardTransactor.pay(transaction, creditCard, amount) if (payment.isOvercharge()) {c creditCardTransactor.rollBack(transaction) }c creditCardTransactor.competeTransaction(transaction) }c @Test fun spendingMoneyLikeNoTomorrow() {c val transactor = mock<CreditCardTransactor>() val subject = CardPaymentProcessor(transactor) whenever(transactor.checkCreditCardState("not-even-real")) .thenReturn(CreditCardState.Gucci) val transaction = mock<Transaction>() whenever(transactor.beginTransaction()).thenReturn(transaction) val payment = mock<Payment>() whenever(payment.isOvercharge()).thenReturn(false) whenever(transactor.pay(any(), any(), any())).thenReturn(payment) }c
21. Test private fun transact(creditCard: String, amount: BigDecimal) {c …c creditCardTransactor.competeTransaction(transaction) }c @Test fun spendingMoneyLikeNoTomorrow() {c val transactor = mock<CreditCardTransactor>() val subject = CardPaymentProcessor(transactor) whenever(transactor.checkCreditCardState("not-even-real")) .thenReturn(CreditCardState.Gucci) val transaction = mock<Transaction>() whenever(transactor.beginTransaction()).thenReturn(transaction) val payment = mock<Payment>() whenever(payment.isOvercharge()).thenReturn(false) whenever(transactor.pay(any(), any(), any())).thenReturn(payment) subject.processPayment("not-even-real", BigDecimal.TEN) }c
22. Test private fun transact(creditCard: String, amount: BigDecimal) {c …c creditCardTransactor.competeTransaction(transaction) }c @Test fun spendingMoneyLikeNoTomorrow() {c val transactor = mock<CreditCardTransactor>() val subject = CardPaymentProcessor(transactor) whenever(transactor.checkCreditCardState("not-even-real")) .thenReturn(CreditCardState.Gucci) val transaction = mock<Transaction>() whenever(transactor.beginTransaction()).thenReturn(transaction) val payment = mock<Payment>() whenever(payment.isOvercharge()).thenReturn(false) whenever(transactor.pay(any(), any(), any())).thenReturn(payment) subject.processPayment("not-even-real", BigDecimal.TEN) verify(transactor).competeTransaction(transaction) }c
23. We win. Ez tests. Mocks are good
24. Something is missing :thinkingFace:
25. Test private fun transact(creditCard: String, amount: BigDecimal) {c … creditCardTransactor.competeTransaction(transaction) }c @Test fun spendingMoneyLikeNoTomorrow() {c val transactor = mock<CreditCardTransactor>() val subject = CardPaymentProcessor(transactor) whenever(transactor.checkCreditCardState("not-even-real")) .thenReturn(CreditCardState.Gucci) val transaction = mock<Transaction>() whenever(transactor.beginTransaction()).thenReturn(transaction) val payment = mock<Payment>() whenever(payment.isOvercharge()).thenReturn(false) whenever(transactor.pay(any(), any(), any())).thenReturn(payment) subject.processPayment("not-even-real", BigDecimal.TEN) verify(transactor).competeTransaction(transaction) }c
26. private fun transact(creditCard: String, amount: BigDecimal) {c val transaction = creditCardTransactor.beginTransaction() val payment = creditCardTransactor.pay(transaction, creditCard, amount) if (payment.isOvercharge()) {c creditCardTransactor.rollBack(transaction) }c creditCardTransactor.competeTransaction(transaction) }c 1 2 3
27. private fun transact(creditCard: String, amount: BigDecimal) {c val transaction = creditCardTransactor.beginTransaction() val payment = creditCardTransactor.pay(transaction, creditCard, amount) if (payment.isOvercharge()) {c creditCardTransactor.rollBack(transaction) }c creditCardTransactor.competeTransaction(transaction) }c 1 2 3
28. Final form
29. @Test fun spendingMoneyLikeNoTomorrow() {c val subject = CardPaymentProcessor(transactor) whenever(transactor.checkCreditCardState("not-even-real")) .thenReturn(CreditCardState.Gucci) val transaction = mock<Transaction>() whenever(transactor.beginTransaction()).thenReturn(transaction) val payment = mock<Payment>() whenever(payment.isOvercharge()).thenReturn(false) whenever(transactor.pay(any(), any(), any())).thenReturn(payment) val transactorInOrder = inOrder(transactor) subject.processPayment("not-even-real", BigDecimal.TEN) transactorInOrder.verify(transactor).beginTransaction() transactorInOrder.verify(transactor).pay( transaction, "not-even-real", BigDecimal.TEN ) transactorInOrder.verify(transactor).competeTransaction(transaction) transactorInOrder.verifyNoMoreInteractions() }cc
30. A few problems
31. A few problems • Implementation details are leaked into the test
32. @Test fun spendingMoneyLikeNoTomorrow() {c val transactor = mock<CreditCardTransactor>() val subject = CardPaymentProcessor(transactor) whenever(transactor.checkCreditCardState("not-even-real")) .thenReturn(CreditCardState.Gucci) val transaction = mock<Transaction>() whenever(transactor.beginTransaction()).thenReturn(transaction) val payment = mock<Payment>() whenever(payment.isOvercharge()).thenReturn(false) whenever(transactor.pay(any(), any(), any())).thenReturn(payment) val transactorInOrder = inOrder(transactor) subject.processPayment("not-even-real", BigDecimal.TEN) transactorInOrder.verify(transactor).beginTransaction() transactorInOrder.verify(transactor).pay( transaction, "not-even-real", BigDecimal.TEN ) transactorInOrder.verify(transactor).competeTransaction(transaction) transactorInOrder.verifyNoMoreInteractions() }cc
33. A few problems • Implementation details are leaked into the test
34. A few problems • Implementation details are leaked into the test • The test is unreadable
35. A few problems • Implementation details are leaked into the test • The test is unreadable • Refactoring is still very dangerous
36. Example interface CreditCardTransactor {c fun checkCreditCardState(creditCard: String): CreditCardState fun pay( transaction: Transaction, creditCard: String, dollars: BigDecimal ): Payment fun beginTransaction(): Transaction fun rollBack(transaction: Transaction) fun competeTransaction(transaction: Transaction) }cc
37. Example interface CreditCardTransactor {c fun checkCreditCardState(creditCard: String): CreditCardState fun inTransaction(doInTransaction: Transaction.() -> Unit) }c interface Transaction {c fun rollback() fun pay( creditCard: String, dollars: BigDecimal ): Payment }c
38. Example private fun transact(creditCard: String, amount: BigDecimal) {c val transaction = creditCardTransactor.beginTransaction() val payment = creditCardTransactor.pay(transaction, creditCard, amount) if (payment.isOvercharge()) {c creditCardTransactor.rollBack(transaction) }cc creditCardTransactor.competeTransaction(transaction) }cc
39. Example private fun transact(creditCard: String, amount: BigDecimal) {c creditCardTransactor.inTransaction {c val payment = pay(creditCard, amount) if (payment.isOverCharge()) {c rollback() }cc }z }cc
40. Let’s run our test :))))))
41. @Test fun spendingMoneyLikeNoTomorrow() {c val transactor = mock<CreditCardTransactor>() val subject = CardPaymentProcessor(transactor) whenever(transactor.checkCreditCardState("not-even-real")) .thenReturn(CreditCardState.Gucci) val transaction = mock<Transaction>() whenever(transactor.beginTransaction()).thenReturn(transaction) val payment = mock<Payment>() whenever(payment.isOvercharge()).thenReturn(false) whenever(transactor.pay(any(), any(), any())).thenReturn(payment) val transactorInOrder = inOrder(transactor) subject.processPayment("not-even-real", BigDecimal.TEN) transactorInOrder.verify(transactor).beginTransaction() transactorInOrder.verify(transactor).pay( transaction, "not-even-real", BigDecimal.TEN ) transactorInOrder.verify(transactor).competeTransaction(transaction) transactorInOrder.verifyNoMoreInteractions() }cc
42. • Implementation details are leaked into the test • The test is unreadable • Refactoring is still very dangerous A few problems
43. • Implementation details are leaked into the test • The test is unreadable • Refactoring is still very dangerous • Has this test provided value? A few problems
44. Is this revolutionary? Well, not quite.
47. Loaded gun • Keep the testing compact and readable • Avoid coding a tautology • Don’t mock everything! it’s an anti pattern • Don’t mock value objects! • Don’t mock a type you don’t own! • …and a few more. https://github.com/mockito/mockito/wiki/How-to-write-good-tests
48. Life without mocks
49. dependencies {c …c testImplementation 'junit:junit:4.12' testImplementation 'com.nhaarman.mockitokotlin2:mockito-kotlin:2.1.0' testImplementation 'org.jetbrains.kotlin:kotlin-test-junit:1.3.31' }c Life without mocks
50. dependencies {c …c testImplementation 'junit:junit:4.12' testImplementation 'org.jetbrains.kotlin:kotlin-test-junit:1.3.31' }c Life without mocks
51. @Test fun buyingThingsWithoutRegrets() {c }c Life without mocks
52. @Test fun buyingThingsWithoutRegrets() {c val transactor = FakeCreditCardTransactor() val subject = CardPaymentProcessor(transactor) }c Life without mocks
53. @Test fun buyingThingsWithoutRegrets() {c val transactor = FakeCreditCardTransactor() val subject = CardPaymentProcessor(transactor) val creditCardNumber = "very-real-much-money" subject.processPayment(creditCardNumber, BigDecimal.TEN) }c Life without mocks
54. @Test fun buyingThingsWithoutRegrets() {c val transactor = FakeCreditCardTransactor() val subject = CardPaymentProcessor(transactor) val creditCardNumber = "very-real-much-money" subject.processPayment(creditCardNumber, BigDecimal.TEN) assertEquals( actual = transactor.getLastPaymentAmount(creditCardNumber), expected = BigDecimal.TEN ) }c Life without mocks
55. @Test fun buyingThingsWithRegrets() {c val transactor = FakeCreditCardTransactor() val subject = CardPaymentProcessor(transactor) val creditCardNumber = "very-real-no-money" subject.processPayment(creditCardNumber, BigDecimal.TEN) assertEquals( actual = transactor.getLastPaymentAmount(creditCardNumber), expected = null ) }c Life without mocks
56. Life with fakes
57. • Functionality focused test Life with fakes
58. • Functionality focused test • Invocation and assertions, nothing else Life with fakes
59. • Functionality focused test • Invocation and assertions, nothing else • Refactoring is safe Life with fakes
60. • Functionality focused test • Invocation and assertions, nothing else • Refactoring is safe • Not only tests Life with fakes
61. What is the catch?
62. What is the catch? • Way more thought goes into the fake implementation
63. What is the catch? • Way more thought goes into the fake implementation • Complex fakes might have complex implementations
64. What is the catch? • Way more thought goes into the fake implementation • Complex fakes might have complex implementations • What else?
65. Literature used • Marcel Weiher “Why I don’t mock” https://news.ycombinator.com/item?id=7809402 • Martin Fowler “Mocks aren’t stubs” https://martinfowler.com/articles/ mocksArentStubs.html#TheDifferenceBetweenMocksAndStubs • Google ToT “Don’t overuse mocks” https://testing.googleblog.com/2013/05/testing-on-toilet-dont-overuse-mocks.html • Google ToT “Testing state vs testing interaction” https://testing.googleblog.com/2013/03/testing-on-toilet-testing-state-vs.html • Google ToT “Fake your way to better tests” https://testing.googleblog.com/2013/06/testing-on-toilet-fake-your-way- to.htmlhttps://testing.googleblog.com/2013/06/testing-on-toilet-fake-your-way-to.html • r/Androiddev “Do you unit test? If you do, do you use mocking libraries?”
 https://www.reddit.com/r/androiddev/comments/7l3wrd/android_devs_do_you_unit_test_if_you_do_do_you/ • Jake Wharton “Mockito is a loaded gun” https://twitter.com/jakewharton/status/1103836521327706113 • Eric Smith “Thats not yours” https://8thlight.com/blog/eric-smith/2011/10/27/thats-not-yours.html • Mockito “How to write good tests” https://github.com/mockito/mockito/wiki/How-to-write-good-tests • Uncle Bob “When to mock” https://blog.cleancoder.com/uncle-bob/2014/05/10/WhenToMock.html • Uncle Bob “The Little Mocker” https://blog.cleancoder.com/uncle-bob/2014/05/14/TheLittleMocker.html • Jesse Wilson “Value objects, Service Objects and Glue“ https://publicobject.com/2019/06/10/value-objects-service-objects-and- glue/
66. Fin