4. 테스트

토비 왈 : 테스트를 만들지 않을 거면 스프링을 도대체 뭐하러 쓰는 거죠?

1. 자동으로 수행되는 테스트(Automated Test)

수동 테스트의 한계

1. 프린트 된 메세지를 수동으로 확인하는 방법은 불편하다.

2. 사용자 웹 UI까지 개발한 뒤에 확인하는 방법은 테스트가 실패했을 때 확인할 코드가 많다.

   1. 가장 작은 단위로 기능을 쪼개서 테스트 하는 것이 기능적 결함이 발생할 가능성이 적다.

3. 테스트 할 대상이 많아질수록 검증하는데 시간이 많이 걸리고 부정확하다.

   1. 결국 사람이 직접 하는 일이기 때문에, 구멍이 생길 수 밖에 없다.

자동으로 수행되는 테스트 (작은 크기의)

개발자가 만드는 테스트

• 개발한 코드에 대한 검증 기능을 코드로 작성한다.

• 자동으로 테스트를 수행하고 결과를 확인한다.

• 테스팅 프레임워크를 활용한다. (ex, JUnit)

• 테스트 작성과 실행도 개발 과정의 일부이다.

2. JUnit 테스트 작성

JUnit 5

• @Test 테스트 메소드 : 테스트 메서드에 붙이는 에너테이션

• @BeforeEach 테스트 : 각각의 @Test 메서드가 실행 되기 전마다 @BeforeEach 메서드가 실행된다.

• 테스트마다 새로운 인스턴스가 만들어진다.

  • 각각의 테스트가 다른 테스트에 영향을 받지 않도록 하기 위해서 테스트마다 각각 새로운 인스턴스를 생성한다.

  • 매번 SortTest 인스턴스가 새롭게 생성된다.

package spring.hellospring;

import java.util.Arrays;
import java.util.Collections;
import java.util.List;

public class Sort {
    public List<String> sortByLength(List<String> list){
        list.sort((o1, o2) -> o1.length() - o2.length());
        return list;
    }
}

package spring.hellospring;

import org.assertj.core.api.Assertions;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import spring.hellospring.Sort;

import java.util.Arrays;
import java.util.List;

public class SortTest {

    Sort sort;

    @BeforeEach
    void beforeEach() {
        // 준비 (given)
        sort = new Sort();
        System.out.println(this);   // 매번 SortTest 인스턴스가 새롭게 생성된다.
    }

    @Test
    void sort(){
        // 실행 (when)
        List<String> list = sort.sortByLength(Arrays.asList("aa", "b"));

        // 검증 (then)
        Assertions.assertThat(list).isEqualTo(List.of("b", "aa"));
    }

    @Test
    void sort3Items(){
        List<String> list = sort.sortByLength(Arrays.asList("aa", "ccc", "b"));

        Assertions.assertThat(list).isEqualTo(List.of("b", "aa", "ccc"));
    }

    @Test
    void sortAlreadySorted(){
        List<String> list = sort.sortByLength(Arrays.asList("b", "aa", "ccc"));

        Assertions.assertThat(list).isEqualTo(List.of("b", "aa", "ccc"));
    }
}

3. PaymentService 테스트

우리가 만들어 낸 PaymentService 를 테스트 해보자.

PaymentService 의 요구사항에 맞추어서 테스트를 해보자.

• 환율정보 가져오기

• 원화 환산 금액 계산

• 원화 환산 금액 유효시간 계산

package spring.hellospring.payment;

import org.assertj.core.api.Assertions;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;
import spring.hellospring.exrate.WebApiExRateProvider;

import java.io.IOException;
import java.math.BigDecimal;
import java.time.LocalDateTime;

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

class PaymentServiceTest {

    @Test
    @DisplayName("prepare 메서드가 요구사항 3가지를 잘 충족했는지 검증")
    void prepare() throws IOException {
        PaymentService paymentService = new PaymentService(new WebApiExRateProvider());

        Payment payment = paymentService.prepare(1L, "USD", BigDecimal.TEN);

        // 환율정보 가져오기    
        assertThat(payment.getExRate()).isNotNull();

        // 원화환산금액 계산
        assertThat(payment.getConvertedAmount())
                .isEqualTo(payment.getExRate().multiply(payment.getForeignCurrencyAmount()));

        // 원화환산금액 유효시간 계산
        assertThat(payment.getValidUntil()).isAfter(LocalDateTime.now());
        assertThat(payment.getValidUntil()).isBefore(LocalDateTime.now().plusMinutes(30));

    }
}

4. 테스트의 구성 요소

그렇다면 우리가 만든 PaymentService 에 대한 테스트가 모두 완료된 것일까?

문제점

1. 우리가 제어할 수 없는 외부 시스템에 문제가 생긴다면?

   1. 환율 정보를 가져오는 외부 API 서버의 문제가 생겨버리면 테스트를 할 수 없다.

2. ExRateProvider 가 제공하는 환율 값으로 계산한 것인가?

   1. prepare 메서드만 보고서 ExRateProvider 가 제공하는 메서드인지 확신할 수 없다.

3. 환율 유효 시간 계산은 정확한 것인가?

일반적으로 테스트는 다음의 구성 요소를 가지고 있다.

• 테스트 : PaymentServiceTest

• 테스트 대상 : PaymentService

• 협력자 : WebApiExRateProvider

  • 협력자의 경우 개발자가 관여할 수 없는 외부 서버에 의존하는 경우가 있는데, 이 경우 서버 상황에 따라 각각 다른 결과를 얻게 될 수 있다.

  • 현재 상황에서 PaymentService 를 테스트하고 싶은거지, WebApiExRateProvider 를 테스트하고 싶지는 않다.

  • 이런 경우를 위해서 고정된 결과를 리턴해주는 Stub or Mock 객체를 만들어 사용할 수 있다.

  • 이 구조가 만들어지기 위해서는 테스트 대상이 특정 인터페이스(ExRateProvider)를 상속받은 클래스를 사용하는 구조가 되어야 한다.

Stub vs Mock

• Stub

  • 테스트 실행을 위한 "미리 준비된 값/상태" 제공

  • 상태 검증 (SUT의 최종 상태나 반환 값)

• Mock

  • 객체 간의 "올바른 상호작용/호출 순서 및 횟수" 검증

  • 행위 검증 (SUT가 의존 객체의 메소드를 올바르게 호출했는지)

결국, Mock과 Stub은 다른 것이며, 어떤 테스트 더블을 사용할지는 테스트의 목적과 무엇을 검증하고 싶은지에 따라 결정해야 한다. 상태를 검증하고 싶다면 스텁을, 행위를 검증하고 싶다면 목을 사용하는 것이 일반적인 접근 방식이다.

5. 테스트와 DI

외부와 의존성이 없는 ExRateProviderStub 클래스를 만들고 해당 클래스 인스턴스를 테스트에서 사용하도록 변경하였다.

이로 인해 외부와 의존성이 없는 테스트를 만들 수 있게 되었다.

수동 DI 를 이용하는 테스트

테스트용 수동 협력자(Colloborator) / 의존 오브젝트를 테스트 대상에 직접 주입하고 테스트

스프링이 원하는 방향

스프링은 기본적으로 DI 를 사용하면서, 외부와 종속적이지 않은 테스트를 만들기를 원한다.

아래 코드는 이러한 방향을 잘 따른 코드라고 볼 수 있다.

package spring.hellospring.payment;

import java.io.IOException;
import java.math.BigDecimal;

public class ExRateProviderStub implements ExRateProvider {

    private BigDecimal exRate;

    public ExRateProviderStub(BigDecimal exRate) {
        this.exRate = exRate;
    }

    public BigDecimal getExRate() {
        return exRate;
    }

    public void setExRate(BigDecimal exRate) {
        this.exRate = exRate;
    }

    @Override
    public BigDecimal getExRate(String currency) throws IOException {
        return exRate;
    }
}

package spring.hellospring.payment;

import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;

import java.io.IOException;
import java.math.BigDecimal;

import static java.math.BigDecimal.*;
import static org.assertj.core.api.Assertions.*;

class PaymentServiceTest {

    @Test
    @DisplayName("prepare 메서드가 요구사항 3가지를 잘 충족했는지 검증")
    void convertedAmount() throws IOException {
        testAmount(valueOf(500), valueOf(5_000));
        testAmount(valueOf(1_000), valueOf(10_000));
        testAmount(valueOf(3_000), valueOf(30_000));

        // 원화환산금액 유효시간 계산
//        assertThat(payment.getValidUntil()).isAfter(LocalDateTime.now());
//        assertThat(payment.getValidUntil()).isBefore(LocalDateTime.now().plusMinutes(30));

    }

    private static void testAmount(BigDecimal exRate, BigDecimal convertedAmount) throws IOException {
        PaymentService paymentService = new PaymentService(new ExRateProviderStub(exRate));

        Payment payment = paymentService.prepare(1L, "USD", TEN);

        assertThat(payment.getExRate()).isEqualByComparingTo(exRate);
        assertThat(payment.getConvertedAmount()).isEqualByComparingTo(convertedAmount);
    }
}

스프링 DI 를 이용하는 테스트

테스트용 협력자(Collborator) / 의존 오브젝트를 스프링의 구성 정보를 이용해서 지정하고, 컨테이너로부터 테스트 대상을 가져와 테스트

알아야 하는 어노테이션

• @ExtendWith(SpringExtension.class) : JUnit 이 스프링의 기능을 사용한다는 어노테이션, 기계적으로 사용하자.

• @ContextConfiguration : 테스트가 실행될 때, 해당 어노테이션으로 지정된 클래스를 바탕으로 스프링 컨테이너에 빈을 등록해준다.

• @Autowired : 테스트가 실행될 때 해당 타입과 매칭되는 인스턴스가 스프링 컨테이너 내에 있다면 해당 인스턴스를 DI 해준다.

스프링 컨테이너를 사용한 테스트

가장 먼저 ObjectFactory 와 같은 테스트 용도로 구성정보를 설정하는 TestObjectFactory 를 만들고 사용하자.

package spring.hellospring;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import spring.hellospring.payment.ExRateProvider;
import spring.hellospring.payment.ExRateProviderStub;
import spring.hellospring.payment.PaymentService;

import static java.math.BigDecimal.*;

@Configuration
public class TestObjectFactory {

    @Bean
    public PaymentService paymentService() {
        return new PaymentService(exRateProvider());
    }

    @Bean
    public ExRateProvider exRateProvider() {
        return new ExRateProviderStub(valueOf(1_000));
    }
}

package spring.hellospring.payment;

import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit.jupiter.SpringExtension;
import spring.hellospring.TestObjectFactory;

import java.io.IOException;

import static java.math.BigDecimal.TEN;
import static java.math.BigDecimal.valueOf;
import static org.assertj.core.api.Assertions.assertThat;

@ExtendWith(SpringExtension.class)
@ContextConfiguration(classes = TestObjectFactory.class)
class PaymentServiceSpringTest {

    @Autowired
    PaymentService paymentService;

    @Test
    void convertedAmount() throws IOException {
        Payment payment = paymentService.prepare(10L, "USD", TEN);

        assertThat(payment.getExRate()).isEqualByComparingTo(valueOf(1_000));
        assertThat(payment.getConvertedAmount()).isEqualByComparingTo(valueOf(10_000));

        // 원화 환산 금액 유효시간 계산
//        assertThat(payment.getVaildUntil()).isAfter(LocalDateTime.now());
//        assertThat(payment.getVaildUntil()).isBefore(LocalDateTime.now().plusMinutes(30));
    }
}

개선된 방식

ExRateProviderStub 빈을 직접적으로 가져와 내부 값(환율 정책)을 바꾸어가면서 사용할 수도 있다. (테스트 용도로 사용하는 클래스이기 때문에 Setter 를 사용해 값을 변경하며 테스트를 할 수 있다)

package spring.hellospring.payment;

import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit.jupiter.SpringExtension;
import spring.hellospring.TestObjectFactory;

import java.io.IOException;

import static java.math.BigDecimal.TEN;
import static java.math.BigDecimal.valueOf;
import static org.assertj.core.api.Assertions.assertThat;

@ExtendWith(SpringExtension.class)
@ContextConfiguration(classes = TestObjectFactory.class)
class PaymentServiceSpringTest {

    @Autowired PaymentService paymentService;
    @Autowired ExRateProviderStub exRateProviderStub;

    @Test
    void convertedAmount() throws IOException {

        // exRate : 1000
        Payment payment1 = paymentService.prepare(1L, "USD", TEN);

        assertThat(payment1.getExRate()).isEqualByComparingTo(valueOf(1_000));
        assertThat(payment1.getConvertedAmount()).isEqualTo(valueOf(10_000));

        // exRate : 500
        exRateProviderStub.setExRate(valueOf(500));
        Payment payment2 = paymentService.prepare(1L, "USD", TEN);

        assertThat(payment2.getExRate()).isEqualByComparingTo(valueOf(500));
        assertThat(payment2.getConvertedAmount()).isEqualTo(valueOf(5_000));

        // 원화환산금액 유효시간 계산
//        assertThat(payment.getValidUntil()).isAfter(LocalDateTime.now());
//        assertThat(payment.getValidUntil()).isBefore(LocalDateTime.now().plusMinutes(30));

    }
}

6. 학습 테스트

언제 학습 테스트를 할까?

직접 만들지 않은 코드, 라이브러리, 레거시 시스템에 대한 테스트가 필요할 때 학습 테스트를 한다.

• 학습 테스트의 목적은 사용할 API, 프레임워크의 기능을 테스트로 작성하고 실행해보면서 사용방법을 바르게 이해했는지 확인할 수 있다.

• 외부 기술, 서비스가 버전이 올라갔을 때, 이전과 동일하게 동작하는지 확인할 수도 있다.

학습 테스트 예제 (Clock)

package spring.hellospring.learningtest;

import org.junit.jupiter.api.Test;

import java.time.Clock;
import java.time.Instant;
import java.time.LocalDateTime;
import java.time.ZoneId;

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

public class ClockTest {

    // Clock 을 이용해서 LocalDateTime.now?
    @Test
    void Clock(){
        Clock clock = Clock.systemDefaultZone();

        LocalDateTime dt1 = LocalDateTime.now(clock);
        LocalDateTime dt2 = LocalDateTime.now(clock);

        assertThat(dt2).isAfter(dt1);
    }

    // Clock 을 Test 에서 사용할 때 내가 원하는 시간을 지정해서 현재 시간을 가져오게 할 수 있는가?
    @Test
    void fixedClock() {
        Clock clock = Clock.fixed(Instant.now(), ZoneId.systemDefault());

        LocalDateTime dt1 = LocalDateTime.now(clock);
        LocalDateTime dt2 = LocalDateTime.now(clock);

        LocalDateTime dt3 = LocalDateTime.now(clock).plusHours(1);

        assertThat(dt1).isEqualTo(dt2);
        assertThat(dt3).isEqualTo(dt1.plusHours(1));
    }
}

7. Clock 을 이용한 시간 테스트

• 스프링 컨테이너에 Clock 을 이용해 FixedClock 을 만들어 PaymentService 를 테스트해보자.

테스트를 위한 사전작업

• 테스트를 위해서 우리가 사용하던 ObjectFactory 를 도메인에 맞는 이름(PaymentConfig) 로 바꾸어 보자.

• 그리고 PaymentService 에서 Clock 을 사용할 수 있도록 코드를 수정해주자.

package spring.hellospring.payment;

import org.springframework.stereotype.Component;

import java.io.IOException;
import java.math.BigDecimal;
import java.time.Clock;
import java.time.LocalDateTime;

@Component
public class PaymentService {
    private final ExRateProvider exRateProvider;
    private final Clock clock;

    public PaymentService(ExRateProvider exRateProvider, Clock clock) {
        this.exRateProvider = exRateProvider;
        this.clock = clock;
    }

    public Payment prepare(Long orderId, String currency, BigDecimal foreignCurrencyAmount) throws IOException {
        BigDecimal exRate = exRateProvider.getExRate(currency);                 // 1. 환율을 가져오고
        BigDecimal convertedAmount = foreignCurrencyAmount.multiply(exRate);    // 2. 원화 환산 금액을 계산한다.
        LocalDateTime validUntil = LocalDateTime.now(clock).plusMinutes(30);    // 3. 환율 유효시간을 계산한다.

        return new Payment(orderId, currency, foreignCurrencyAmount, exRate, convertedAmount, validUntil);
    }
}

package spring.hellospring;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import spring.hellospring.exrate.CachedExRateProvider;
import spring.hellospring.exrate.WebApiExRateProvider;
import spring.hellospring.payment.ExRateProvider;
import spring.hellospring.payment.PaymentService;

import java.time.Clock;

@Configuration
public class PaymentConfig {

    @Bean
    public PaymentService paymentService() {
        return new PaymentService(exRateProvider(), clock());
    }

    @Bean
    public ExRateProvider exRateProvider() {
        return new WebApiExRateProvider();
    }

    @Bean
    public Clock clock(){ return Clock.systemDefaultZone(); }
}

수동 DI 를 이용하는 테스트

• 수동 DI 테스트에서는 직접 의존성을 넣어주어야 한다.

package spring.hellospring.payment;

import org.assertj.core.api.Assertions;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;

import java.io.IOException;
import java.math.BigDecimal;
import java.time.Clock;
import java.time.Instant;
import java.time.LocalDateTime;
import java.time.ZoneId;

import static java.math.BigDecimal.*;
import static org.assertj.core.api.Assertions.*;

class PaymentServiceTest {
    Clock clock;

    @BeforeEach
    void beforeEach() {
        this.clock = Clock.fixed(Instant.now(), ZoneId.systemDefault());
    }

    @Test
    @DisplayName("prepare 메서드가 요구사항 3가지를 잘 충족했는지 검증")
    void convertedAmount() throws IOException {
        testAmount(valueOf(500), valueOf(5_000), this.clock);
        testAmount(valueOf(1_000), valueOf(10_000), this.clock);
        testAmount(valueOf(3_000), valueOf(30_000), this.clock);
    }

    @Test
    @DisplayName("valid until 이 prepare() 30분 뒤로 설정되었는가?")
    void validUntil() throws IOException {
        PaymentService paymentService = new PaymentService(new ExRateProviderStub(valueOf(1_000)), this.clock);

        Payment payment = paymentService.prepare(1L, "USD", TEN);

        LocalDateTime now = LocalDateTime.now(this.clock);
        LocalDateTime expectedValidUntil = now.plusMinutes(30);

        Assertions.assertThat(payment.getValidUntil()).isEqualTo(expectedValidUntil);
    }

    private static void testAmount(BigDecimal exRate, BigDecimal convertedAmount, Clock clock) throws IOException {
        PaymentService paymentService = new PaymentService(new ExRateProviderStub(exRate), clock);

        Payment payment = paymentService.prepare(1L, "USD", TEN);

        // 환율정보 가져오기
        assertThat(payment.getExRate()).isEqualByComparingTo(exRate);
        // 원화환산금액 계산
        assertThat(payment.getConvertedAmount()).isEqualTo(convertedAmount);
    }

}

스프링 DI 를 이용하는 테스트

• 스프링 DI 테스트에서는 PaymentConfig 에서 이미 DI 설정이 이루어졌기 때문에, @Autowired 를 통해 직접 인스턴스를 가져와 사용하면된다.

  • 스프링을 사용하는 테스트는 DI 부분을 고려하지 않기 때문에, 코드의 변경이 크지 않다.

package spring.hellospring.payment;

import org.assertj.core.api.Assertions;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit.jupiter.SpringExtension;
import spring.hellospring.TestPaymentConfig;

import java.io.IOException;
import java.time.Clock;
import java.time.LocalDateTime;

import static java.math.BigDecimal.TEN;
import static java.math.BigDecimal.valueOf;
import static org.assertj.core.api.Assertions.assertThat;

@ExtendWith(SpringExtension.class)
@ContextConfiguration(classes = TestPaymentConfig.class)
class PaymentServiceSpringTest {

    @Autowired PaymentService paymentService;
    @Autowired Clock clock;
    @Autowired ExRateProviderStub exRateProviderStub;

    @Test
    @DisplayName("prepare 메서드가 요구사항 3가지를 잘 충족했는지 검증")
    void convertedAmount() throws IOException {

        // exRate : 1000
        Payment payment1 = paymentService.prepare(1L, "USD", TEN);

        assertThat(payment1.getExRate()).isEqualByComparingTo(valueOf(1_000));
        assertThat(payment1.getConvertedAmount()).isEqualTo(valueOf(10_000));

        // exRate : 500
        exRateProviderStub.setExRate(valueOf(500));
        Payment payment2 = paymentService.prepare(1L, "USD", TEN);

        assertThat(payment2.getExRate()).isEqualByComparingTo(valueOf(500));
        assertThat(payment2.getConvertedAmount()).isEqualTo(valueOf(5_000));

    }

    @Test
    @DisplayName("valid until 이 prepare() 30분 뒤로 설정되었는가?")
    void validUntil() throws IOException {
        PaymentService paymentService = new PaymentService(new ExRateProviderStub(valueOf(1_000)), this.clock);

        Payment payment = paymentService.prepare(1L, "USD", TEN);

        LocalDateTime now = LocalDateTime.now(this.clock);
        LocalDateTime expectedValidUntil = now.plusMinutes(30);

        Assertions.assertThat(payment.getValidUntil()).isEqualTo(expectedValidUntil);
    }
}

8. 도메인 오브젝트 테스트

토비왈 : 테스트할 시간이 없다고 하더라도, 도메인 오브젝트 테스트는 꼭 하길 바람

도메인 모델 아키텍처 패턴이란?

도메인 로직, 비지니스 로직을 어디에 둘 것인가를 결정하는 패턴

아키텍처 패턴

1. 트랜잭션 스크립트 - 서비스 메서드(PaymentService.prepare)

   1. 현재 코드에서 사용하고 있는 방식

   2. service 로직에서 모든 서비스 로직을 담당한다.

2. 도메인 모델 - 도메인 모델 오브젝트(Payment)

   1. 도메인 모델 오브젝트에서 도메인 모델이(Payment) 서비스 로직을 가지고 있어야 한다.

      1. 현재 코드에서 Payment 는 값만 가지고 있다.

      2. 그렇기에 현재 코드는 도메인 모델 방식의 코드가 아니다.

   2. 도메인 모델 방식을 사용했을 때, 테스트에서 얻는 이점이 크다.

      1. 도메인 모델 안에 비지니스 로직이 모두 들어 있다면, 외부 의존성과 관계 없이 독립적으로 테스트 가능하다.

      2. 응집도가 높아지기 때문에, 테스트 대상이 되는 도메인의 경계를 명확하게 할 수 있다.

도메인 모델 아키텍처 패턴 예제

기존에는 PaymentService.prepare() 메서드 내부에서 모든 비지니스 로직을 담당하고 있었다.

1. 환율을 가져오고,

2. 원화 환산 금액을 계산하고,

3. 환율 유효시간을 계산하다.

하지만 도메인 오브젝트 모델에서는, 도메인 모델(Payment)이 서비스 로직을 가지고 있어야 한다.

팩토리 메서드 패턴(Payment.createPrepared())을 사용해, 외부 오브젝트에 영향을 받는 로직을 제외하고는 도메인 모델로 서비스 로직을 옮기자.

• 외부 영향을 받는 로직 : 환율을 가져오는 로직

팩토리 메서드 패턴을 사용한 예제

package spring.hellospringv5.payment;

import org.springframework.stereotype.Component;

import java.io.IOException;
import java.math.BigDecimal;
import java.time.Clock;
import java.time.LocalDateTime;

@Component
public class PaymentService {
    private final ExRateProvider exRateProvider;
    private final Clock clock;

    public PaymentService(ExRateProvider exRateProvider, Clock clock) {
        this.exRateProvider = exRateProvider;
        this.clock = clock;
    }

    public Payment prepare(Long orderId, String currency, BigDecimal foreignCurrencyAmount) throws IOException {
        BigDecimal exRate = exRateProvider.getExRate(currency);    // 1. 환율을 가져오고

        return Payment.createPrepared(orderId, currency, foreignCurrencyAmount, exRate, 
                                    LocalDateTime.now(clock));
    }
}

package spring.hellospringv5.payment;

import java.math.BigDecimal;
import java.time.LocalDateTime;

public class Payment {
    private Long orderId;
    private String currency;
    private BigDecimal foreignCurrencyAmount;
    private BigDecimal exRate;
    private BigDecimal convertedAmount;
    private LocalDateTime validUntil;

    public Payment(Long orderId, String currency, BigDecimal foreignCurrencyAmount, BigDecimal exRate, BigDecimal convertedAmount, LocalDateTime validUntil) {
        this.orderId = orderId;
        this.currency = currency;
        this.foreignCurrencyAmount = foreignCurrencyAmount;
        this.exRate = exRate;
        this.convertedAmount = convertedAmount;
        this.validUntil = validUntil;
    }

    public static Payment createPrepared(Long orderId, String currency, BigDecimal foreignCurrencyAmount, BigDecimal exRate,
                                         LocalDateTime now) {
        BigDecimal convertedAmount = foreignCurrencyAmount.multiply(exRate);    // 2. 원화 환산 금액을 계산한다.
        LocalDateTime validUntil = now.plusMinutes(30);                         // 3. 환율 유효시간을 계산한다.

        return new Payment(orderId, currency, foreignCurrencyAmount, exRate, convertedAmount, validUntil);
    }

    public Long getOrderId() {
        return orderId;
    }

    public String getCurrency() {
        return currency;
    }

    public BigDecimal getForeignCurrencyAmount() {
        return foreignCurrencyAmount;
    }

    public BigDecimal getExRate() {
        return exRate;
    }

    public BigDecimal getConvertedAmount() {
        return convertedAmount;
    }

    public LocalDateTime getValidUntil() {
        return validUntil;
    }

    @Override
    public String toString() {
        return "Payment{" +
                "orderId=" + orderId +
                ", currency='" + currency + '\'' +
                ", foreignCurrencyAmount=" + foreignCurrencyAmount +
                ", exRate=" + exRate +
                ", convertedAmount=" + convertedAmount +
                ", validUntil=" + validUntil +
                '}';
    }
}

package spring.hellospringv5.payment;

import org.assertj.core.api.Assertions;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;

import java.math.BigDecimal;
import java.time.*;
import java.time.temporal.ChronoUnit;

import static java.math.BigDecimal.valueOf;

public class PaymentTest {

    @Test
    void createPrepared() {
        Payment payment = Payment.createPrepared(
                1L, "USD", TEN, valueOf(1_000), LocalDateTime.now(clock)
        );

        assertThat(payment.getConvertedAmount()).isEqualByComparingTo(valueOf(10_000));
        assertThat(payment.getVaildUntil()).isEqualTo(LocalDateTime.now(clock).plusMinutes(30));
    }
}

• 테스트가 정상적으로 실행된다. Payment 안으로 Payment 와 관련된 로직을 넣어 PaymentService 내에서는 정말 Payment 객체를 사용하기만 했다.

Payment 유효시간을 검증하는 로직도 Payment 안에 추가해 테스트를 더 간편하게 작성해보자.

package spring.hellospring.payment;

import java.math.BigDecimal;
import java.time.Clock;
import java.time.LocalDateTime;

public class Payment {
    private Long orderId;
    private String currency;
    private BigDecimal foreignCurrencyAmount;
    private BigDecimal exRate;
    private BigDecimal convertedAmount;
    private LocalDateTime vaildUntil;

    public Payment(Long orderId, String currency, BigDecimal foreignCurrencyAmount, BigDecimal exRate, BigDecimal convertedAmount, LocalDateTime vaildUntil) {
        this.orderId = orderId;
        this.currency = currency;
        this.foreignCurrencyAmount = foreignCurrencyAmount;
        this.exRate = exRate;
        this.convertedAmount = convertedAmount;
        this.vaildUntil = vaildUntil;
    }

    public static Payment createPrepared(Long orderId, String currency, BigDecimal foreignCurrencyAmount, BigDecimal exRate,
                                         LocalDateTime now) {
        BigDecimal convertedAmount = foreignCurrencyAmount.multiply(exRate);
        LocalDateTime valiedUntil = now.plusMinutes(30);

        return new Payment(orderId, currency, foreignCurrencyAmount, exRate, convertedAmount, valiedUntil);
    }

    public boolean isValid(Clock clock) {
        return LocalDateTime.now(clock).isBefore(this.vaildUntil);
    }

    public Long getOrderId() {
        return orderId;
    }

    public String getCurrency() {
        return currency;
    }

    public BigDecimal getForeignCurrencyAmount() {
        return foreignCurrencyAmount;
    }

    public BigDecimal getExRate() {
        return exRate;
    }

    public BigDecimal getConvertedAmount() {
        return convertedAmount;
    }

    public LocalDateTime getVaildUntil() {
        return vaildUntil;
    }

    @Override
    public String toString() {
        return "Payment{" +
                "orderId=" + orderId +
                ", currency='" + currency + '\'' +
                ", foreignCurrencyAmount=" + foreignCurrencyAmount +
                ", exRate=" + exRate +
                ", convertedAmount=" + convertedAmount +
                ", vaildUntil=" + vaildUntil +
                '}';
    }
}

package spring.hellospring.payment;

import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;

import java.time.*;
import java.time.temporal.ChronoUnit;

import static java.math.BigDecimal.*;
import static org.assertj.core.api.Assertions.*;

public class PaymentTest {
    Clock clock;

    @BeforeEach
    void setUp() {
        this.clock = Clock.fixed(Instant.now(), ZoneId.systemDefault());
    }


    @Test
    void createPrepared() {
        Payment payment = Payment.createPrepared(
                1L, "USD", TEN, valueOf(1_000), LocalDateTime.now(clock)
        );

        assertThat(payment.getConvertedAmount()).isEqualByComparingTo(valueOf(10_000));
        assertThat(payment.getVaildUntil()).isEqualTo(LocalDateTime.now(clock).plusMinutes(30));
    }

    @Test
    void isValid() {
        Payment payment = Payment.createPrepared(
                1L, "USD", TEN, valueOf(1_000), LocalDateTime.now(clock)
        );

        assertThat(payment.isValid(clock)).isTrue();
        assertThat(payment.isValid(Clock.offset(clock, Duration.of(30, ChronoUnit.MINUTES)))).isFalse();
    }
}

• isValid() 메서드를 추가해 Payment 응집도를 강화했다.

• 이런식으로 도메인 객체를 강화하면 PaymentService 와 같은 서비스 로직에서 도메인 객체에 대한 결합도가 줄어든다.

도메인 모델 아키텍처 패턴을 왜 사용하는가?

• 객체 지향을 이야기 할 때, 좋은 객체 지향 코드는 다음과 같다고 한다.

결합도가 낮고, 응집도가 높은 코드가 좋은 코드이다.

• 도메인 모델 아키텍처 패턴을 적용하기 전 코드를 생각해보면, 요구사항이 복잡해지고, 추가적인 클래스를 만드는 상황이 생겨난다면 PaymentService 클래스에 변화가 생겨나고, 결합도는 높아질 것이다.

• 이를 해결하기 위해서, 각 도메인의 기능들은 해당 메서드로 옮겨서, 결합도를 낮추고, 응집도를 높이는 설계를 할 필요가 있다.

• 하지만, 비용이 많이 드는 것은 사실이다.

• 때문에, 작은 부분부터 도메인 모델을 적용해보자!