TDD, 동시성 처리 - 항해 플러스 회고 (1주차)

 

 

들어가며

 

드디어 1주 차가 끝났다..! (이제 10퍼 했다..)

 

정말 지난 한 주는 내 머리로 들어오는 인풋 데이터가 어마어마한 일주일이었다.

지난 토요일, 오프라인 세션 모임에서 10주동안 함께 할 팀원들과 첫 대면을 하고, 1주 차 과제에 대한 발제를 들었다. 그냥 아이스브레이킹 하며 서로 궁금한 것들 얘기 나누고, 코치님에게 과제를 어떻게 풀어갈 것 인가에 대한 설명만 들었을 뿐인데 지금 회사에서는 경험해 보지도, 느껴보지도 못했던 내용들에 적잖은 충격과 설렘과 긴장이 뒤섞여있었다.

 

오프라인 세션 시작 대기 중

 

나는 지금 회사에서 그래도 나쁘지 않은 성과를 내곤 있지만, 지난 20대 시절 다른 분야의 일을 하면서 ‘우물 안 개구리’가 뭔지를 한번 쎄게 느껴보았기 때문에, 이번에도 그럴 것이라는 걸 각오하고 왔었다.

아니나 다를까, 역시 세상에 잘하는 사람은 많고, 또 열심히 해보고자 도전하는 사람도 많아서 내가 여기서 잘 배우고 버틸 수 있을까 내심 걱정은 되었다.

 

하지만 한 가지 좋았던 점도 있었다. 그래도 나름 직장다니면서 틈틈이 CS 공부, 서비스 회사에서 사용하는 기술 스택을 공부해 왔었다고 사람들이 무슨 얘기를 하는지 이해가 되는 것에 스스로 신기했다. 분명 1년 전만 해도 이해하지 못할 그런 주제였다. 그런 부분에서 스스로 자신감을 가지고 해야겠다고 생각했던 것 같다.

 

우리 팀은 모각코를 위한 코어 타임을 매주 월~목 21~23시로 정했다. 다른 시간은 자율적으로 공부하고, 이 시간에는 서로 궁금한 점을 물어보고, 코드 리뷰하는 등의 시간으로 할애했다.

 

그중에 정말 좋았던 건, 주중에 일곱 분의 코치님들이 각 팀마다 한 시간씩 궁금한 점에 대한 멘토링을 해주시는데 해당 세션에 가서 청강(이라 읽고 도강)할 수 있도록 해주었다. 다른 수강생들의 질문도 나와 비슷한 고민이고, 궁금해할만한 것들이어서 코치님마다의 생각, 성향과 스타일, 코드 작성 요령 등을 라이브 코딩식으로 볼 수가 있었다.

 

많은 사람들이 청강 중이다

 

 

 

1주 차 과제 시작

 

이번 1주 차 프로젝트 구현 과제는 주로 TDD, 동시성 처리에 관한 문제였다. 기본적으로 유저가 포인트, 포인트 이력 조회, 포인트 사용 및 충전하는 API를 작성하는 과제였다.

하지만 테스트 코드 작성과 동시성 처리를 처음 해본(코틀린도) 나로선 어떤 식으로 해야 할지 고민이 많이 되었다.

참 다행히도 마침 최근에 인프런에서 들었던 강좌 2개가 나에게 큰 보탬이 되었다.

인프런 Practical Testing: 실용적인 테스트 가이드 강의 | 박우빈 - 인프런
​인프런 김영한의 실전 자바 - 고급 1편, 멀티스레드와 동시성 강의 | 김영한 - 인프런

 

우빈님이 강의해 준 테스트 강의는 JUnit5 기반 단위테스트, 통합테스트에 대한 작성 요령을 예시 코드와 함께 잘 설명해 주었고, 영한님의 멀티스레드 강의도 우리가 Java 진영에서 주로 사용하는 Executor가 어떤 과정과 원리로 탄생했는지에 대해 단계 별로 예시 코드를 만들며 쉽게 이해 가도록 설명해 주었다. 그 덕에 문제를 어떻게 풀어갈 것인가에 대한 기본적인 방향을 잡을 수 있었다.

 

문제

 

1. 테스트 코드의 작성 범위는?

처음 테스트 코드를 작성하다 보니 단위테스트와 통합테스트의 작성 범위를 정하는 것이 어려웠다.

모든 레이어의 단위 테스트를 다 작성해야 하나?

통합 테스트의 range도 Service → Persistance Layer 까지 작성할까 Presentation Layer 까지 포함하여 작성할까?

Request 객체 안에 있는 Validate 로직도 테스트하기 위해 단위 테스트를 작성해야 하나?

 

2. 동시성 처리를 위한 락을 어떻게?

단순히 임계영역을 지정하기 위해 Synchronized를 사용하면 될까? 아니면 다른 방법을 사용해야 할까?

 

 

시도

우선 위 해답을 찾기 위해서는 구체적인 방향성이 필요했다. 팀원들과 문제 해결 방법에 대한 각자의 의견을 물어보고, 조언을 들으며 기본적인 방향을 잡고, 위에서 말했던 코치님들의 멘토링을 청강하면서 여러 코치님들이 주는 힌트들을 정말 많이 참고했다.

 

 

해결

1. 테스트 코드의 작성 범위

1) 단위 테스트

- Presentation Layer : @WebMvcTest 와 MockMvc 을 사용한 HTTP 요청 응답 검증

@WebMvcTest(PointController::class)
class PointControllerTest {
    @Autowired
    private lateinit var mockMvc: MockMvc

    @MockBean
    private lateinit var pointService: PointService

    @Test
    fun `특정 유저의 포인트를 조회할 수 있어야 한다`() {
        // given
        val userId = 1L
        val expectedResponse = UserPointResponse(1L, 100L)

        // when
        `when`(pointService.getUserPoint(userId)).thenReturn(expectedResponse)

        // then
        mockMvc.perform(
            get("/point/$userId"),
        )
            .andExpect(status().isOk)
            .andExpect(content().contentType(MediaType.APPLICATION_JSON))
            .andExpect(jsonPath("$.id", `is`(expectedResponse.id.toInt())))
            .andExpect(jsonPath("$.point", `is`(expectedResponse.point.toInt())))

        verify(pointService).getUserPoint(userId)
    }

    // ...

}

 

 

- Business Layer : 외부 의존 객체에 대해 Fake를 만들어 해당 Service 클래스의 기능만 검증

class PointServiceTest {
    private lateinit var pointHistoryRepository: PointHistoryRepository
    private lateinit var userPointRepository: UserPointRepository
    private lateinit var userLockManager: IUserLockManager
    private lateinit var pointValidateHelper: IPointValidateHelper
    private lateinit var pointConverter: IPointConverter
    private lateinit var pointHistoryQueueManager: IPointHistoryQueueManager
    private lateinit var pointService: PointService

    @BeforeEach
    fun setup() {
        pointHistoryRepository = FakePointHistoryRepository()
        userPointRepository = FakeUserPointRepository()
        userLockManager = FakeUserLockManager()
        pointValidateHelper = FakePointValidateHelper()
        pointConverter = FakePointConverter()
        pointConverter = FakePointConverter()
        pointHistoryQueueManager = FakePointHistoryQueueManager(pointHistoryRepository)
        pointService =
            PointServiceImpl(
                pointHistoryRepository,
                userPointRepository,
                userLockManager,
                pointValidateHelper,
                pointConverter,
                pointHistoryQueueManager,
            )
    }

    @Test
    fun `포인트를 조회하면 해당 유저의 포인트를 반환해야 한다`() {
        // given
        val userId = 1L
        val point = 1000L
        val expectedUserPoint = userPointRepository.insertOrUpdate(userId, point)

        // when
        val actualUserPoint = pointService.getUserPoint(userId)

        // then
        assertEquals(expectedUserPoint.id, actualUserPoint.id)
        assertEquals(expectedUserPoint.point, actualUserPoint.point)
    }

    // ...

}

 

 

- 그 외 : Validation 기능을 하는 Request 객체, 동시성 처리를 위한 LockManager, 순차 처리를 위한 QueueManager에 대한 기능 검증

class UserLockManagerTest {
    private lateinit var userLockManager: IUserLockManager

    @BeforeEach
    fun setup() {
        userLockManager = UserLockManager()
    }

    @Test
    fun `executeWithLock()을 호출하여 락을 얻었을 때 내부 로직이 수행된다`() {
        // given
        val userId = 1L
        val expectedValue = true
        var isExecuted = false

        // when
        userLockManager.executeWithLock(userId) {
            isExecuted = true
        }

        // then
        assertEquals(expectedValue, isExecuted)
    }

    // ...
}

 

 

 

2) 통합 테스트

- Business Layer에서 @SpringBootTest 를 사용하여 Persistance Layer 까지의 동시성 처리 검증

@SpringBootTest
class PointServiceIntegrationTest
    @Autowired
    constructor(
        val pointService: PointService,
        val userPointRepository: UserPointRepository,
        val pointHistoryRepository: PointHistoryRepository,
    ) {
        @Nested
        @TestMethodOrder(MethodOrderer.OrderAnnotation::class)
        @DisplayName("한명의 유저에게 포인트 충전과 사용을 동시에 할 때")
        inner class OneUserPointTest {
            private val threadPools = Executors.newFixedThreadPool(1000)
            private val chargeExceptionCount = AtomicInteger(0)
            private val useExceptionCount = AtomicInteger(0)
            private val initPoint = 100_000L
            private val operationCount = 50

            @BeforeEach
            fun setup() {
                chargeExceptionCount.set(0)
                useExceptionCount.set(0)
            }

            @Test
            @Order(1)
            @DisplayName("남은 포인트가 정상적으로 반환되고")
            fun remainingPointsMustBeCorrect() {
                // given
                val userId = 1L
                val chargeAmount = 100L
                val useAmount = 50L
                userPointRepository.insertOrUpdate(userId, initPoint)

                // when
                repeat(operationCount) {
                    threadPools.execute {
                        pointService.chargePoint(PointRequest(userId, chargeAmount))
                    }
                    threadPools.execute {
                        pointService.usePoint(PointRequest(userId, useAmount))
                    }
                }

                threadPools.shutdown()
                threadPools.awaitTermination(1, TimeUnit.MINUTES)

                // then
                val finalUserPoint = userPointRepository.selectById(userId)
                val expectedPoint = initPoint + (chargeAmount * operationCount) - (useAmount * operationCount)

                assertEquals(expectedPoint, finalUserPoint.point)
            }

            @Test
            @Order(2)
            @DisplayName("포인트 범위 이외의 요청은 취소하며")
            fun outsideRangeShouldBeCancelled() {
                // given
                val userId = 2L
                val chargeAmount = 200_003L
                val useAmount = 200_007L
                userPointRepository.insertOrUpdate(userId, initPoint)

                // when
                repeat(operationCount) {
                    threadPools.execute {
                        try {
                            pointService.chargePoint(PointRequest(userId, chargeAmount))
                        } catch (e: Exception) {
                            chargeExceptionCount.incrementAndGet()
                        }
                    }
                    threadPools.execute {
                        try {
                            pointService.usePoint(PointRequest(userId, useAmount))
                        } catch (e: Exception) {
                            useExceptionCount.incrementAndGet()
                        }
                    }
                }

                threadPools.shutdown()
                threadPools.awaitTermination(1, TimeUnit.MINUTES)

                // then
                val finalUserPoint = userPointRepository.selectById(userId)
                val expectedPoint =
                    initPoint +
                        (chargeAmount * operationCount) -
                        (useAmount * operationCount) -
                        (chargeAmount * chargeExceptionCount.get()) +
                        (useAmount * useExceptionCount.get())

                assertEquals(expectedPoint, finalUserPoint.point)
            }

            @Test
            @Order(3)
            @DisplayName("포인트 이력에는 정상적으로 수행된 요청만 남겨야 한다")
            fun pointHistoryMustOnlyContainSuccessfully() {
                // given
                val userId = 3L
                val chargeAmount = 700_003L
                val useAmount = 700_007L
                userPointRepository.insertOrUpdate(userId, initPoint)

                // when
                repeat(operationCount) {
                    threadPools.execute {
                        try {
                            pointService.chargePoint(PointRequest(userId, chargeAmount))
                        } catch (e: Exception) {
                            chargeExceptionCount.incrementAndGet()
                        }
                    }
                    threadPools.execute {
                        try {
                            pointService.usePoint(PointRequest(userId, useAmount))
                        } catch (e: Exception) {
                            useExceptionCount.incrementAndGet()
                        }
                    }
                }

                threadPools.shutdown()
                threadPools.awaitTermination(1, TimeUnit.MINUTES)

                // then
                val history = pointHistoryRepository.selectAllByUserId(userId)
                for (h in history) {
                    println(h)
                }
                assertEquals(operationCount * 2 - chargeExceptionCount.get() - useExceptionCount.get(), history.size)
                assertEquals(history.count { it.type == TransactionType.CHARGE }, operationCount - chargeExceptionCount.get())
                assertEquals(history.count { it.type == TransactionType.USE }, operationCount - useExceptionCount.get())
            }
        }

        @Nested
        @DisplayName("두명의 유저가 동시에 포인트 충전을 할 때")
        inner class TwoUserPointsTest {
            private val threadPools = Executors.newFixedThreadPool(1000)
            private val initPoint = 100_000L
            private val operationCount = 10_000

            @Test
            @DisplayName("포인트 잔액과 이력이 정상적으로 저장되어야 한다.")
            fun mustNeverBeAffectedByOtherUsersLock() {
                // given
                val userId1 = 4L
                val userId2 = 5L
                userPointRepository.insertOrUpdate(userId1, initPoint)
                userPointRepository.insertOrUpdate(userId2, initPoint)

                // when
                repeat(operationCount) {
                    threadPools.execute {
                        pointService.chargePoint(PointRequest(userId1, 10L))
                    }
                    threadPools.execute {
                        pointService.chargePoint(PointRequest(userId2, 10L))
                    }
                }
                threadPools.shutdown()
                threadPools.awaitTermination(1, TimeUnit.MINUTES)

                // then
                val userPoint1 = pointService.getUserPoint(userId1)
                val userPoint2 = pointService.getUserPoint(userId2)
                assertEquals(200_000, userPoint1.point)
                assertEquals(200_000, userPoint2.point)

                val pointHistory1 = pointService.getPointHistory(userId1)
                val pointHistory2 = pointService.getPointHistory(userId2)
                assertEquals(10_000, pointHistory1.size)
                assertEquals(10_000, pointHistory2.size)
            }
        }
    }

 

 

2. 동시성 처리

1. 유저 별로 락을 관리

• 이유 : 임계 영역에 하나의 락으로 관리하게 되면 다른 유저에 충전, 사용 시에 락 획득 대기 발생
• 해결방법 : UserLockManager 에서 유저 별 ReentrantLock 을 관리하는 ConcurrentHashMap 생성

@Component
class UserLockManager : IUserLockManager {
    private val lockMap: ConcurrentHashMap<Long, ReentrantLock> = ConcurrentHashMap()

    override fun <T> executeWithLock(
        userId: Long,
        action: () -> T,
    ): T {
        val lock = lockMap.computeIfAbsent(userId) { ReentrantLock() }

        if (!lock.tryLock(10, TimeUnit.SECONDS)) {
            throw LockAcquisitionException("락 획득에 실패했습니다. userId: $userId")
        }

        return try {
            action()
        } finally {
            lock.unlock()
        }
    }
}

 

 

2. 포인트 이력 Insert를 위한 별도 Queue 관리

• 이유 : 두 명의 유저가 포인트 이력을 Insert 할 때, 원자성 보장이 안되는 이슈 (동시에 조회하면 결괏값에 대한 보장이 되지 않는다.)
• 해결 방법: PointHistoryQueueManager 에 BlockingQueue 를 활용하여 Producer/Consumer 패턴으로 구현

@Component
class PointHistoryQueueManager(
    private val pointHistoryRepository: PointHistoryRepository,
) : IPointHistoryQueueManager {
    private val queue: BlockingQueue<PointHistoryQueueItem> = ArrayBlockingQueue(10_000)

    init {
        Thread { processQueue() }.start()
    }

    override fun put(history: PointHistoryQueueItem) {
        queue.put(history)
    }

    override fun processQueue() {
        while (true) {
            try {
                val pointRequest = queue.take()
                processPointRequest(pointRequest)
            } catch (e: Exception) {
                e.printStackTrace()
            }
        }
    }

    override fun processPointRequest(history: PointHistoryQueueItem) {
        pointHistoryRepository.insert(history.userId, history.amount, history.type, System.currentTimeMillis())
    }

    override fun isQueueEmpty(): Boolean {
        return queue.isEmpty()
    }
}

 

 

 

알게 된 것

• 테스트 코드
  • 단위 테스트에 대한 외부 의존성 해결을 어떤 방법으로 해야 하는지에 대한 방향성
  • Test Double에 대한 공부를 하면서 이번에 Fake 객체를 처음 사용해 보았는데, 어떻게 사용하는 것이 좋은 테스트 작성으로 이어질까에 대한 생각을 많이 했던 것 같다.
• 동시성 처리
  • Synchronized 와 ReentrantLock에 대한 차이
  • 비즈니스 로직에 임계 영역을 설정할 때의 주의점에 대해 테스트 작성을 통해 많이 알게 되었다.

 

Keep

• 이번 과제로 만들어본 테스트 코드 작성 요령을 토대로 한 테스트 코드 작성 습관
• 비즈니스 로직에서 동시성 문제에 대한 기능, 성능적 고민

 

Problem

• TDD 에 대한 실천 부족
  • 테스트 코드가 익숙하지 않아 기능 구현 → 테스트 코드 작성으로 이어진 경우가 많았다.
• 불완전했던 비즈니스 로직 컴포넌트 별 책임 분리
• GitHub 브랜치 별 PR 작성 요령

 

Try

다음 주차의 과제부터는 TDD의 장점을 살려서 기능 구현을 해보는걸 중점으로 가져가야겠다. 또한 회사에서 GitHub나 Git을 제대로 사용하질 않다보니 과제 제출에 있어서도 많이 헤맸던 것 같다. 다른 사람들의 PR을 보면서 어떻게 제출하는게 좋을까 고민해봐야겠다.

 

 

 

 

마치며

 

[출처] https://pin.it/e2tA7ydBN

 

퇴근하고도 다른 곳에 신경써야 할 일이 많다 보니 오로지 개발에 몰두해 본 적이 입사 이후 처음인 것 같다. 그만큼 앞으로의 인생에 중요한 시기가 될 것 같으니 남은 9주도 지금과 같은 마음으로 열심히 임해야겠다..!

 

[1주차 과제 GitHub] https://github.com/eastshine12/hhplus-tdd-jvm/tree/dev