Test Piramidi, JUnit 5 ve Mockito

1
final class CardPaymentService {
2

3
    private static final Currency TRY = Currency.getInstance("TRY");
4

5
    private final FxRates fxRates;
6
    private final Ledger ledger;
7
    private final SmsSender sms;
8

9
    CardPaymentService(FxRates fxRates, Ledger ledger, SmsSender sms) {
10
        this.fxRates = fxRates;
11
        this.ledger = ledger;
12
        this.sms = sms;
13
    }
14

15
    // A foreign card payment is booked in TRY on the customer's account.
16
    Money pay(String accountNo, Money price) {
17
        BigDecimal rate = fxRates.sellRate(price.currency());   // TRY per unit of foreign currency
18
        Money charged = new Money(price.value().multiply(rate).setScale(2, RoundingMode.HALF_EVEN), TRY);
19
        ledger.debit(accountNo, charged);
20
        sms.paymentNotice(accountNo, charged);
21
        return charged;
22
    }
23
}

1
// A fake: a real, working ledger that keeps balances in a map.
2
final class InMemoryLedger implements Ledger {
3

4
    private final Map<String, BigDecimal> balances = new HashMap<>();
5

6
    InMemoryLedger withBalance(String accountNo, String amount) {
7
        balances.put(accountNo, new BigDecimal(amount));
8
        return this;
9
    }
10

11
    @Override
12
    public void debit(String accountNo, Money amount) {
13
        BigDecimal balance = balances.getOrDefault(accountNo, BigDecimal.ZERO);
14
        if (balance.compareTo(amount.value()) < 0) {
15
            throw new InsufficientFundsException(accountNo);
16
        }
17
        balances.put(accountNo, balance.subtract(amount.value()));
18
    }
19

20
    BigDecimal balanceOf(String accountNo) {
21
        return balances.get(accountNo);
22
    }
23
}

1
@ExtendWith(MockitoExtension.class)
2
class CardPaymentServiceTest {
3

4
    private static final String ACCOUNT = "TR330006100519786457841326";
5
    private static final Currency EUR = Currency.getInstance("EUR");
6

7
    @Mock
8
    FxRates fxRates;   // a stub: it only supplies a rate
9

10
    @Mock
11
    SmsSender sms;     // a mock: the notice is part of the contract
12

13
    private final InMemoryLedger ledger = new InMemoryLedger().withBalance(ACCOUNT, "5000.00");
14
    private CardPaymentService service;
15

16
    @BeforeEach
17
    void setUp() {
18
        when(fxRates.sellRate(EUR)).thenReturn(new BigDecimal("37.4520"));
19
        service = new CardPaymentService(fxRates, ledger, sms);
20
    }
21

22
    @Test
23
    void chargesTheConvertedAmountAndNotifiesTheCustomer() {
24
        Money charged = service.pay(ACCOUNT, new Money(new BigDecimal("40.00"), EUR));
25

26
        assertThat(charged.value()).isEqualByComparingTo("1498.08");   // 40.00 x 37.4520
27
        assertThat(ledger.balanceOf(ACCOUNT)).isEqualByComparingTo("3501.92");
28
        verify(sms).paymentNotice(ACCOUNT, charged);
29
    }
30

31
    @Test
32
    void sendsNoNoticeWhenTheBalanceIsShort() {
33
        assertThatThrownBy(() -> service.pay(ACCOUNT, new Money(new BigDecimal("200.00"), EUR)))
34
                .isInstanceOf(InsufficientFundsException.class);
35
        verifyNoInteractions(sms);
36
    }
37
}

1
// It could also be written like this. It passes today; watch the first refactor.
2
@ExtendWith(MockitoExtension.class)
3
class CardPaymentServiceStrictTest {
4

5
    private static final Currency EUR = Currency.getInstance("EUR");
6
    private static final Currency TRY = Currency.getInstance("TRY");
7

8
    @Mock FxRates fxRates;
9
    @Mock Ledger ledger;
10
    @Mock SmsSender sms;
11

12
    @Test
13
    void chargesTheConvertedAmount() {
14
        when(fxRates.sellRate(EUR)).thenReturn(new BigDecimal("37.4520"));
15
        new CardPaymentService(fxRates, ledger, sms).pay("TR330006100519786457841326",
16
                new Money(new BigDecimal("40.00"), EUR));
17

18
        // Every call, in this exact order, and nothing else. Read the balance first for a
19
        // clearer error, and this goes red although the same amount is charged.
20
        InOrder order = inOrder(fxRates, ledger, sms);
21
        order.verify(fxRates).sellRate(EUR);
22
        order.verify(ledger).debit(any(), eq(new Money(new BigDecimal("1498.08"), TRY)));
23
        order.verify(sms).paymentNotice(any(), any());
24
        verifyNoMoreInteractions(fxRates, ledger, sms);
25
    }
26
}