package com.assu.study.clean_me.account.domain;

import static com.assu.study.clean_me.common.AccountTestData.defaultAccount;
import static com.assu.study.clean_me.common.ActivityTestData.defaultActivity;
import static org.assertj.core.api.Assertions.assertThat;
import static org.junit.jupiter.api.Assertions.*;

import org.junit.jupiter.api.Test;

class AccountTest {

  @Test
  void calculatesBalance() {
    Account.AccountId accountId = new Account.AccountId(1L);
    Account account =
        defaultAccount()
            .withAccountId(accountId)
            .withBaselineBalance(Money.of(555L))
            .withActivityWindow(
                new ActivityWindow(
                    defaultActivity()
                        .withTargetAccount(accountId)
                        .withMoney(Money.of(999L))
                        .build(),
                    defaultActivity().withTargetAccount(accountId).withMoney(Money.of(1L)).build()))
            .build();

    Money balance = account.calculateBalance();
    assertThat(balance).isEqualTo(Money.of(1555L));
  }

  @Test
  void withdrawalSucceeds() {
    Account.AccountId accountId = new Account.AccountId(1L);
    // 특정 상태의 Account 를 인스턴스화함
    Account account =
        defaultAccount()
            .withAccountId(accountId)
            .withBaselineBalance(Money.of(555L))
            .withActivityWindow(
                new ActivityWindow(
                    defaultActivity()
                        .withTargetAccount(accountId)
                        .withMoney(Money.of(999L))
                        .build(),
                    defaultActivity().withTargetAccount(accountId).withMoney(Money.of(1L)).build()))
            .build();

    boolean success = account.withdraw(Money.of(555L), new Account.AccountId(998L));

    assertThat(success).isTrue();
    assertThat(account.getActivityWindow().getActivities()).hasSize(3);
    assertThat(account.calculateBalance()).isEqualTo(Money.of(1000L));
  }

  @Test
  void withdrawalFailure() {
    Account.AccountId accountId = new Account.AccountId(1L);
    Account account =
        defaultAccount()
            .withAccountId(accountId)
            .withBaselineBalance(Money.of(555L))
            .withActivityWindow(
                new ActivityWindow(
                    defaultActivity()
                        .withTargetAccount(accountId)
                        .withMoney(Money.of(999L))
                        .build(),
                    defaultActivity().withTargetAccount(accountId).withMoney(Money.of(1L)).build()))
            .build();

    boolean success = account.withdraw(Money.of(1556L), new Account.AccountId(111L));

    assertThat(success).isFalse();
    assertThat(account.getActivityWindow().getActivities()).hasSize(2);
    assertThat(account.calculateBalance()).isEqualTo(Money.of(1555L));
  }

  @Test
  void depositSuccess() {
    Account.AccountId accountId = new Account.AccountId(1L);
    Account account =
        defaultAccount()
            .withAccountId(accountId)
            .withBaselineBalance(Money.of(555L))
            .withActivityWindow(
                new ActivityWindow(
                    defaultActivity()
                        .withTargetAccount(accountId)
                        .withMoney(Money.of(999L))
                        .build(),
                    defaultActivity().withTargetAccount(accountId).withMoney(Money.of(1L)).build()))
            .build();

    boolean success = account.deposit(Money.of(445L), new Account.AccountId(111L));

    assertThat(success).isTrue();
    assertThat(account.getActivityWindow().getActivities()).hasSize(3);
    assertThat(account.calculateBalance()).isEqualTo(Money.of(2000L));
  }
}

package com.assu.study.clean_me.common;

import com.assu.study.clean_me.account.domain.Account;
import com.assu.study.clean_me.account.domain.ActivityWindow;
import com.assu.study.clean_me.account.domain.Money;

public class AccountTestData {
  public static AccountBuilder defaultAccount() {
    return new AccountBuilder()
        .withAccountId(new Account.AccountId(42L))
        .withBaselineBalance(Money.of(999L))
        .withActivityWindow(
            new ActivityWindow(
                ActivityTestData.defaultActivity().build(),
                ActivityTestData.defaultActivity().build()));
  }

  public static class AccountBuilder {
    private Account.AccountId accountId;
    private Money baselineBalance;
    private ActivityWindow activityWindow;

    public AccountBuilder withAccountId(Account.AccountId accountId) {
      this.accountId = accountId;
      return this;
    }

    public AccountBuilder withBaselineBalance(Money baselineBalance) {
      this.baselineBalance = baselineBalance;
      return this;
    }

    public AccountBuilder withActivityWindow(ActivityWindow activityWindow) {
      this.activityWindow = activityWindow;
      return this;
    }

    public Account build() {
      return Account.withId(this.accountId, this.baselineBalance, this.activityWindow);
    }
  }
}

package com.assu.study.clean_me.common;

import com.assu.study.clean_me.account.domain.Account;
import com.assu.study.clean_me.account.domain.Activity;
import com.assu.study.clean_me.account.domain.Money;
import java.time.LocalDateTime;

public class ActivityTestData {

  public static ActivityBuilder defaultActivity() {
    return new ActivityBuilder()
        .withOwnerAccount(new Account.AccountId(42L))
        .withSourceAccount(new Account.AccountId(42L))
        .withTargetAccount(new Account.AccountId(41L))
        .withTimestamp(LocalDateTime.now())
        .withMoney(Money.of(999L));
  }

  public static class ActivityBuilder {
    private Activity.ActivityId id;
    private Account.AccountId ownerAccountId;
    private Account.AccountId sourceAccountId;
    private Account.AccountId targetAccountId;
    private LocalDateTime timestamp;
    private Money money;

    public ActivityBuilder withId(Activity.ActivityId id) {
      this.id = id;
      return this;
    }

    public ActivityBuilder withOwnerAccount(Account.AccountId accountId) {
      this.ownerAccountId = accountId;
      return this;
    }

    public ActivityBuilder withSourceAccount(Account.AccountId accountId) {
      this.sourceAccountId = accountId;
      return this;
    }

    public ActivityBuilder withTargetAccount(Account.AccountId accountId) {
      this.targetAccountId = accountId;
      return this;
    }

    public ActivityBuilder withTimestamp(LocalDateTime timestamp) {
      this.timestamp = timestamp;
      return this;
    }

    public ActivityBuilder withMoney(Money money) {
      this.money = money;
      return this;
    }

    public Activity build() {
      return new Activity(
          this.id,
          this.ownerAccountId,
          this.sourceAccountId,
          this.targetAccountId,
          this.timestamp,
          this.money);
    }
  }
}

package com.assu.study.cleanme.account.application.service;

import static org.assertj.core.api.Assertions.assertThat;
import static org.junit.jupiter.api.Assertions.*;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.eq;
import static org.mockito.BDDMockito.given;
import static org.mockito.BDDMockito.then;
import static org.mockito.Mockito.times;

import com.assu.study.cleanme.account.application.port.in.SendMoneyCommand;
import com.assu.study.cleanme.account.application.port.out.AccountLock;
import com.assu.study.cleanme.account.application.port.out.LoadAccountPort;
import com.assu.study.cleanme.account.application.port.out.UpdateAccountStatePort;
import com.assu.study.cleanme.account.domain.Account;
import com.assu.study.cleanme.account.domain.Money;
import java.time.LocalDateTime;
import java.util.List;
import java.util.Optional;
import java.util.stream.Collectors;
import org.junit.jupiter.api.Test;
import org.mockito.ArgumentCaptor;
import org.mockito.Mockito;

class SendMoneyServiceTest {
  private final LoadAccountPort loadAccountPort = Mockito.mock(LoadAccountPort.class);
  private final AccountLock accountLock = Mockito.mock(AccountLock.class);
  private final UpdateAccountStatePort updateAccountStatePort =
          Mockito.mock(UpdateAccountStatePort.class);
  private final SendMoneyService sendMoneyService =
          new SendMoneyService(
                  loadAccountPort, accountLock, updateAccountStatePort, moneyTransferProperties());

  @Test
  void givenWithdrawalFails_thenOnlySourceAccountIdLockedAndReleased() {
    // Given (테스트 케이스가 동작하기 위해 갖춰져야 하는 선행 조건 준비)
    Account.AccountId sourceAccountId = new Account.AccountId(41L);
    Account sourceAccount = givenAnAccountWithId(sourceAccountId);

    Account.AccountId targetAccountId = new Account.AccountId(42L);
    Account targetAccount = givenAnAccountWithId(targetAccountId);

    givenWithdrawalWillFail(sourceAccount);
    givenDepositWillSucceed(targetAccount);

    SendMoneyCommand command =
            new SendMoneyCommand(sourceAccountId, targetAccountId, Money.of(300L));

    // When (테스트하고자 하는 대상 코드 실행)
    // 유스케이스 실행
    boolean success = sendMoneyService.sendMoney(command);

    // Then (대상 코드의 수행 결과 판단)
    // 트랜잭션이 성공적이었는지 확인
    assertThat(success).isFalse();

    // sourceAccount 에 대해 lock, release 메서드가 실행되었는지 확인
    then(accountLock).should().lockAccount(eq(sourceAccountId));
    then(accountLock).should().releaseAccount(eq(sourceAccountId));

    // 인출에 실패하면 targetAccount 는 한번도 잠기지 않음
    then(accountLock).should(times(0)).lockAccount(eq(targetAccountId));
  }

  @Test
  void transactionSucceeds() {
    // Given (테스트 케이스가 동작하기 위해 갖춰져야 하는 선행 조건 준비)
    Account sourceAccount = givenSourceAccount();
    Account targetAccount = givenTargetAccount();

    givenWithdrawalWillSucceed(sourceAccount);
    givenDepositWillSucceed(targetAccount);

    Money money = Money.of(500L);

    // 유스케이스의 입력으로 사용할 command
    SendMoneyCommand command =
            new SendMoneyCommand(sourceAccount.getId().get(), targetAccount.getId().get(), money);

    // When (테스트하고자 하는 대상 코드 실행)
    // 유스케이스 실행
    boolean success = sendMoneyService.sendMoney(command);

    // Then (대상 코드의 수행 결과 판단)
    // 트랜잭션이 성공적이었는지 확인
    assertThat(success).isTrue();

    Account.AccountId sourceAccountId = sourceAccount.getId().get();
    Account.AccountId targetAccountId = targetAccount.getId().get();

    // AccountLock 에 대해 특정 메서드가 호출되었는지 확인
    then(accountLock).should().lockAccount(eq(sourceAccountId));
    then(sourceAccount).should().withdraw(eq(money), eq(targetAccountId));
    then(accountLock).should().releaseAccount(sourceAccountId);

    then(accountLock).should().lockAccount(eq(targetAccountId));
    then(targetAccount).should().deposit(eq(money), eq(sourceAccountId));
    then(accountLock).should().releaseAccount(targetAccountId);

    thenAccountsHaveBeenUpdated(sourceAccountId, targetAccountId);
  }

  private void givenWithdrawalWillFail(Account account) {
    // mock 객체 생성
    given(account.withdraw(any(Money.class), any(Account.AccountId.class))).willReturn(false);
  }

  private void thenAccountsHaveBeenUpdated(Account.AccountId... accountIds) {
    ArgumentCaptor<Account> accountCaptor = ArgumentCaptor.forClass(Account.class);

    then(updateAccountStatePort)
            .should(times(accountIds.length))
            .updateActivities(accountCaptor.capture());

    List<Account.AccountId> updatedAccountIds =
            accountCaptor.getAllValues().stream()
                    .map(Account::getId)
                    .map(Optional::get)
                    .collect(Collectors.toList());

    for (Account.AccountId accountId : accountIds) {
      assertThat(updatedAccountIds).contains(accountId);
    }
  }

  private Account givenSourceAccount() {
    return givenAnAccountWithId(new Account.AccountId(41L));
  }

  private Account givenAnAccountWithId(Account.AccountId id) {
    Account account = Mockito.mock(Account.class);

    // account.getId() 호출 시 id 리턴
    given(account.getId()).willReturn(Optional.of(id));

    // loadAccountPort.loadAccount() 호출 시 account 리턴
    given(loadAccountPort.loadAccount(eq(account.getId().get()), any(LocalDateTime.class)))
            .willReturn(account);

    return account;
  }

  private void givenWithdrawalWillSucceed(Account account) {
    // 어떤 금액과 아이디가 들어와도 true 리턴
    given(account.withdraw(any(Money.class), any(Account.AccountId.class))).willReturn(true);
  }

  private void givenDepositWillSucceed(Account account) {
    // 어떤 금액과 아이디가 들어와도 true 리턴
    given(account.deposit(any(Money.class), any(Account.AccountId.class))).willReturn(true);
  }

  private Account givenTargetAccount() {
    return givenAnAccountWithId(new Account.AccountId(42L));
  }

  private MoneyTransferProperties moneyTransferProperties() {
    return new MoneyTransferProperties(Money.of(Long.MAX_VALUE));
  }
}

package com.assu.study.cleanme.account.adapter.in.web;

import static org.mockito.ArgumentMatchers.eq;
import static org.mockito.BDDMockito.then;
import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.post;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status;

import com.assu.study.cleanme.account.application.port.in.SendMoneyCommand;
import com.assu.study.cleanme.account.application.port.in.SendMoneyUseCase;
import com.assu.study.cleanme.account.domain.Account;
import com.assu.study.cleanme.account.domain.Money;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.autoconfigure.web.servlet.WebMvcTest;
import org.springframework.boot.test.mock.mockito.MockBean;
import org.springframework.http.MediaType;
import org.springframework.test.web.servlet.MockMvc;

// @WebMvcTest 의 controllers 속성을 사용하지 않으면 애플리케이션에 포함된 모든 컨트롤러 클래스 스캔
@WebMvcTest(controllers = SendMoneyController.class)
class SendMoneyControllerTest {
  @Autowired private MockMvc mockMvc;
  @MockBean private SendMoneyUseCase sendMoneyUseCase;

  @Test
  void testSendMoney() throws Exception {
    mockMvc
        .perform(
            post("/accounts/send/{sourceAccountId}/{targetAccountId}/{amount}", 41L, 42L, 500)
                .header("Content-Type", MediaType.APPLICATION_JSON))
        .andExpect(status().isOk());

    SendMoneyCommand command =
        new SendMoneyCommand(
            new Account.AccountId(41L), new Account.AccountId(42L), Money.of(500L));

    then(sendMoneyUseCase).should().sendMoney(eq(command));
  }
}

package com.assu.study.cleanme.account.adapter.out.persistence;

import static com.assu.study.cleanme.common.AccountTestData.defaultAccount;
import static com.assu.study.cleanme.common.ActivityTestData.defaultActivity;
import static org.assertj.core.api.Assertions.assertThat;

import com.assu.study.cleanme.account.domain.Account;
import com.assu.study.cleanme.account.domain.ActivityWindow;
import com.assu.study.cleanme.account.domain.Money;
import java.time.LocalDateTime;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.autoconfigure.orm.jpa.DataJpaTest;
import org.springframework.context.annotation.Import;
import org.springframework.test.context.jdbc.Sql;

@DataJpaTest
@Import({AccountPersistenceAdapter.class, AccountMapper.class})
class AccountPersistenceAdapterTest {
  @Autowired private AccountPersistenceAdapter accountPersistenceAdapter;

  @Autowired private ActivityRepository activityRepository;

  @DisplayName("계좌 조회")
  @Test
  @Sql("AccountPersistenceAdapterTest.sql") // DB 를 특정 상태로 만듦
  void loadAccount() {
    // When
    // 어댑터를 이용하여 계좌 조회
    Account account =
            accountPersistenceAdapter.loadAccount(
                    new Account.AccountId(1L), LocalDateTime.of(2023, 8, 10, 0, 0));

    // Then
    // Sql 스크립트에서 설정한 상태값을 가지고 있는지 검증
    assertThat(account.getActivityWindow().getActivities()).hasSize(2);
    assertThat(account.calculateBalance()).isEqualTo(Money.of(500));
  }

  @DisplayName("새로운 계좌 활동 DB 에 저장")
  @Test
  void updateActivities() {
    // Given
    // 새로운 계좌 활동을 가진 Account 를 만듦
    Account account =
            defaultAccount()
                    .withBaselineBalance(Money.of(555L))
                    .withActivityWindow(
                            new ActivityWindow(defaultActivity().withId(null).withMoney(Money.of(1L)).build()))
                    .build();

    // When
    // 위에서 만든 Account 를 어댑터로 전달
    accountPersistenceAdapter.updateActivities(account);

    // Then
    // DB 에 잘 저장되었는지 확인
    assertThat(activityRepository.count()).isEqualTo(1);

    ActivityJpaEntity savedActivity = activityRepository.findAll().get(0);
    assertThat(savedActivity.getAmount()).isEqualTo(1L);
  }
}

package com.assu.study.cleanme;

import static org.assertj.core.api.BDDAssertions.then;

import com.assu.study.cleanme.account.application.port.out.LoadAccountPort;
import com.assu.study.cleanme.account.domain.Account;
import com.assu.study.cleanme.account.domain.Money;
import java.time.LocalDateTime;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.boot.test.web.client.TestRestTemplate;
import org.springframework.http.*;
import org.springframework.test.context.jdbc.Sql;

@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT)
public class SendMoneySystemTest {
  @Autowired private TestRestTemplate testRestTemplate;
  @Autowired private LoadAccountPort loadAccountPort;

  @DisplayName("송금하기 시스템 테스트")
  @Test
  @Sql("SendMoneySystemTest.sql")
  void sendMoney() {
    // Given (테스트 케이스가 동작하기 위해 갖춰져야 하는 선행 조건 준비)
    Money initialSourceBalance = sourceAccount().calculateBalance();
    Money initialTargetBalance = targetAccount().calculateBalance();

    // When (테스트하고자 하는 대상 코드 실행)
    ResponseEntity response =
        whenSendMoney(sourceAccountId(), targetAccountId(), transferredAmount());

    // Then (대상 코드의 수행 결과 판단)
    then(response.getStatusCode()).isEqualTo(HttpStatus.OK);

    then(sourceAccount().calculateBalance())
        .isEqualTo(initialSourceBalance.minus(transferredAmount()));

    then(targetAccount().calculateBalance())
        .isEqualTo(initialTargetBalance.plus(transferredAmount()));
  }

  // 여기서부터 헬퍼 메서드들 (DSL)
  private Account sourceAccount() {
    return loadAccount(sourceAccountId());
  }

  private Account targetAccount() {
    return loadAccount(targetAccountId());
  }

  private Account loadAccount(Account.AccountId accountId) {
    return loadAccountPort.loadAccount(accountId, LocalDateTime.now());
  }

  private Account.AccountId sourceAccountId() {
    return new Account.AccountId(1L);
  }

  private Account.AccountId targetAccountId() {
    return new Account.AccountId(2L);
  }

  private Money transferredAmount() {
    return Money.of(500L);
  }

  private ResponseEntity whenSendMoney(
      Account.AccountId sourceAccountId, Account.AccountId targetAccountId, Money amount) {
    HttpHeaders headers = new HttpHeaders();
    headers.add("Content-Type", MediaType.APPLICATION_JSON_VALUE);
    HttpEntity<Void> request = new HttpEntity<>(null, headers);

    return testRestTemplate.exchange(
        "/accounts/send/{sourceAccountId}/{targetAccountId}/{amount}",
        HttpMethod.POST,
        request,
        Object.class,
        sourceAccountId.getValue(),
        targetAccountId.getValue(),
        amount.getAmount());
  }
}