👨‍💻 API 개발부터 Postman 테스트까지! (feat. 프론트 개발자가 백엔드를 처음 맡아보니...)

hidihyeonee·2025년 3월 6일

API IntelliJ Java Spring boot postman 데이터베이스 백엔드 신한DS 금융SW 아카데미 4기 웹

2025.03.06 작성

OS : Window
개발환경: IntelliJ IDEA
개발언어: Java
프레임워크: Spring Boot

🔥 2차 프로젝트 시작과 역할

2월 24일부터 신한DS 금융SW 아카데미 4기 2차 프로젝트가 시작됐다.
이번 프로젝트에서 팀 리더를 맡아 팀을 이끌고 있고, 나름 잘 해나가고 있다고 생각 중...🙂

기존에는 앱 프론트엔드 개발을 주로 담당했지만, 이번엔 백엔드까지 직접 개발하게 되면서 풀스택 개발자로 성장하는 과정을 겪고 있다.

뿐만 아니라, 디자인까지 맡게 되어 UI/UX 디자인 역량도 함께 키우는 중.
~~하지만 너무 피곤해서 미쳐버리겠음!!~~

백엔드를 처음 배우면서 다시 코린이로 돌아간 기분이지만, 먼 훗날엔 므찐 개발자가 되어 있을 테니 걱정 없다. 😎

내가 맡게 된 백엔드 API는 다음과 같음

1) Domain : Account / Method : POST / URI: api/account/set-ratio / CRUD : UPDATE / Description : 증권계좌에 이체될 비율을 설정하는 기능 / Response : x
2) Domain : Account / Method : POST / URI: api/account/collect-interest / CRUD : UPDATE / Description : 이자 받기 기능 / Response : 유저의 잔액정보를 리턴
3) Domain : Account / Method : GET / URI: api/account/get-interest / CRUD : READ / Description : 이자정보를 가져온다 / Response : 유저가 받을 이자를 리턴
4) Domain : Account / Method : GET / URI: api/account/histotry / CRUD : READ / Description : 유저 계좌의 히스토리 정보를 가져온다 / Response : 유저의 파킹통장 히스토리 정보

개발 순서는 다음과 같다

DB 테이블 확인 및 JPA Entity 작성
- 기존 AccountEntity에 이체 비율 (investor_ratio)와 이자 정보(interest, interest_ratio) 추가
- 계좌 히스토리를 저장할 AccountHistoryEntity 추가
DTO (Data Transfer Object) 작성
- 클라이언트와 데이터를 주고받기 위한 DTO 만들기
Repository (JPA 인터페이스) 작성
- DB와 연결되는 AccountRepository, AccountHistoryRepository 생성
Service (비즈니스 로직) 구현
- set-ratio, collect-interest, get-interest, history 기능 구현
Controller (API 요청 처리) 구현
- 클라이언트 요청을 처리할 AccountController 작성
테스트 데이터 (더미 데이터) 삽입
- DB에 샘플 데이터 추가
JPA 테스트 코드 작성
- 기능이 정상 작동하는지 확인
Postman으로 API 테스트
- 필수는 아니지만, 기획자나 프론트엔드 개발자와 의사소통을 하고자 한다면 Postman으로 API 테스트를 하고 문서화해서 전달해주면 협업하기 좋음
- 방식은 팀 내에서 자유롭게 정해서 하면 됨
- 팀 내에서 각자 테스트하고 구글 시트에 정리하기로 결정
- 이전 '모잉'이라는 팀에서 앱 프론트 개발자로 활동했을 때, 백엔드 개발자 친구들이 전달해준 문서가 아주 좋았던 기억이 있어 공유함.
  http://13.209.196.123/docs/api.html#Overview-Response

1. DB 테이블 확인 및 JPA Entity 작성

AccountEntity

package org.team4.sol_server.domain.account.entity;

import jakarta.persistence.*;
import lombok.*;

import java.math.BigInteger;

@Entity
@Getter
@Setter
@NoArgsConstructor
@AllArgsConstructor
@Builder
@Table(name = "account")
public class AccountEntity extends BaseEntity {

//        @ManyToOne
//        @JoinColumn(name = "user_idx", nullable = false)
//        private UserEntity user;

        @Id
        @Column(name = "account_no", nullable = false, unique = true)
        private String accountNumber;

        // 임시
        @Column(name = "user_idx", nullable = false)
        private int userIdx;

        @Column(name = "balance", nullable = false)
        private Long balance;

        @Column(name = "investor_ratio", nullable = false)
        private int investorRatio;  // 이체 비율

        @Column(name = "interest", nullable = false)
        private int interest;  // 이자 금액

        @Column(name = "interest_ratio", nullable = false)
        private double interestRatio;  // 이자율
}

이체 비율 (investor_ratio)와 이자 정보(interest, interest_ratio) 추가

AccountHistoryEntity

package org.team4.sol_server.domain.account.entity;

import jakarta.persistence.*;
import lombok.*;

@Entity
@Getter
@Setter
@NoArgsConstructor
@AllArgsConstructor
@Builder
@Table(name = "account_history")
public class AccountHistoryEntity extends BaseEntity {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    @Column(name = "account_his_idx")
    private int id;

    @ManyToOne
    @JoinColumn(name = "account_no", nullable = false)
    private AccountEntity account;

//    @ManyToOne
//    @JoinColumn(name = "user_idx", nullable = false)
//    private UserEntity user;

    // 임시
    @Column(name = "user_idx", nullable = false)
    private int userIdx;

    @Column(name = "display_name", nullable = false)
    private String displayName;

    @Column(name = "pre_balance", nullable = false)
    private int preBalance;

}

계좌 히스토리를 저장할 AccountHistoryEntity

2. DTO (Data Transfer Object) 작성

package org.team4.sol_server.domain.account.dto;

import lombok.*;

import java.math.BigInteger;

@Data
@ToString
@Builder
@AllArgsConstructor
@NoArgsConstructor
public class AccountDTO {

    private String accountNumber;
    private Long balance;
}

근데 개발 완료하고 의문점이 생김...

DTO는 꼭 필요한가?

그래서 강사님께 호다닥 달려가서 여쭤봤다!

강사님왈 : 사실 DTO? 안 만들어도 되긴 합니다...

예를 들어, 아래 setTransferRatio()와 collectInterest() 두 개의 API를 비교해보자.

// 증권 계좌 이체 비율 설정
    @PostMapping("/set-ratio")
    // accountNumber --> 계좌 번호 받음, ratio --> 이체 비율(%) 받음
    public ResponseEntity<String> setTransferRatio(@RequestBody TransferRatioDTO requestDTO) {
        accountService.setTransferRatio(requestDTO.getAccountNumber(), requestDTO.getRatio()); // 투자 비율 업데이트
        return ResponseEntity.ok("증권 계좌 이체 비율 설정: " + requestDTO.getRatio());
    }

// 이자 받기
    @PostMapping("/collect-interest")
    public ResponseEntity<AccountDTO> collectInterest(@RequestParam String accountNumber) {
        AccountDTO updatedAccount = accountService.collectInterest(accountNumber); // 투자 비율을 기준으로 이자 계산 및 계좌 잔액 증가 함수
        return ResponseEntity.ok(updatedAccount);
    }

이 둘의 차이점이 있다.

setTransferRatio()에서는 DTO(TransferRatioDTO)를 사용해서 데이터를 넘긴다.

collectInterest()에서는 @RequestParam을 직접 사용한다.

근데 나 같은 경우에 실제로 TransferRatioDTO를 보면

package org.team4.sol_server.domain.account.dto;

import lombok.*;

@Data
@Builder
@AllArgsConstructor
@NoArgsConstructor
public class TransferRatioDTO {
    private String accountNumber;
    private int ratio;
}

이렇게 변수가 2~3개 정도밖에 없는데...
굳이 DTO를 만드는 게 필요할까?라는 생각이 들어 이렇게 작성하게 된 것이다.

그래서 강사님한테 여쭤본 결과...

결론

PostMapping의 경우 @RequestParam과 @RequestBody(DTO) 모두 가능.
팀 내 코드 컨벤션을 정해서 사용하면 됨.
예를 들어, 5개 이상이면 DTO를 만들어서 사용하자! 등.
DTO의 장점: 코드의 재사용성과 유지보수가 좋고, 협업할 때 가독성이 높아짐.
DTO가 불필요한 경우: 데이터가 단순한 경우 (2~3개 이하).

아무튼 DTO는 꼭 존재할 필요가 없다는 사실이다.

데이터가 단순한 경우 안 써도 문제 없음.

코드의 재사용성이나 유지보수? 측면에서는 존재하면 좋을 것 같긴 하다만...
다른 사람과 협업할 때 DTO가 있으면 파악이 훨씬 빠르게 되니까(가독성) 그런 부분에서도 좋긴 하다만...

개인적인 생각으로는 5개 이상이 아니라면 그냥 DTO 만들지 않고 @RequestParam을 써서 사용하는 게 나을 것 같다.

추가적으로 여기서 8.Postman으로 API 테스트 내용을 덧붙이자면,

테스트를 할 때 @RequestParam형식은

사진과 같이 Params에 값을 임의로 넣어주고 요청하면 Body로 200 결과를 얻을 수 있고

@RequestBody TransferRatioDTO requestDTO 형식은

이렇게 Body로 raw 값을 작성해서 요청하면 사진과 같이 결과를 얻을 수 있다.
(Body > raw JSON 형식으로 값을 보내야 한다.)

아직 백린이라 이런 것도 서서히 알아가는 중...

3. Repository (JPA 인터페이스) 작성

AccountRepository

package org.team4.sol_server.domain.account.repository;

import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.stereotype.Repository;
import org.team4.sol_server.domain.account.entity.AccountEntity;

import java.util.Optional;

public interface AccountRepository extends JpaRepository<AccountEntity, Long> {
    Optional<AccountEntity> findByAccountNumber(String accountNumber);

}

AccountHistoryRepository

package org.team4.sol_server.domain.account.repository;

import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.stereotype.Repository;
import org.team4.sol_server.domain.account.entity.AccountHistoryEntity;

import java.util.List;

@Repository
public interface AccountHistoryRepository extends JpaRepository<AccountHistoryEntity, Integer> {
    // 특정 계좌의 거래 내역 조회
    List<AccountHistoryEntity> findByAccountAccountNumber(String accountNumber);
}

DB와 연결되는 AccountRepository, AccountHistoryRepository 생성

4. Service (비즈니스 로직) 구현

package org.team4.sol_server.domain.account.service;

import lombok.RequiredArgsConstructor;

import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.team4.sol_server.domain.account.dto.AccountDTO;
import org.team4.sol_server.domain.account.entity.AccountEntity;
import org.team4.sol_server.domain.account.entity.AccountHistoryEntity;
import org.team4.sol_server.domain.account.repository.AccountHistoryRepository;
import org.team4.sol_server.domain.account.repository.AccountRepository;

import java.util.List;
import java.util.Optional;

@Service
@RequiredArgsConstructor
public class AccountService {
    // 데이터베이스에서 계좌 조회, 입금, 출금, 이체, 이체 비율 설정, 이자 계산 등을 처리
    private final AccountRepository accountRepository;
    private final AccountHistoryRepository accountHistoryRepository;

    public Optional<AccountEntity> getAccountByNumber(String accountNumber) {
        return accountRepository.findByAccountNumber(accountNumber);
    }

    @Transactional
    public boolean transfer(String fromAccountNumber, String toAccountNumber, Long amount) {
        Optional<AccountEntity> fromAccountOpt = accountRepository.findByAccountNumber(fromAccountNumber); // 출금 계좌
        Optional<AccountEntity> toAccountOpt = accountRepository.findByAccountNumber(toAccountNumber); // 입금 계좌

        if (fromAccountOpt.isPresent() && toAccountOpt.isPresent()) {
            AccountEntity fromAccount = fromAccountOpt.get();
            AccountEntity toAccount = toAccountOpt.get();

            if (fromAccount.getBalance() >= amount) {
                fromAccount.setBalance(fromAccount.getBalance() - amount);
                toAccount.setBalance(toAccount.getBalance() + amount);
                accountRepository.save(fromAccount);
                accountRepository.save(toAccount);
                return true;
            }
        }
        return false;
    }

    @Transactional
    public boolean deposit(String accountNumber, Long amount) {
        Optional<AccountEntity> accountOpt = accountRepository.findByAccountNumber(accountNumber);

        if (accountOpt.isPresent() && amount > 0) {
            AccountEntity account = accountOpt.get();

            account.setBalance(account.getBalance() + amount);  //  입금 로직
            accountRepository.save(account);
            return true;
        }
        return false;
    }

    // 파킹 통장 투자 비율 설정
    @Transactional
    public void setTransferRatio(String accountNumber, int ratio) {
        Optional<AccountEntity> accountOpt = accountRepository.findByAccountNumber(accountNumber);
        accountOpt.ifPresent(account -> {
            account.setInvestorRatio(ratio);
            accountRepository.save(account);
        });
    }

    // 파킹 통장 투자 비율 조회
    @Transactional
    public Integer getTransferRatio(String accountNumber) {
        Optional<AccountEntity> accountOpt = accountRepository.findByAccountNumber(accountNumber);
        return accountOpt.map(AccountEntity::getInvestorRatio).orElse(0);
    }

    // collectInterest() --> 투자 비율을 기준으로 이자 계산 및 계좌 잔액 증가 함수
    @Transactional
    public AccountDTO collectInterest(String accountNumber) {
        Optional<AccountEntity> accountOpt = accountRepository.findByAccountNumber(accountNumber);
        if (accountOpt.isPresent()) {
            AccountEntity account = accountOpt.get();
            // 이자 계산 = 잔액 * (이자율/100.0)
            int interest = (int) (account.getBalance() * (account.getInterestRatio() / 100.0));
            account.setInterest(interest);
            account.setBalance(account.getBalance() + interest);
            accountRepository.save(account);

            return AccountDTO.builder()
                    .accountNumber(account.getAccountNumber())
                    .balance(account.getBalance())
                    .build();
        }
        return null;
    }

    // 받을 이자 조회
    public int getInterest(String accountNumber) {
        Optional<AccountEntity> accountOpt = accountRepository.findByAccountNumber(accountNumber);
        return accountOpt.map(AccountEntity::getInterest).orElse(0);
    }

    // 거래 내역 조회
    @Transactional(readOnly = true)
    public List<AccountHistoryEntity> getAccountHistory(String accountNumber) {
        return accountHistoryRepository.findByAccountAccountNumber(accountNumber);
    }

}

set-ratio, collect-interest, get-interest, history 기능 구현

5. Controller (API 요청 처리) 구현

package org.team4.sol_server.domain.account.controller;

import lombok.RequiredArgsConstructor;
import org.springframework.http.ResponseEntity;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.*;
import org.team4.sol_server.domain.account.dto.AccountDTO;
import org.team4.sol_server.domain.account.dto.DepositRequestDTO;
import org.team4.sol_server.domain.account.dto.TransferRatioDTO;
import org.team4.sol_server.domain.account.dto.TransferRequestDTO;
import org.team4.sol_server.domain.account.entity.AccountEntity;
import org.team4.sol_server.domain.account.entity.AccountHistoryEntity;
import org.team4.sol_server.domain.account.repository.AccountRepository;
import org.team4.sol_server.domain.account.service.AccountService;

import java.util.List;
import java.util.Optional;

/*
파일명 : AccountController.java
생성자 : JDeok
날 짜  : 2025.03.05
시 간  : 오후 02:14
기 능  : 계좌페이지
Params :
Return :
변경사항
     - 2025.03.05 : JDeok(최초작성)
*/
@RestController
@RequestMapping("api/account")
@RequiredArgsConstructor
@CrossOrigin(origins = "http://localhost:3000")
public class AccountController {

    private final AccountService accountService;
    private final AccountRepository accountRepository;

    // 계좌 조회 페이지
    @GetMapping("/balance")
    public ResponseEntity<AccountDTO> getAccount(@RequestParam String accountNumber, Model model) {
        Optional<AccountEntity> account = accountService.getAccountByNumber(accountNumber);
        account.ifPresent(value -> model.addAttribute("account", value));

        AccountDTO dto = AccountDTO.builder()
                .accountNumber(account.get().getAccountNumber())
                .balance(account.get().getBalance())
                .build();

        return ResponseEntity.ok().body(dto);
    }

//    이체 폼 페이지
//    @GetMapping("/transfer")
//    public String showTransferForm() {
//        return "transfer";
//    }

    // 이체 기능 수행
    @PostMapping("/transfer")
    public String transfer(@RequestBody TransferRequestDTO transferRequestDTO, Model model) {
        boolean success = accountService.transfer(transferRequestDTO.getFromAccount()
                                                , transferRequestDTO.getToAccount()
                                                , transferRequestDTO.getAmount());
        model.addAttribute("success", success);
        return "transfer_result";
    }

    // 입금 (Deposit)
    @PostMapping("/deposit")
    public ResponseEntity<String> deposit(@RequestBody DepositRequestDTO requestDTO) {

        boolean success = accountService.deposit(requestDTO.getAccountNumber(), requestDTO.getAmount());
        if (success) {
            return ResponseEntity.ok("Deposit successful");
        }
        return ResponseEntity.badRequest().body("Deposit failed: Invalid account or amount");
    }

    // 증권 계좌 이체 비율 설정
    @PostMapping("/set-ratio")
    // accountNumber --> 계좌 번호 받음, ratio --> 이체 비율(%) 받음
    public ResponseEntity<String> setTransferRatio(@RequestBody TransferRatioDTO requestDTO) {
        accountService.setTransferRatio(requestDTO.getAccountNumber(), requestDTO.getRatio()); // 투자 비율 업데이트
        return ResponseEntity.ok("증권 계좌 이체 비율 설정: " + requestDTO.getRatio());
    }

    // 증권 계좌 이체 비율 조회
    @GetMapping("/get-ratio")
    public Integer getTransferRatio(@RequestParam String accountNumber) {
        return accountService.getTransferRatio(accountNumber);
    }

    // 이자 받기
    @PostMapping("/collect-interest")
    public ResponseEntity<AccountDTO> collectInterest(@RequestParam String accountNumber) {
        AccountDTO updatedAccount = accountService.collectInterest(accountNumber); // 투자 비율을 기준으로 이자 계산 및 계좌 잔액 증가 함수
        return ResponseEntity.ok(updatedAccount);
    }

    // 이자 정보 조회 --> 사용자가 받을 이자
    // 현재 잔액 기준으로 받을 이자 계산 후 반환
    @GetMapping("/get-interest")
    public ResponseEntity<Integer> getInterest(@RequestParam String accountNumber) {
        int interest = accountService.getInterest(accountNumber); // 이자 비율에 따라 이자 계산
        return ResponseEntity.ok(interest);
    }

    // 해당 계좌 통장 내역 조회
    @GetMapping("/history")
    public ResponseEntity<List<AccountHistoryEntity>> getAccountHistory(@RequestParam String accountNumber) {
        List<AccountHistoryEntity> historyList = accountService.getAccountHistory(accountNumber);
        return ResponseEntity.ok(historyList);
    }

}

클라이언트 요청을 처리할 AccountController 작성

여기서 잠깐 다시 개념 정리를 하자면

✔ 컨트롤러(Controller)
클라이언트 요청을 받음 (@PostMapping, @GetMapping)
요청 데이터를 서비스(Service)로 전달
서비스에서 처리된 결과를 클라이언트에게 반환

✔ 서비스(Service)
서비스는 실제 비즈니스 로직(업무 로직)을 처리하는 곳이야!
데이터베이스에서 값을 읽어오거나, 값을 계산하고 변경하는 건 모두 서비스에서 처리해.
비즈니스 로직을 처리 (DB에서 조회/수정, 계산, 검증 등)
데이터베이스와 직접 통신
여러 컨트롤러에서 재사용 가능

✔ 컨트롤러와 서비스를 분리하면?
코드가 깔끔하고, 유지보수가 쉬움
재사용성 증가 (같은 로직을 여러 API에서 사용 가능)
테스트가 쉬움 (서비스 단위 테스트, 컨트롤러 Mock 테스트 가능)

🚀 쉽게 이해하는 비유
✅ 컨트롤러(Controller) = 웨이터 🍽
👉 손님(클라이언트) 주문을 받고, 요리를 주방(서비스)에게 전달

✅ 서비스(Service) = 주방 🍳
👉 웨이터가 전달한 주문을 처리해서 요리를 완성

✅ Repository = 창고 🏪
👉 주방(서비스)에서 재료(DB 데이터)를 가져오거나 저장

✔ 컨트롤러가 모든 걸 처리하면? 🤯 (웨이터가 요리까지 다 하려면 힘들겠지?)
✔ 컨트롤러는 "요청을 받아서 전달하는 역할"만 하고, 요리는 "서비스"에서 해야 해!

6. 테스트 데이터 (더미 데이터) 삽입

DB에 샘플 데이터 추가
- 이건 GPT씨한테 만들어 달라고 하면 시간 절약 가능!

7. JPA 테스트 코드 작성

AccountRepositoryTest

package org.team4.sol_server.repository;

import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.autoconfigure.orm.jpa.DataJpaTest;
import org.team4.sol_server.domain.account.entity.AccountEntity;
import org.team4.sol_server.domain.account.repository.AccountRepository;

import java.util.Optional;

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

@DataJpaTest
public class AccountRepositoryTest {

    @Autowired
    private AccountRepository accountRepository;

    @Test
    public void testFindByAccountNumber() {
        Optional<AccountEntity> account = accountRepository.findByAccountNumber("ACC123456");

        assertThat(account).isPresent();
        assertThat(account.get().getBalance()).isEqualTo(1000000);
    }
}

AccountServiceTests

package org.team4.sol_server.service;

import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.autoconfigure.jdbc.AutoConfigureTestDatabase;
import org.springframework.boot.test.autoconfigure.orm.jpa.DataJpaTest;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.transaction.annotation.Transactional;
import org.team4.sol_server.domain.account.dto.AccountDTO;
import org.team4.sol_server.domain.account.entity.AccountEntity;
import org.team4.sol_server.domain.account.repository.AccountRepository;
import org.team4.sol_server.domain.account.service.AccountService;

import java.util.Optional;

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

@SpringBootTest
@AutoConfigureTestDatabase(replace = AutoConfigureTestDatabase.Replace.NONE)
@Transactional
public class AccountServiceTests {

    @Autowired
    private AccountRepository accountRepository;

    @Autowired
    private AccountService accountService;

    private String testAccountNumber = "ACC123";
    private String testAccountNumber2 = "ACC456";

    @BeforeEach
    void setUp() {
        AccountEntity account1 = AccountEntity.builder()
                .accountNumber(testAccountNumber)
                .userIdx(1)
                .balance(1000000L)
                .investorRatio(50)
                .interest(25000)
                .interestRatio(2.5)
                .build();
        accountRepository.save(account1);

        AccountEntity account2 = AccountEntity.builder()
                .accountNumber(testAccountNumber2)
                .userIdx(2)
                .balance(500000L)
                .investorRatio(30)
                .interest(0)
                .interestRatio(1.2)
                .build();
        accountRepository.save(account2);
    }

    @Test
    public void testGetAccount() {
        // 계좌 정보 조회 테스트
        Optional<AccountEntity> accountOpt = accountService.getAccountByNumber(testAccountNumber);
        assertThat(accountOpt).isPresent();
        assertThat(accountOpt.get().getBalance()).isEqualTo(1000000);
        System.out.println("파킹 통장 잔액: " + accountOpt.get().getBalance());
    }

    @Test
    public void testDeposit() {
        // 입금 테스트: 10만원 입금
        boolean result = accountService.deposit(testAccountNumber, 100000L);
        assertThat(result).isTrue();

        // 변경된 잔액 확인
        Optional<AccountEntity> updatedAccount = accountService.getAccountByNumber(testAccountNumber);
        assertThat(updatedAccount).isPresent();
        assertThat(updatedAccount.get().getBalance()).isEqualTo(1100000);
        System.out.println("파킹 통장 잔액: " + updatedAccount.get().getBalance());
    }

    @Test
    public void testTransfer() {
        // 계좌 간 송금 테스트 (출금 10만원)
        boolean result = accountService.transfer(testAccountNumber, testAccountNumber2, 100000L);
        assertThat(result).isTrue();

        // 잔액 확인
        Optional<AccountEntity> fromAccount = accountService.getAccountByNumber(testAccountNumber);
        Optional<AccountEntity> toAccount = accountService.getAccountByNumber(testAccountNumber2);

        assertThat(fromAccount).isPresent();
        assertThat(toAccount).isPresent();
        assertThat(fromAccount.get().getBalance()).isEqualTo(900000);
        assertThat(toAccount.get().getBalance()).isEqualTo(600000);

        System.out.println("파킹 통장 잔액: " + fromAccount.get().getBalance());
        System.out.println("증권 계좌 잔액: " + toAccount.get().getBalance());
    }

    @Test
    public void testSetTransferRatio() {
        // 투자 비율 변경 테스트
        accountService.setTransferRatio(testAccountNumber, 80);
        Optional<AccountEntity> updatedAccount = accountService.getAccountByNumber(testAccountNumber);
        assertThat(updatedAccount).isPresent();
        assertThat(updatedAccount.get().getInvestorRatio()).isEqualTo(80);
        System.out.println("투자 비율 변경: " + updatedAccount.get().getInvestorRatio());
    }

    @Test
    public void testCollectInterest() {
        // 이자 받기 기능 테스트
        AccountDTO updatedAccount = accountService.collectInterest(testAccountNumber);

        // 이자가 올바르게 추가되었는지 확인
        assertThat(updatedAccount).isNotNull();
        assertThat(updatedAccount.getBalance()).isEqualTo(1025000);  // 100만원 + 2.5% (25000원)
        System.out.println("이자 받기: " + updatedAccount.getBalance());
    }

    @Test
    public void testGetInterest() {
        // 받을 이자 조회 테스트
        int interest = accountService.getInterest(testAccountNumber);
        assertThat(interest).isEqualTo(25000);  // 100만원 × 2.5% = 25000원
        System.out.println(interest);
    }

}

8. Postman으로 API 테스트

끝!

추가적으로 MockMvc를 사용하여 Spring Boot 컨트롤러 테스트하는 방법이 있다.
굳이 Postman을 쓰지 않아도 되는 방법인데, 포스트맨씨가 UI가 이쁘고 편하니까 걍 그거 쓰는 게 낫긴 하다.

방식은 대충

package org.team4.sol_server.domain.account.controller;

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;
import org.team4.sol_server.domain.account.service.AccountService;

import static org.mockito.Mockito.*;
import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.*;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.*;

@WebMvcTest(AccountController.class)  // 특정 컨트롤러만 테스트
public class AccountControllerTest {

    @Autowired
    private MockMvc mockMvc;

    @MockBean  // 서비스 계층을 Mocking (의존성 주입)
    private AccountService accountService;

    @Test
    public void testGetBalance() throws Exception {
        // 가짜 서비스 응답 설정
        when(accountService.getInterest("ACC123")).thenReturn(5000);

        // GET 요청을 실행하고 결과 검증
        mockMvc.perform(get("/api/account/get-interest")
                        .param("accountNumber", "ACC123"))  // 요청 파라미터 설정
                .andExpect(status().isOk())  // 응답 코드 200인지 확인
                .andExpect(content().string("5000"));  // 응답 내용 검증
    }
}

이러하다.

일단은 끝났지만, 추가적으로 더 구현할 사항이 늘어날 것 같긴 하다.
우선은 프론트랑 백 연동을 시작해 데이터를 출력해보고 UI까지 디자인 싸악 할 계획~~~

✔ API 개발하면서 DTO 필요성에 대한 고민을 해봄
✔ Postman을 활용해 API 테스트 및 문서화 진행
✔ 곧 프론트와 백엔드 연동 후 UI까지 완성할 계획!

🔥 앞으로도 계속 성장하는 풀스택 개발자가 되기 위해 달려간다! 🚀

hidihyeonee

벨로그 쫌 재밌네?

이전 포스트

[코드로 배우는 스프링 부트 웹 프로젝트] 스프링 부트(Spring Boot) 04

다음 포스트