diff --git a/.idea/.name b/.idea/.name
new file mode 100644
index 0000000..0af53bb
--- /dev/null
+++ b/.idea/.name
@@ -0,0 +1 @@
+hhplus-tdd-jvm
\ No newline at end of file
diff --git a/.idea/codeStyles/Project.xml b/.idea/codeStyles/Project.xml
new file mode 100644
index 0000000..1bec35e
--- /dev/null
+++ b/.idea/codeStyles/Project.xml
@@ -0,0 +1,10 @@
+<component name="ProjectCodeStyleConfiguration">
+  <code_scheme name="Project" version="173">
+    <JetCodeStyleSettings>
+      <option name="CODE_STYLE_DEFAULTS" value="KOTLIN_OFFICIAL" />
+    </JetCodeStyleSettings>
+    <codeStyleSettings language="kotlin">
+      <option name="CODE_STYLE_DEFAULTS" value="KOTLIN_OFFICIAL" />
+    </codeStyleSettings>
+  </code_scheme>
+</component>
\ No newline at end of file
diff --git a/.idea/codeStyles/codeStyleConfig.xml b/.idea/codeStyles/codeStyleConfig.xml
new file mode 100644
index 0000000..79ee123
--- /dev/null
+++ b/.idea/codeStyles/codeStyleConfig.xml
@@ -0,0 +1,5 @@
+<component name="ProjectCodeStyleConfiguration">
+  <state>
+    <option name="USE_PER_PROJECT_SETTINGS" value="true" />
+  </state>
+</component>
\ No newline at end of file
diff --git a/.idea/gradle.xml b/.idea/gradle.xml
index f9163b4..0ead08a 100644
--- a/.idea/gradle.xml
+++ b/.idea/gradle.xml
@@ -1,8 +1,10 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <project version="4">
+  <component name="GradleMigrationSettings" migrationVersion="1" />
   <component name="GradleSettings">
     <option name="linkedExternalProjectsSettings">
       <GradleProjectSettings>
+        <option name="testRunner" value="PLATFORM" />
         <option name="externalProjectPath" value="$PROJECT_DIR$" />
         <option name="modules">
           <set>
diff --git a/README.md b/README.md
new file mode 100644
index 0000000..f5397d1
--- /dev/null
+++ b/README.md
@@ -0,0 +1,49 @@
+# 테스트 항목
+✅ 1. 기본 기능 테스트 (정상 시나리오)
+가장 일반적인 입력을 주었을 때, 예상한 대로 동작하는지 확인
+
+예) 로그인 기능: 올바른 ID/PW 입력 시 로그인 성공
+
+✅ 2. 경계값 테스트 (Boundary Value Testing)
+입력값의 경계(최소값, 최대값 등)에서 오류가 없는지 확인
+
+예) 입력 가능한 글자 수가 1~100자일 경우:
+
+0자, 1자, 100자, 101자 테스트
+
+✅ 3. 예외/에러 처리 테스트 (Negative Testing)
+잘못된 입력이나 조건에서 시스템이 적절히 대응하는지 확인
+
+예) 이메일 형식이 아닌 문자열 입력 시 에러 메시지 출력
+
+✅ 4. 빈 입력/Null 값 테스트
+사용자가 아무것도 입력하지 않거나, null/undefined가 들어왔을 때의 동작 확인
+
+✅ 5. 중복/재입력 테스트
+동일한 입력이 반복될 때의 시스템 반응
+
+예) 동일한 ID로 회원가입 시 처리 방식
+
+---
+
+✅ 6. 성능/부하 테스트 (기본 수준)
+일정 수준 이상의 데이터가 들어왔을 때 시스템이 버티는지
+
+예) 검색어 자동완성에 초당 1000건 요청 시 응답 지연 여부
+
+✅ 7. 보안 관련 테스트
+허용되지 않은 접근이나 데이터 조작이 가능한지 확인
+
+예) 인증되지 않은 사용자가 관리자 페이지 접근 시 차단 여부
+
+✅ 8. 호환성 테스트
+여러 환경/브라우저/OS에서 동일하게 동작하는지 (웹/모바일 앱의 경우)
+
+✅ 9. 상태 유지/세션 테스트
+세션이 끊긴 뒤의 동작, 로그인 후 특정 시간 지나면 로그아웃 되는지 등
+
+✅ 10. 업데이트/삭제 등 부작용 테스트
+특정 기능 실행 후 다른 기능에 영향이 없는지 확인
+
+예) 게시글 삭제 후 목록이 제대로 갱신되는지
+
diff --git a/src/main/java/io/hhplus/tdd/database/UserPointTable.java b/src/main/java/io/hhplus/tdd/database/UserPointTable.java
index 8e91e13..40e25f3 100644
--- a/src/main/java/io/hhplus/tdd/database/UserPointTable.java
+++ b/src/main/java/io/hhplus/tdd/database/UserPointTable.java
@@ -15,11 +15,13 @@ public class UserPointTable {
 
     private final Map<Long, UserPoint> table = new HashMap<>();
 
+    // 사용자 Id 기반 데이터 조회
     public UserPoint selectById(Long id) {
         throttle(200);
         return table.getOrDefault(id, UserPoint.empty(id));
     }
 
+    // USER POINT 삽입 함수
     public UserPoint insertOrUpdate(long id, long amount) {
         throttle(300);
         UserPoint userPoint = new UserPoint(id, amount, System.currentTimeMillis());
diff --git a/src/main/java/io/hhplus/tdd/point/PointController.java b/src/main/java/io/hhplus/tdd/point/PointController.java
index 215eabb..c5f3fb8 100644
--- a/src/main/java/io/hhplus/tdd/point/PointController.java
+++ b/src/main/java/io/hhplus/tdd/point/PointController.java
@@ -6,11 +6,15 @@
 
 import java.util.List;
 
+import lombok.RequiredArgsConstructor;
+
 @RestController
 @RequestMapping("/point")
+@RequiredArgsConstructor
 public class PointController {
 
     private static final Logger log = LoggerFactory.getLogger(PointController.class);
+    private final PointService pointService;
 
     /**
      * TODO - 특정 유저의 포인트를 조회하는 기능을 작성해주세요.
@@ -19,7 +23,7 @@ public class PointController {
     public UserPoint point(
             @PathVariable long id
     ) {
-        return new UserPoint(0, 0, 0);
+        return pointService.selectPointById(id);
     }
 
     /**
@@ -29,7 +33,7 @@ public UserPoint point(
     public List<PointHistory> history(
             @PathVariable long id
     ) {
-        return List.of();
+        return pointService.selectHistoryById(id);
     }
 
     /**
@@ -40,7 +44,7 @@ public UserPoint charge(
             @PathVariable long id,
             @RequestBody long amount
     ) {
-        return new UserPoint(0, 0, 0);
+        return pointService.chargePointById(id, amount);
     }
 
     /**
@@ -51,6 +55,6 @@ public UserPoint use(
             @PathVariable long id,
             @RequestBody long amount
     ) {
-        return new UserPoint(0, 0, 0);
+        return pointService.usePointById(id, amount);
     }
 }
diff --git a/src/main/java/io/hhplus/tdd/point/PointHistory.java b/src/main/java/io/hhplus/tdd/point/PointHistory.java
index e062843..a5d0fc9 100644
--- a/src/main/java/io/hhplus/tdd/point/PointHistory.java
+++ b/src/main/java/io/hhplus/tdd/point/PointHistory.java
@@ -1,5 +1,11 @@
 package io.hhplus.tdd.point;
 
+/* 
+ * 포인트 내역 클래스
+ * 
+ * 포인트 충전/사용 내역을 저장하는 클래스
+ * 
+ */
 public record PointHistory(
         long id,
         long userId,
diff --git a/src/main/java/io/hhplus/tdd/point/PointService.java b/src/main/java/io/hhplus/tdd/point/PointService.java
new file mode 100644
index 0000000..c60bb02
--- /dev/null
+++ b/src/main/java/io/hhplus/tdd/point/PointService.java
@@ -0,0 +1,58 @@
+package io.hhplus.tdd.point;
+
+import io.hhplus.tdd.point.UserPoint;
+import org.springframework.stereotype.Service;
+
+import io.hhplus.tdd.database.PointHistoryTable;
+import io.hhplus.tdd.database.UserPointTable;
+import lombok.RequiredArgsConstructor;
+
+import java.util.List;
+
+@Service
+@RequiredArgsConstructor // 클래스의 final 필드와 @NonNull로 표시된 필드에 대한 생성자를 자동으로 생성해 줍니다.
+public class PointService {
+    private final UserPointTable userPointTable;
+    private final PointHistoryTable pointHistoryTable;
+
+    public UserPoint selectPointById(long userId) {
+        return userPointTable.selectById(userId);
+    }
+
+    public List<PointHistory> selectHistoryById(long id)
+    {
+        return pointHistoryTable.selectAllByUserId(id);
+    }
+
+    public UserPoint chargePointById(long userId, long chargeAmount) {
+        // check for user exists
+        UserPoint userPoint = userPointTable.selectById(userId);
+        if(userPoint == null){
+            userPoint = UserPoint.empty(userId);
+        }
+        ///  DDD work
+        userPoint = userPoint.charge(userPoint, chargeAmount);
+        userPoint = userPointTable.insertOrUpdate(userId, userPoint.point());
+
+        // recording
+        pointHistoryTable.insert(userId, chargeAmount, TransactionType.CHARGE, System.currentTimeMillis());
+        return userPoint;
+    }
+
+    public UserPoint usePointById(long userId, long useAmount) {
+        // check for user exists
+        UserPoint userPoint = userPointTable.selectById(userId);
+        if(userPoint == null){
+            return UserPoint.empty(userId);
+        }
+        userPoint.chkForValidate(TransactionType.USE, useAmount);
+
+        // DDD
+        userPoint = userPoint.use(userPoint, useAmount);
+        userPoint = userPointTable.insertOrUpdate(userId, userPoint.point());
+
+        // recording
+        pointHistoryTable.insert(userId, useAmount, TransactionType.USE, System.currentTimeMillis());
+        return userPoint;
+    }
+}
\ No newline at end of file
diff --git a/src/main/java/io/hhplus/tdd/point/UserPoint.java b/src/main/java/io/hhplus/tdd/point/UserPoint.java
index c517ebf..0ea5b7a 100644
--- a/src/main/java/io/hhplus/tdd/point/UserPoint.java
+++ b/src/main/java/io/hhplus/tdd/point/UserPoint.java
@@ -1,12 +1,51 @@
 package io.hhplus.tdd.point;
 
+import lombok.val;
+import org.apache.catalina.User;
+
 public record UserPoint(
         long id,
         long point,
         long updateMillis
 ) {
 
+    // 1억
+    private static final long maxPoint = 10000L;
     public static UserPoint empty(long id) {
         return new UserPoint(id, 0, System.currentTimeMillis());
     }
+
+    /// point 경계값 체크
+    public void chkForValidate(TransactionType type, long amount){
+        // over 0 is validate
+        if(amount <= 0) throw new IllegalArgumentException("요청한 포인트가 0 보다 커야 합니다.");
+        switch (type){
+            case CHARGE -> {
+                if(point + amount > maxPoint)
+                {
+                    throw new IllegalArgumentException("포인트 한도를 초과했습니다.");
+                }
+            }
+            case USE -> {
+                if(point - amount < 0)
+                {
+                    throw new IllegalArgumentException("포인트가 부족합니다.");
+                }
+            }
+        }
+    }
+
+    /// Charging
+    public UserPoint charge(UserPoint userPoint, long amount)
+    {
+        chkForValidate(TransactionType.CHARGE, amount);
+        return new UserPoint(userPoint.id, userPoint.point + amount, System.currentTimeMillis());
+    }
+
+    /// Using
+    public UserPoint use(UserPoint userPoint, long amount)
+    {
+        chkForValidate(TransactionType.USE, amount);
+        return new UserPoint(userPoint.id, userPoint.point - amount, System.currentTimeMillis());
+    }
 }
diff --git a/src/test/java/io/hhplus/tdd/database/PointHistoryTableTest.java b/src/test/java/io/hhplus/tdd/database/PointHistoryTableTest.java
new file mode 100644
index 0000000..9a3abd8
--- /dev/null
+++ b/src/test/java/io/hhplus/tdd/database/PointHistoryTableTest.java
@@ -0,0 +1,149 @@
+package io.hhplus.tdd.database;
+
+import io.hhplus.tdd.point.PointHistory;
+import io.hhplus.tdd.point.TransactionType;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Nested;
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+@DisplayName("Point History Table 단위 테스트")
+public class PointHistoryTableTest {
+    /**
+     * 언제 Mock 객체를 쓰고 언제 진짜 객체를 써야할까?
+     * 단위 테스트는 **코드의 개별 단위를 고립시켜 검증**하는 것을 목표로 합니다.
+     * - 외부 의존성을 제거하고, 테스트 대상 클래스 **자체의 로직**이 잘 동작하는지 확인하는 것이 핵심
+     *
+     * ### Mock 객체는 **외부 의존성을 대체**하여 클래스의 **행위를 고립**시켜 테스트하기 위해 사용됩니다.
+     * 따라서, 클래스가 다른 객체(의존성)를 사용하는 경우 해당 객체를 Mock으로 주입하는 것이 일반적
+     *
+     * ### **진짜 객체(실제 의존성)를 써야 할 경우**
+     * 1. **PointHistoryTable이 의존성이 없는 순수한 객체**라면
+     * 2. **통합 테스트가 목적**인 경우
+     * */
+    private final PointHistoryTable pointHistoryTable = new PointHistoryTable();
+
+    @Nested
+    @DisplayName("Insert 함수 단위 테스트")
+    class PointHistoryTableInsertTest {
+        @Test
+        @DisplayName("성공_PointHistory_삽입_테스트")
+        void insertChargeHistory_ReturnsValidPointHistory_WhenValidInput() {
+            // given
+            long userId = 1L;
+            long amount = 100L;
+            TransactionType type = TransactionType.CHARGE;
+            long updateMillis = System.currentTimeMillis();
+
+            // when
+            PointHistory result = pointHistoryTable.insert(userId, amount, type, updateMillis);
+
+            // then
+            assertNotNull(result);
+            assertEquals(userId, result.userId());
+            assertEquals(amount, result.amount());
+            assertEquals(type, result.type());
+            assertEquals(updateMillis, result.updateMillis());
+        }
+
+        @Test
+        @DisplayName("성공_사용_이력_테스트")
+        void insertUseHistory_ReturnsValidPointHistory_WhenValidInput() {
+            // given
+            long userId = 1L;
+            long amount = 100L;
+            TransactionType type = TransactionType.USE;
+            long updateMillis = System.currentTimeMillis();
+
+            // when
+            PointHistory result = pointHistoryTable.insert(userId, amount, type, updateMillis);
+
+            // then
+            assertNotNull(result);
+            assertEquals(userId, result.userId());
+            assertEquals(amount, result.amount());
+            assertEquals(type, result.type());
+        }
+
+        @Test
+        @DisplayName("성공_ID_증가_테스트")
+        void insertIncrementsIdSequentially_WhenMultipleHistoriesInserted() {
+            // given
+            long userId = 1L;
+            TransactionType type = TransactionType.CHARGE;
+
+            // when
+            PointHistory firstInsert = pointHistoryTable.insert(userId, 100L, type, System.currentTimeMillis());
+            PointHistory secondInsert = pointHistoryTable.insert(userId, 200L, type, System.currentTimeMillis());
+            PointHistory thirdInsert = pointHistoryTable.insert(userId, 300L, type, System.currentTimeMillis());
+
+            // then
+            assertEquals(firstInsert.id() + 1, secondInsert.id());
+            assertEquals(secondInsert.id() + 1, thirdInsert.id());
+        }
+    }
+
+    @Nested
+    @DisplayName("selectAllByUserId 단위 테스트")
+    class PointHistoryTableSelectAllByUserIdTest {
+        @Test
+        @DisplayName("성공_UserId_기반_PointHistory_조회_테스트")
+        void selectAllByUserId_ReturnsValidPointHistoryList_WhenValidInput() {
+            // given
+            long userId = 1L;
+            pointHistoryTable.insert(userId, 100L, TransactionType.CHARGE, System.currentTimeMillis());
+            pointHistoryTable.insert(userId, 200L, TransactionType.USE, System.currentTimeMillis());
+            pointHistoryTable.insert(2L, 50L, TransactionType.CHARGE, System.currentTimeMillis()); // 다른 userId 데이터
+
+            // when
+            var result = pointHistoryTable.selectAllByUserId(userId);
+
+            // then
+            assertNotNull(result);
+            assertEquals(2, result.size());
+            assertTrue(
+                    result.stream()
+                            .allMatch(pointHistory -> pointHistory.userId() == userId)
+            );
+        }
+
+
+        @Test
+        @DisplayName("실패_존재하지_않는_UserId_조회시_빈_리스트_반환_테스트")
+        void selectAllByUserId_ReturnsEmptyList_WhenUserIdNotExists() {
+            // given
+            long nonExistentUserId = 999L;
+
+            // when
+            var result = pointHistoryTable.selectAllByUserId(nonExistentUserId);
+
+            // then
+            assertNotNull(result);
+            assertTrue(result.isEmpty(), "Result should be an empty list for non-existent userId");
+        }
+
+        @Test
+        @DisplayName("성공_이력_삽입_순서대로_조회되는_테스트")
+        void selectAllByUserId_ReturnsHistoriesInInsertionOrder_WhenMultipleHistoriesInserted() {
+            // given
+            long userId = 1L;
+
+            PointHistory firstInsert = pointHistoryTable.insert(userId, 100L, TransactionType.CHARGE, System.currentTimeMillis());
+            PointHistory secondInsert = pointHistoryTable.insert(userId, 200L, TransactionType.USE, System.currentTimeMillis());
+            PointHistory thirdInsert = pointHistoryTable.insert(userId, 300L, TransactionType.CHARGE, System.currentTimeMillis());
+
+            // when
+            var result = pointHistoryTable.selectAllByUserId(userId);
+
+            // then
+            assertNotNull(result);
+            assertEquals(3, result.size());
+            assertEquals(firstInsert.id(), result.get(0).id());
+            assertEquals(secondInsert.id(), result.get(1).id());
+            assertEquals(thirdInsert.id(), result.get(2).id());
+        }
+        
+        
+    }
+}
diff --git a/src/test/java/io/hhplus/tdd/database/UserPointTableTest.java b/src/test/java/io/hhplus/tdd/database/UserPointTableTest.java
new file mode 100644
index 0000000..2408596
--- /dev/null
+++ b/src/test/java/io/hhplus/tdd/database/UserPointTableTest.java
@@ -0,0 +1,94 @@
+package io.hhplus.tdd.database;
+
+import io.hhplus.tdd.point.UserPoint;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Nested;
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+@DisplayName("UserPointTable 단위 테스트")
+public class UserPointTableTest {
+
+    private final UserPointTable userPointTable = new UserPointTable();
+
+    @Nested
+    @DisplayName("통합 테스트")
+    class UserPointTableIntegrationTest {
+        @Test
+        @DisplayName("업데이트된 포인트를 selectById로 조회할 수 있는지 테스트")
+        void testSelectByIdAfterUpdate() {
+            // Given
+            long userId = 100L;
+            long initialPoint = 250L;
+            long updatedPoint = 500L;
+
+            // When
+            userPointTable.insertOrUpdate(userId, initialPoint);
+            userPointTable.insertOrUpdate(userId, updatedPoint);
+            UserPoint result = userPointTable.selectById(userId);
+
+            // Then
+            assertNotNull(result);
+            assertEquals(userId, result.id());
+            assertEquals(updatedPoint, result.point());
+        }
+    }
+
+    @Nested
+    @DisplayName("SelectById 단위 테스트")
+    class SelectByIdTest {
+        @Test
+        @DisplayName("저장되지 않은 사용자의 selectById 테스트")
+        void testSelectByIdForUnregisteredUser() {
+            // Given
+            long userId = 12345L;
+
+            // When
+            UserPoint result = userPointTable.selectById(userId);
+
+            // Then
+            assertNotNull(result);
+            assertEquals(userId, result.id());
+            assertEquals(0L, result.point());
+        }
+    }
+
+    @Nested
+    @DisplayName("InsertOrUpdate 단위 테스트")
+    class InsertOrUpdateTest {
+        @Test
+        @DisplayName("신규 사용자의 InsertOrUpdate 성공 테스트")
+        void testInsertOrUpdateForNewUser() {
+            // Given
+            long newUserId = 1L;
+            long newUserPoint = 500L;
+
+            // When
+            UserPoint newUser = userPointTable.insertOrUpdate(newUserId, newUserPoint);
+
+            // Then
+            assertNotNull(newUser);
+            assertEquals(newUserId, newUser.id());
+            assertEquals(newUserPoint, newUser.point());
+        }
+
+        @Test
+        @DisplayName("기존 사용자의 InsertOrUpdate 성공 테스트")
+        void testInsertOrUpdateForExistingUser() {
+            // Given
+            long existingUserId = 2L;
+            long initialPoint = 300L;
+            long updatedPoint = 200L;
+            userPointTable.insertOrUpdate(existingUserId, initialPoint);
+
+            // When
+            UserPoint updatedUser = userPointTable.insertOrUpdate(existingUserId, updatedPoint);
+
+            // Then
+            assertNotNull(updatedUser);
+            assertEquals(existingUserId, updatedUser.id());
+            assertEquals(updatedPoint, updatedUser.point());
+        }
+    }
+}
diff --git a/src/test/java/io/hhplus/tdd/point/PointServiceTest.java b/src/test/java/io/hhplus/tdd/point/PointServiceTest.java
new file mode 100644
index 0000000..9ee8ad4
--- /dev/null
+++ b/src/test/java/io/hhplus/tdd/point/PointServiceTest.java
@@ -0,0 +1,96 @@
+package io.hhplus.tdd.point;
+
+import io.hhplus.tdd.database.PointHistoryTable;
+import io.hhplus.tdd.database.UserPointTable;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Nested;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.junit.jupiter.MockitoExtension;
+
+import static org.junit.jupiter.api.Assertions.*;
+import static io.hhplus.tdd.point.TransactionType.*;
+import static org.mockito.ArgumentMatchers.anyLong;
+import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.Mockito.*;
+
+@ExtendWith(MockitoExtension.class)
+public class PointServiceTest {
+    @Mock
+    private UserPointTable userPointTable;
+
+    @Mock
+    private PointHistoryTable pointHistoryTable;
+    
+    /**
+     * InjectMocks : **테스트 대상 클래스에 Mock 객체를 주입**
+     * - 테스트하려는 클래스 인스턴스를 생성하고, 
+     * 클래스의 필드 또는 생성자에 필요한 의존성을 **테스트에서 생성된 Mock 객체로 주입**합니다.
+     * */
+    @InjectMocks
+    private PointService pointService;
+
+    /* */
+    @Nested
+    @DisplayName("포인트 충전 검증 단위 테스트")
+    class ChargingPointTest {
+        @Test
+        @DisplayName("chargePointById가 포인트 충전 요청을 성공적으로 처리하는지 단위 테스트")
+        void testChargePointById_success() {
+            // Given
+            long userId = 1L;
+            long initialPoint = 100L;
+            long chargeAmount = 50L;
+            UserPoint originalPoint = new UserPoint(userId, initialPoint, System.currentTimeMillis());
+            UserPoint updatedPoint = new UserPoint(userId, initialPoint + chargeAmount, System.currentTimeMillis());
+
+            when(userPointTable.selectById(eq(userId))).thenReturn(originalPoint);
+            when(userPointTable.insertOrUpdate(eq(userId), eq(initialPoint + chargeAmount))).thenReturn(updatedPoint);
+
+            // When
+            UserPoint result = pointService.chargePointById(userId, chargeAmount);
+
+            // Then
+            assertNotNull(result);
+            assertEquals(userId, result.id());
+            assertEquals(initialPoint + chargeAmount, result.point());
+
+            verify(userPointTable).selectById(eq(userId));
+            verify(userPointTable).insertOrUpdate(eq(userId), eq(initialPoint + chargeAmount));
+            verify(pointHistoryTable).insert(eq(userId), eq(chargeAmount), eq(CHARGE), anyLong());
+        }
+    }
+
+    @Nested
+    @DisplayName("포인트 사용 검증 단위 테스트")
+    class UsingPointTest {
+
+        @Test
+        @DisplayName("usePointById가 포인트 사용 요청을 성공적으로 처리하는지 단위 테스트")
+        void testUsePointById_success() {
+            // Given
+            long userId = 1L;
+            long initialPoint = 100L;
+            long useAmount = 30L;
+            UserPoint originalPoint = new UserPoint(userId, initialPoint, System.currentTimeMillis());
+            UserPoint updatedPoint = new UserPoint(userId, initialPoint - useAmount, System.currentTimeMillis());
+
+            when(userPointTable.selectById(eq(userId))).thenReturn(originalPoint);
+            when(userPointTable.insertOrUpdate(eq(userId), eq(initialPoint - useAmount))).thenReturn(updatedPoint);
+
+            // When
+            UserPoint result = pointService.usePointById(userId, useAmount);
+
+            // Then
+            assertNotNull(result);
+            assertEquals(userId, result.id());
+            assertEquals(initialPoint - useAmount, result.point());
+
+            verify(userPointTable).selectById(eq(userId));
+            verify(userPointTable).insertOrUpdate(eq(userId), eq(initialPoint - useAmount));
+            verify(pointHistoryTable).insert(eq(userId), eq(useAmount), eq(USE), anyLong());
+        }
+    }
+}
diff --git a/src/test/java/io/hhplus/tdd/point/UserPointTest.java b/src/test/java/io/hhplus/tdd/point/UserPointTest.java
new file mode 100644
index 0000000..409fa81
--- /dev/null
+++ b/src/test/java/io/hhplus/tdd/point/UserPointTest.java
@@ -0,0 +1,135 @@
+package io.hhplus.tdd.point;
+
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Nested;
+import org.junit.jupiter.api.Test;
+
+/**
+ * | **기능** | `import` | `import static` |
+ * | --- | --- | --- |
+ * | **대상** | 클래스 또는 인터페이스 | 정적 필드 또는 정적 메서드 |
+ * | **멤버 접근 방식** | 클래스 이름으로 접근 | 클래스 이름 없이 직접 접근 |
+ * | **주로 사용하는 경우** | 특정 클래스를 많이 사용할 때 | 정적 유틸리티 메서드나 상수 사용 시 |
+ * | **가독성 고려** | 항상 명확하고 직관적임 | 과도하게 사용하면 코드가 모호해질 수 있음 |
+ * */
+
+import static io.hhplus.tdd.point.TransactionType.*;
+import static org.junit.jupiter.api.Assertions.*;
+
+public class UserPointTest {
+    /**
+     * `@Nested`는 **JUnit 5**에서 제공하는 어노테이션입니다.
+     * `@Nested`를 사용하면 테스트 클래스 내부에 **중첩 클래스**를 정의할 수 있으며,
+     * 이 중첩 클래스는 테스트 관련 시나리오를 **보다 구체적으로 구조화**하고 **읽기 쉽게 분리**하는 데 사용됩니다.
+     */
+    @Nested
+    class CommonTest{
+        @Test
+        @DisplayName("실패_요청_포인트_음수")
+        void 실패_요청_포인트_음수_IllegalArgumentException_반환()
+        {
+            // given
+            UserPoint userPoint = new UserPoint(1L, 100, System.currentTimeMillis());
+            long chargingAmount = -101;
+
+            // when & then
+            assertAll(
+                    "요청 포인트 검증",
+                    ()->{
+                        IllegalArgumentException exception = assertThrows(
+                                IllegalArgumentException.class,
+                                () -> userPoint.chkForValidate(CHARGE, chargingAmount));
+                        assertEquals("요청한 포인트가 0 보다 커야 합니다.", exception.getMessage());
+                    },
+                    ()->{
+                        IllegalArgumentException exception = assertThrows(
+                                IllegalArgumentException.class,
+                                () -> userPoint.chkForValidate(USE, chargingAmount));
+                        assertEquals("요청한 포인트가 0 보다 커야 합니다.", exception.getMessage());
+                    }
+            );
+        }
+
+        @Test
+        @DisplayName("실패_포인트_0을_요청")
+        void 실패_포인트_0을_요청_IllegalArgumentException_반환()
+        {
+            // given
+            UserPoint userPoint = new UserPoint(1L, 100, System.currentTimeMillis());
+            long chargingAmount =0;
+
+            // when & then
+            IllegalArgumentException exception = assertThrows(
+                    IllegalArgumentException.class,
+                    () -> userPoint.chkForValidate(CHARGE, chargingAmount));
+            assertEquals("요청한 포인트가 0 보다 커야 합니다.", exception.getMessage());
+
+            exception = assertThrows(
+                    IllegalArgumentException.class,
+                    () -> userPoint.chkForValidate(USE, chargingAmount));
+            assertEquals("요청한 포인트가 0 보다 커야 합니다.", exception.getMessage());
+        }
+    }
+
+    @Nested
+    class ChargeTest {
+        @Test
+        @DisplayName("성공_요금 충전 테스트")
+        void 성공_요금_충전_테스트()
+        {
+            // given
+            UserPoint userPoint = new UserPoint(1L, 100, System.currentTimeMillis());
+            long chargingAmount = 500;
+
+            // when & then
+            assertDoesNotThrow(() -> userPoint.chkForValidate(CHARGE, chargingAmount));
+        }
+
+        @Test
+        @DisplayName("실패_포인트_충전_초과")
+        void 실패_포인트_충전_초과_IllegalArgumentException_반환()
+        {
+            // given
+            UserPoint userPoint = new UserPoint(1L, 9000, System.currentTimeMillis());
+            long chargingAmount = 1001;
+
+            // when & then
+            IllegalArgumentException exception = assertThrows(
+                    IllegalArgumentException.class,
+                    () -> userPoint.chkForValidate(CHARGE, chargingAmount));
+
+            assertEquals("포인트 한도를 초과했습니다.", exception.getMessage());
+        }
+    }
+
+    @Nested
+    class UseTest {
+        @Test
+        @DisplayName("성공_요금 사용 테스트")
+        void 성공_요금_사용_테스트()
+        {
+            // given
+            UserPoint userPoint = new UserPoint(1L, 1000, System.currentTimeMillis());
+            long chargingAmount = 500;
+
+            // when & then
+            assertDoesNotThrow(() -> userPoint.chkForValidate(USE, chargingAmount));
+        }
+
+        @Test
+        @DisplayName("실패_포인트_사용_초과")
+        void 실패_포인트_사용_초과_IllegalArgumentException_반환()
+        {
+            // given
+            UserPoint userPoint = new UserPoint(1L, 1000, System.currentTimeMillis());
+            long chargingAmount = 1001;
+
+            // when & then
+            IllegalArgumentException exception = assertThrows(
+                    IllegalArgumentException.class,
+                    () -> userPoint.chkForValidate(USE, chargingAmount));
+
+            assertEquals("포인트가 부족합니다.", exception.getMessage());
+        }
+    }
+}