diff --git a/frontend/src/App.tsx b/frontend/src/App.tsx
index e85af96a..b95ec603 100644
--- a/frontend/src/App.tsx
+++ b/frontend/src/App.tsx
@@ -23,6 +23,7 @@ import ReservationSuccessPageV21 from './pages/v2/ReservationSuccessPageV21';
 import HomePageV2 from './pages/v2/HomePageV2';
 import LoginPageV2 from './pages/v2/LoginPageV2';
 import SignupPageV2 from './pages/v2/SignupPageV2';
+import ReservationFormPage from './pages/v2/ReservationFormPage';
 import AdminThemeEditPage from './pages/admin/AdminThemeEditPage';
 import AdminSchedulePage from './pages/admin/AdminSchedulePage';
 
@@ -72,6 +73,7 @@ function App() {
 
                                 {/* V2.1 Reservation Flow */}
                                 <Route path="/v2-1/reservation" element={<ReservationStep1PageV21 />} />
+                                <Route path="/v2/reservation/form" element={<ReservationFormPage />} />
                                 <Route path="/v2-1/reservation/payment" element={<ReservationStep2PageV21 />} />
                                 <Route path="/v2-1/reservation/success" element={<ReservationSuccessPageV21 />} />
                             </Routes>
diff --git a/frontend/src/api/member/memberTypes.ts b/frontend/src/api/member/memberTypes.ts
index 32d4ab17..6dc36555 100644
--- a/frontend/src/api/member/memberTypes.ts
+++ b/frontend/src/api/member/memberTypes.ts
@@ -17,3 +17,9 @@ export interface SignupResponse {
     id: string;
     name: string;
 }
+
+export interface MemberSummaryRetrieveResponse {
+    id: string;
+    name: string;
+    email: string;
+}
diff --git a/frontend/src/api/payment/PaymentTypes.ts b/frontend/src/api/payment/PaymentTypes.ts
new file mode 100644
index 00000000..93b015df
--- /dev/null
+++ b/frontend/src/api/payment/PaymentTypes.ts
@@ -0,0 +1,73 @@
+export interface PaymentConfirmRequest {
+    paymentKey: string;
+    orderId: string;
+    amount: number;
+    paymentType: PaymentType;
+}
+
+export interface PaymentCancelRequest {
+    reservationId: string,
+    cancelReason: String
+}
+
+// V2 types
+export const PaymentType = {
+    NORMAL: 'NORMAL',
+    BILLING: 'BILLING',
+    BRANDPAY: 'BRANDPAY'
+} as const;
+
+export type PaymentType =
+    | typeof PaymentType.NORMAL
+    | typeof PaymentType.BILLING
+    | typeof PaymentType.BRANDPAY;
+
+export interface PaymentCreateResponseV2 {
+    paymentId: string;
+    detailId: string;
+}
+
+export interface PaymentRetrieveResponse {
+  orderId: string;
+  totalAmount: number;
+  method: string;
+  status: 'DONE' | 'CANCELED';
+  requestedAt: string;
+  approvedAt: string;
+  detail: CardPaymentDetail | BankTransferPaymentDetail | EasyPayPrepaidPaymentDetail;
+  cancellation?: CanceledPaymentDetailResponse;
+}
+
+export interface CardPaymentDetail {
+  type: 'CARD';
+  issuerCode: string;
+  cardType: 'CREDIT' | 'CHECK' | 'GIFT';
+  ownerType: 'PERSONAL' | 'CORPORATE';
+  cardNumber: string;
+  amount: number;
+  approvalNumber: string;
+  installmentPlanMonths: number;
+  isInterestFree: boolean;
+  easypayProviderName?: string;
+  easypayDiscountAmount?: number;
+}
+
+export interface BankTransferPaymentDetail {
+  type: 'BANK_TRANSFER';
+  bankName: string;
+  settlementStatus: string;
+}
+
+export interface EasyPayPrepaidPaymentDetail {
+  type: 'EASYPAY_PREPAID';
+  providerName: string;
+  amount: number;
+  discountAmount: number;
+}
+
+export interface CanceledPaymentDetailResponse {
+  cancellationRequestedAt: string; // ISO 8601 format
+  cancellationApprovedAt: string; // ISO 8601 format
+  cancelReason: string;
+  canceledBy: string;
+}
diff --git a/frontend/src/api/payment/paymentAPI.ts b/frontend/src/api/payment/paymentAPI.ts
new file mode 100644
index 00000000..c5481ec8
--- /dev/null
+++ b/frontend/src/api/payment/paymentAPI.ts
@@ -0,0 +1,10 @@
+import apiClient from "@_api/apiClient";
+import type { PaymentCancelRequest, PaymentConfirmRequest, PaymentCreateResponseV2 } from "./PaymentTypes";
+
+export const confirmPayment = async (reservationId: string, request: PaymentConfirmRequest): Promise<PaymentCreateResponseV2> => {
+    return await apiClient.post<PaymentCreateResponseV2>(`/payments?reservationId=${reservationId}`, request);
+};
+
+export const cancelPayment = async (request: PaymentCancelRequest): Promise<void> => {
+    return await apiClient.post(`/payments/cancel`, request);
+};
diff --git a/frontend/src/api/reservation/reservationAPI.ts b/frontend/src/api/reservation/reservationAPI.ts
index 01a39c4a..ca370e74 100644
--- a/frontend/src/api/reservation/reservationAPI.ts
+++ b/frontend/src/api/reservation/reservationAPI.ts
@@ -85,10 +85,7 @@ export const confirmReservationPayment = async (id: string, data: ReservationPay
     return await apiClient.post<ReservationPaymentResponse>(`/v2/reservations/${id}/pay`, data, true);
 };
 
-// POST /v2/reservations/{id}/cancel
-export const cancelReservationV2 = async (id: string, cancelReason: string): Promise<void> => {
-    return await apiClient.post(`/v2/reservations/${id}/cancel`, { cancelReason }, true);
-};
+
 
 // GET /v2/reservations
 export const fetchMyReservationsV2 = async (): Promise<ReservationSummaryListV2> => {
diff --git a/frontend/src/api/reservation/reservationAPIV2.ts b/frontend/src/api/reservation/reservationAPIV2.ts
index e69de29b..01992108 100644
--- a/frontend/src/api/reservation/reservationAPIV2.ts
+++ b/frontend/src/api/reservation/reservationAPIV2.ts
@@ -0,0 +1,23 @@
+import apiClient from '../apiClient';
+import type { PendingReservationCreateRequest, PendingReservationCreateResponse, ReservationDetailRetrieveResponse, ReservationSummaryRetrieveListResponse } from './reservationTypesV2';
+
+export const createPendingReservation = async (request: PendingReservationCreateRequest): Promise<PendingReservationCreateResponse> => {
+    return await apiClient.post<PendingReservationCreateResponse>('/reservations/pending', request);
+};
+
+export const confirmReservation = async (reservationId: string): Promise<void> => {
+    await apiClient.post(`/reservations/${reservationId}/confirm`, {});
+};
+
+
+export const cancelReservation = async (id: string, cancelReason: string): Promise<void> => {
+    return await apiClient.post(`/reservations/${id}/cancel`, { cancelReason }, true);
+};
+
+export const fetchSummaryByMember = async (): Promise<ReservationSummaryRetrieveListResponse> => {
+    return await apiClient.get<ReservationSummaryRetrieveListResponse>('/reservations/summary');
+}
+
+export const fetchDetailById = async (reservationId: string): Promise<ReservationDetailRetrieveResponse> => {
+    return await apiClient.get<ReservationDetailRetrieveResponse>(`/reservations/${reservationId}/detail`);
+}
diff --git a/frontend/src/api/reservation/reservationTypes.ts b/frontend/src/api/reservation/reservationTypes.ts
index 5501ed8c..29d20a57 100644
--- a/frontend/src/api/reservation/reservationTypes.ts
+++ b/frontend/src/api/reservation/reservationTypes.ts
@@ -1,4 +1,5 @@
-import type { MemberRetrieveResponse } from '@_api/member/memberTypes';
+import type { MemberRetrieveResponse, MemberSummaryRetrieveResponse } from '@_api/member/memberTypes';
+import type { PaymentRetrieveResponse, PaymentType } from '@_api/payment/PaymentTypes';
 import type { ThemeRetrieveResponse } from '@_api/theme/themeTypes';
 import type { TimeRetrieveResponse } from '@_api/time/timeTypes';
 
@@ -77,18 +78,6 @@ export interface ReservationSearchQuery {
     dateTo?: string;
 }
 
-// V2 types
-export const PaymentType = {
-    NORMAL: 'NORMAL',
-    BILLING: 'BILLING',
-    BRANDPAY: 'BRANDPAY'
-} as const;
-
-export type PaymentType =
-    | typeof PaymentType.NORMAL
-    | typeof PaymentType.BILLING
-    | typeof PaymentType.BRANDPAY;
-
 export const PaymentStatus = {
     IN_PROGRESS: '결제 진행 중',
     DONE: '결제 완료',
@@ -123,7 +112,7 @@ export interface ReservationPaymentRequest {
     paymentKey: string;
     orderId: string;
     amount: number;
-    paymentType: PaymentType
+    paymentType: PaymentType;
 }
 
 export interface ReservationPaymentResponse {
@@ -133,75 +122,14 @@ export interface ReservationPaymentResponse {
     paymentStatus: PaymentStatus;
 }
 
-export interface ReservationSummaryV2 {
-  id: string;
-  themeName: string;
-  date: string;
-  startAt: string;
-  status: string; // 'CONFIRMED', 'CANCELED_BY_USER', etc.
-}
 
-export interface ReservationSummaryListV2 {
-  reservations: ReservationSummaryV2[];
-}
 
 export interface ReservationDetailV2 {
   id: string;
-  user: UserDetailV2;
+  user: MemberSummaryRetrieveResponse;
   themeName: string;
   date: string;
   startAt: string;
   applicationDateTime: string; 
-  payment: PaymentV2;
-  cancellation: CancellationV2 | null;
-}
-
-export interface UserDetailV2 {
-    id: string;
-    name: string;
-    email: string;
-}
-
-export interface PaymentV2 {
-  orderId: string;
-  totalAmount: number;
-  method: string;
-  status: 'DONE' | 'CANCELED';
-  requestedAt: string;
-  approvedAt: string;
-  detail: CardPaymentDetailV2 | BankTransferPaymentDetailV2 | EasyPayPrepaidPaymentDetailV2;
-}
-
-export interface CardPaymentDetailV2 {
-  type: 'CARD';
-  issuerCode: string;
-  cardType: 'CREDIT' | 'CHECK' | 'GIFT';
-  ownerType: 'PERSONAL' | 'CORPORATE';
-  cardNumber: string;
-  amount: number;
-  approvalNumber: string;
-  installmentPlanMonths: number;
-  isInterestFree: boolean;
-  easypayProviderName?: string;
-  easypayDiscountAmount?: number;
-}
-
-export interface BankTransferPaymentDetailV2 {
-  type: 'BANK_TRANSFER';
-  bankName: string;
-  settlementStatus: string;
-}
-
-export interface EasyPayPrepaidPaymentDetailV2 {
-  type: 'EASYPAY_PREPAID';
-  providerName: string;
-  amount: number;
-  discountAmount: number;
-}
-
-export interface CancellationV2 {
-  cancellationRequestedAt: string; // ISO 8601 format
-  cancellationApprovedAt: string; // ISO 8601 format
-  cancelReason: string;
-  canceledBy: string;
+  payment: PaymentRetrieveResponse;
 }
diff --git a/frontend/src/api/reservation/reservationTypesV2.ts b/frontend/src/api/reservation/reservationTypesV2.ts
new file mode 100644
index 00000000..3dc595fa
--- /dev/null
+++ b/frontend/src/api/reservation/reservationTypesV2.ts
@@ -0,0 +1,58 @@
+import type { MemberSummaryRetrieveResponse } from "@_api/member/memberTypes";
+import type { PaymentRetrieveResponse } from "@_api/payment/PaymentTypes";
+
+export const ReservationStatusV2 = {
+    PENDING: 'PENDING',
+    CONFIRMED: 'CONFIRMED',
+    CANCELED: 'CANCELED',
+    FAILED: 'FAILED',
+    EXPIRED: 'EXPIRED'
+} as const;
+
+export type ReservationStatusV2 =
+    | typeof ReservationStatusV2.PENDING
+    | typeof ReservationStatusV2.CONFIRMED
+    | typeof ReservationStatusV2.CANCELED
+    | typeof ReservationStatusV2.FAILED
+    | typeof ReservationStatusV2.EXPIRED;
+
+export interface PendingReservationCreateRequest {
+  scheduleId: string,
+  reserverName: string,
+  reserverContact: string,
+  participantCount: number,
+  requirement: string
+}
+
+export interface PendingReservationCreateResponse {
+  id: string
+}
+
+export interface ReservationSummaryRetrieveResponse {
+  id: string;
+  themeName: string;
+  date: string;
+  startAt: string;
+  status: ReservationStatusV2;
+}
+
+export interface ReservationSummaryRetrieveListResponse {
+  reservations: ReservationSummaryRetrieveResponse[];
+}
+
+export interface ReservationDetailRetrieveResponse {
+    id: string;
+    member: MemberSummaryRetrieveResponse;
+    applicationDateTime: string; 
+    payment: PaymentRetrieveResponse;
+}
+
+export interface ReservationDetail {
+    id: string;
+    themeName: string;
+    date: string;
+    startAt: string;
+    member: MemberSummaryRetrieveResponse;
+    applicationDateTime: string; 
+    payment: PaymentRetrieveResponse;
+}
diff --git a/frontend/src/api/schedule/scheduleAPI.ts b/frontend/src/api/schedule/scheduleAPI.ts
index 403a5204..f828fa2b 100644
--- a/frontend/src/api/schedule/scheduleAPI.ts
+++ b/frontend/src/api/schedule/scheduleAPI.ts
@@ -30,3 +30,7 @@ export const updateSchedule = async (id: string, request: ScheduleUpdateRequest)
 export const deleteSchedule = async (id: string): Promise<void> => {
     await apiClient.del(`/schedules/${id}`);
 };
+
+export const holdSchedule = async (id: string): Promise<void> => {
+    await apiClient.patch(`/schedules/${id}/hold`, {});
+};
diff --git a/frontend/src/api/schedule/scheduleTypes.ts b/frontend/src/api/schedule/scheduleTypes.ts
index 73550b46..6230cf01 100644
--- a/frontend/src/api/schedule/scheduleTypes.ts
+++ b/frontend/src/api/schedule/scheduleTypes.ts
@@ -1,6 +1,6 @@
 export enum ScheduleStatus {
     AVAILABLE = 'AVAILABLE',
-    PENDING = 'PENDING',
+    HOLD = 'HOLD',
     RESERVED = 'RESERVED',
     BLOCKED = 'BLOCKED',
 }
diff --git a/frontend/src/css/reservation-v2-1.css b/frontend/src/css/reservation-v2-1.css
index 6e56c6ba..76820556 100644
--- a/frontend/src/css/reservation-v2-1.css
+++ b/frontend/src/css/reservation-v2-1.css
@@ -417,4 +417,81 @@
 }
 .modal-actions .confirm-button:hover {
     background-color: #1B64DA;
-}
\ No newline at end of file
+}
+
+/* Styles for ReservationFormPage */
+.form-group {
+    margin-bottom: 20px;
+}
+
+.form-group label {
+    display: block;
+    font-weight: bold;
+    margin-bottom: 8px;
+    color: #333;
+}
+
+.form-group input[type="text"],
+.form-group input[type="tel"],
+.form-group input[type="number"],
+.form-group textarea {
+    width: 100%;
+    padding: 12px;
+    border: 1px solid #ccc;
+    border-radius: 8px;
+    font-size: 16px;
+    box-sizing: border-box;
+    transition: border-color 0.2s, box-shadow 0.2s;
+}
+
+.form-group input:focus, .form-group textarea:focus {
+    outline: none;
+    border-color: #3182F6;
+    box-shadow: 0 0 0 3px rgba(49, 130, 246, 0.2);
+}
+
+.form-group textarea {
+    resize: vertical;
+    min-height: 100px;
+}
+
+.participant-control {
+    display: flex;
+    align-items: center;
+}
+
+.participant-control input {
+    text-align: center;
+    border-left: none;
+    border-right: none;
+    width: 60px;
+    border-radius: 0;
+}
+
+.participant-control button {
+    width: 44px;
+    height: 44px;
+    border: 1px solid #ccc;
+    background-color: #f0f0f0;
+    font-size: 20px;
+    cursor: pointer;
+    transition: background-color 0.2s;
+}
+
+.participant-control button:hover:not(:disabled) {
+    background-color: #e0e0e0;
+}
+
+.participant-control button:disabled {
+    background-color: #e9ecef;
+    cursor: not-allowed;
+    color: #aaa;
+}
+
+.participant-control button:first-of-type {
+    border-radius: 8px 0 0 8px;
+}
+
+.participant-control button:last-of-type {
+    border-radius: 0 8px 8px 0;
+}
diff --git a/frontend/src/pages/admin/AdminSchedulePage.tsx b/frontend/src/pages/admin/AdminSchedulePage.tsx
index 28657fe6..7f8c5793 100644
--- a/frontend/src/pages/admin/AdminSchedulePage.tsx
+++ b/frontend/src/pages/admin/AdminSchedulePage.tsx
@@ -11,7 +11,7 @@ const getScheduleStatusText = (status: ScheduleStatus): string => {
     switch (status) {
         case ScheduleStatus.AVAILABLE:
             return '예약 가능';
-        case ScheduleStatus.PENDING:
+        case ScheduleStatus.HOLD:
             return '예약 진행 중';
         case ScheduleStatus.RESERVED:
             return '예약 완료';
diff --git a/frontend/src/pages/admin/AdminThemeEditPage.tsx b/frontend/src/pages/admin/AdminThemeEditPage.tsx
index 88a8fc51..0121d5dd 100644
--- a/frontend/src/pages/admin/AdminThemeEditPage.tsx
+++ b/frontend/src/pages/admin/AdminThemeEditPage.tsx
@@ -193,7 +193,7 @@ const AdminThemeEditPage: React.FC = () => {
 
                         <div className="form-row">
                             <div className="form-group">
-                                <label className="form-label" htmlFor="price">가격 (원)</label>
+                                <label className="form-label" htmlFor="price">1인당 요금 (원)</label>
                                 <input id="price" name="price" type="number" className="form-input" value={theme.price} onChange={handleChange} required disabled={!isEditing} />
                             </div>
                             <div className="form-group">
diff --git a/frontend/src/pages/admin/ThemePage.tsx b/frontend/src/pages/admin/ThemePage.tsx
index f2daaba4..68eec8b0 100644
--- a/frontend/src/pages/admin/ThemePage.tsx
+++ b/frontend/src/pages/admin/ThemePage.tsx
@@ -37,7 +37,7 @@ const AdminThemePage: React.FC = () => {
         navigate('/admin/theme/edit/new');
     };
     
-    const handleManageClick = (themeId: number) => {
+    const handleManageClick = (themeId: string) => {
         navigate(`/admin/theme/edit/${themeId}`);
     };
 
@@ -54,7 +54,7 @@ const AdminThemePage: React.FC = () => {
                             <tr>
                                 <th>이름</th>
                                 <th>난이도</th>
-                                <th>가격</th>
+                                <th>1인당 요금</th>
                                 <th>공개여부</th>
                                 <th></th>
                             </tr>
diff --git a/frontend/src/pages/v2/MyReservationPageV2.tsx b/frontend/src/pages/v2/MyReservationPageV2.tsx
index ccbcb99e..a229b953 100644
--- a/frontend/src/pages/v2/MyReservationPageV2.tsx
+++ b/frontend/src/pages/v2/MyReservationPageV2.tsx
@@ -1,10 +1,8 @@
+import { cancelPayment } from '@_api/payment/paymentAPI';
+import type { PaymentRetrieveResponse } from '@_api/payment/PaymentTypes';
+import { cancelReservation, fetchDetailById, fetchSummaryByMember } from '@_api/reservation/reservationAPIV2';
+import type { ReservationDetail, ReservationSummaryRetrieveResponse } from '@_api/reservation/reservationTypesV2';
 import React, { useEffect, useState } from 'react';
-import {
-  cancelReservationV2,
-  fetchMyReservationsV2,
-  fetchReservationDetailV2
-} from '../../api/reservation/reservationAPI';
-import type { PaymentV2, ReservationDetailV2, ReservationSummaryV2 } from '../../api/reservation/reservationTypes';
 import '../../css/my-reservation-v2.css';
 
 const formatDisplayDateTime = (dateTime: any): string => {
@@ -78,7 +76,7 @@ const formatCardDateTime = (dateStr: string, timeStr: string): string => {
 
 // --- Cancellation View Component ---
 const CancellationView: React.FC<{
-  reservation: ReservationDetailV2;
+  reservation: ReservationDetail;
   onCancelSubmit: (reason: string) => void;
   onBack: () => void;
   isCancelling: boolean;
@@ -119,13 +117,12 @@ const CancellationView: React.FC<{
 };
 
 
-// --- Reservation Detail View Component ---
 const ReservationDetailView: React.FC<{
-  reservation: ReservationDetailV2;
+  reservation: ReservationDetail;
   onGoToCancel: () => void;
 }> = ({ reservation, onGoToCancel }) => {
 
-  const renderPaymentDetails = (payment: PaymentV2) => {
+  const renderPaymentDetails = (payment: PaymentRetrieveResponse) => {
     const { detail } = payment;
 
     switch (detail.type) {
@@ -178,8 +175,8 @@ const ReservationDetailView: React.FC<{
         <h3>예약 정보</h3>
         <p><strong>예약 테마:</strong> {reservation.themeName}</p>
         <p><strong>이용 예정일:</strong> {formatCardDateTime(reservation.date, reservation.startAt)}</p>
-        <p><strong>예약자 이름:</strong> {reservation.user.name}</p>
-        <p><strong>예약자 이메일:</strong> {reservation.user.email}</p>
+        <p><strong>예약자 이름:</strong> {reservation.member.name}</p>
+        <p><strong>예약자 이메일:</strong> {reservation.member.email}</p>
         <p><strong>예약 신청 일시:</strong> {formatDisplayDateTime(reservation.applicationDateTime)}</p>
       </div>
       <div className="modal-section-v2">
@@ -188,13 +185,13 @@ const ReservationDetailView: React.FC<{
         {renderPaymentDetails(reservation.payment)}
         <p><strong>결제 승인 일시:</strong> {formatDisplayDateTime(reservation.payment.approvedAt)}</p>
       </div>
-      {reservation.cancellation && (
+      {reservation.payment.cancellation && (
         <div className="modal-section-v2 cancellation-section-v2">
           <h3>취소 정보</h3>
-          <p><strong>취소 요청 일시:</strong> {formatDisplayDateTime(reservation.cancellation.cancellationRequestedAt)}</p>
-          <p><strong>환불 완료 일시:</strong> {formatDisplayDateTime(reservation.cancellation.cancellationApprovedAt)}</p>
-          <p><strong>취소 사유:</strong> {reservation.cancellation.cancelReason}</p>
-          <p><strong>취소 요청자:</strong> {reservation.cancellation.canceledBy == reservation.user.id ? '회원 본인' : '관리자'}</p>
+          <p><strong>취소 요청 일시:</strong> {formatDisplayDateTime(reservation.payment.cancellation.cancellationRequestedAt)}</p>
+          <p><strong>환불 완료 일시:</strong> {formatDisplayDateTime(reservation.payment.cancellation.cancellationApprovedAt)}</p>
+          <p><strong>취소 사유:</strong> {reservation.payment.cancellation.cancelReason}</p>
+          <p><strong>취소 요청자:</strong> {reservation.payment.cancellation.canceledBy == reservation.member.id ? '회원 본인' : '관리자'}</p>
         </div>
       )}
       {reservation.payment.status !== 'CANCELED' && (
@@ -208,11 +205,11 @@ const ReservationDetailView: React.FC<{
 
 // --- Main Page Component ---
 const MyReservationPageV2: React.FC = () => {
-  const [reservations, setReservations] = useState<ReservationSummaryV2[]>([]);
+  const [reservations, setReservations] = useState<ReservationSummaryRetrieveResponse[]>([]);
   const [isLoading, setIsLoading] = useState(true);
   const [error, setError] = useState<string | null>(null);
 
-  const [selectedReservation, setSelectedReservation] = useState<ReservationDetailV2 | null>(null);
+  const [selectedReservation, setSelectedReservation] = useState<ReservationDetail | null>(null);
   const [isModalOpen, setIsModalOpen] = useState(false);
   const [isDetailLoading, setIsDetailLoading] = useState(false);
   const [detailError, setDetailError] = useState<string | null>(null);
@@ -223,7 +220,7 @@ const MyReservationPageV2: React.FC = () => {
   const loadReservations = async () => {
     try {
       setIsLoading(true);
-      const data = await fetchMyReservationsV2();
+      const data = await fetchSummaryByMember();
       setReservations(data.reservations);
       setError(null);
     } catch (err) {
@@ -237,14 +234,21 @@ const MyReservationPageV2: React.FC = () => {
     loadReservations();
   }, []);
 
-  const handleShowDetail = async (id: string) => {
+  const handleShowDetail = async (id: string, themeName: string, date: string, time: string) => {
     try {
       setIsDetailLoading(true);
       setDetailError(null);
       setModalView('detail');
-      const detailData = await fetchReservationDetailV2(id);
-      console.log('상세 정보:', detailData);
-      setSelectedReservation(detailData);
+      const detailData = await fetchDetailById(id);
+      setSelectedReservation({
+        id: detailData.id,
+        themeName: themeName,
+        date: date,
+        startAt: time,
+        member: detailData.member,
+        applicationDateTime: detailData.applicationDateTime,
+        payment: detailData.payment
+      });
       setIsModalOpen(true);
     } catch (err) {
       setDetailError('예약 상세 정보를 불러오는 데 실패했습니다.');
@@ -268,16 +272,18 @@ const MyReservationPageV2: React.FC = () => {
     try {
       setIsCancelling(true);
       setDetailError(null);
-      await cancelReservationV2(selectedReservation.id, reason);
+      await cancelReservation(selectedReservation.id, reason);
+      cancelPayment({ reservationId: selectedReservation.id, cancelReason: reason });
       alert('예약을 취소했어요. 결제 취소까지는 3-5일 정도 소요될 수 있어요.');
       handleCloseModal();
-      loadReservations(); // Refresh the list
+      await loadReservations(); // Refresh the list
     } catch (err) {
       setDetailError(err instanceof Error ? err.message : '예약 취소에 실패했습니다.');
     } finally {
-      setIsCancelling(false);
+      setIsCancelling(true);
     }
   };
+  console.log("reservations=", reservations);
 
   return (
     <div className="my-reservation-container-v2">
@@ -289,14 +295,13 @@ const MyReservationPageV2: React.FC = () => {
       {!isLoading && !error && (
         <div className="reservation-list-v2">
           {reservations.map((res) => (
-            console.log(res),
-            <div key={res.id} className={`reservation-summary-card-v2 status-${res.status.toLowerCase()}`}>
+            <div key={res.id} className={`reservation-summary-card-v2 status-${res.status.toString().toLowerCase()}`}>
               <div className="summary-details-v2">
                 <h3 className="summary-theme-name-v2">{res.themeName}</h3>
                 <p className="summary-datetime-v2">{formatCardDateTime(res.date, res.startAt)}</p>
               </div>
               <button
-                onClick={() => handleShowDetail(res.id)}
+                onClick={() => handleShowDetail(res.id, res.themeName, res.date, res.startAt)}
                 disabled={isDetailLoading}
                 className="detail-button-v2"
               >
diff --git a/frontend/src/pages/v2/ReservationFormPage.tsx b/frontend/src/pages/v2/ReservationFormPage.tsx
new file mode 100644
index 00000000..f5243b53
--- /dev/null
+++ b/frontend/src/pages/v2/ReservationFormPage.tsx
@@ -0,0 +1,121 @@
+import { isLoginRequiredError } from '@_api/apiClient';
+import { createPendingReservation } from '@_api/reservation/reservationAPIV2';
+import '@_css/reservation-v2-1.css';
+import React, { useState } from 'react';
+import { useLocation, useNavigate } from 'react-router-dom';
+import { formatDate, formatTime } from 'src/util/DateTimeFormatter';
+
+const ReservationFormPage: React.FC = () => {
+    const navigate = useNavigate();
+    const location = useLocation();
+    const { scheduleId, theme, date, time } = location.state || {};
+
+    const [reserverName, setReserverName] = useState('');
+    const [reserverContact, setReserverContact] = useState('');
+    const [participantCount, setParticipantCount] = useState(2);
+    const [requirement, setRequirement] = useState('');
+
+    const handleError = (err: any) => {
+        if (isLoginRequiredError(err)) {
+            alert('로그인이 필요해요.');
+            navigate('/login', { state: { from: location } });
+        } else {
+            const message = err.response?.data?.message || '알 수 없는 오류가 발생했습니다.';
+            alert(message);
+            console.error(err);
+        }
+    };
+
+    const handleCountChange = (delta: number) => {
+        setParticipantCount(prev => Math.max(theme.minParticipants, Math.min(theme.maxParticipants, prev + delta)));
+    };
+
+    const handlePayment = () => {
+        if (!reserverName || !reserverContact) {
+            alert('예약자명과 연락처를 입력해주세요.');
+            return;
+        }
+
+        const reservationData = {
+            scheduleId,
+            reserverName,
+            reserverContact,
+            participantCount,
+            requirement,
+        };
+
+        createPendingReservation(reservationData)
+            .then(res => {
+                navigate('/v2-1/reservation/payment', {
+                    state: {
+                        reservationId: res.id,
+                        themeName: theme.name,
+                        date: date,
+                        startAt: time,
+                        price: theme.price * participantCount,
+                    }
+                });
+            })
+            .catch(handleError);
+    };
+
+    if (!scheduleId || !theme) {
+        // Handle case where state is not passed correctly
+        return (
+            <div className="reservation-v21-container">
+                <h2 className="page-title">잘못된 접근</h2>
+                <p>예약 정보가 올바르지 않습니다. 예약 페이지로 다시 이동해주세요.</p>
+                <button onClick={() => navigate('/v2-1/reservation')} className="next-step-button">예약 페이지로</button>
+            </div>
+        );
+    }
+
+    return (
+        <div className="reservation-v21-container">
+            <h2 className="page-title">예약 정보 입력</h2>
+            
+            <div className="step-section">
+                <h3>예약 내용 확인</h3>
+                <p><strong>테마:</strong> {theme.name}</p>
+                <p><strong>날짜:</strong> {formatDate(date)}</p>
+                <p><strong>시간:</strong> {formatTime(time)}</p>
+            </div>
+
+            <div className="step-section">
+                <h3>예약자 정보</h3>
+                <div className="form-group">
+                    <label htmlFor="reserverName">예약자명</label>
+                    <input type="text" id="reserverName" value={reserverName} onChange={e => setReserverName(e.target.value)} />
+                </div>
+                <div className="form-group">
+                    <label htmlFor="reserverContact">연락처</label>
+                    <input type="tel" id="reserverContact" value={reserverContact} onChange={e => setReserverContact(e.target.value)} placeholder="'-' 없이 입력"/>
+                </div>
+                <div className="form-group">
+                    <label>인원</label>
+                    <div className="participant-control">
+                        <input 
+                            type="number" 
+                            value={participantCount} 
+                            onChange={e => setParticipantCount(Math.max(theme.minParticipants, Math.min(theme.maxParticipants, Number(e.target.value))))}
+                            min={theme.minParticipants}
+                            max={theme.maxParticipants}
+                        />
+                    </div>
+                </div>
+                <div className="form-group">
+                    <label htmlFor="requirement">요청사항</label>
+                    <textarea id="requirement" value={requirement} onChange={e => setRequirement(e.target.value)} />
+                </div>
+            </div>
+
+            <div className="next-step-button-container">
+                <button onClick={handlePayment} className="next-step-button">
+                    결제하기
+                </button>
+            </div>
+        </div>
+    );
+};
+
+export default ReservationFormPage;
diff --git a/frontend/src/pages/v2/ReservationStep1PageV21.tsx b/frontend/src/pages/v2/ReservationStep1PageV21.tsx
index 51286bb0..0910bfc8 100644
--- a/frontend/src/pages/v2/ReservationStep1PageV21.tsx
+++ b/frontend/src/pages/v2/ReservationStep1PageV21.tsx
@@ -1,7 +1,6 @@
 import { isLoginRequiredError } from '@_api/apiClient';
-import { createPendingReservation } from '@_api/reservation/reservationAPI';
-import { findAvailableThemesByDate, findSchedules } from '@_api/schedule/scheduleAPI';
-import type { ScheduleRetrieveResponse } from '@_api/schedule/scheduleTypes';
+import { holdSchedule, findAvailableThemesByDate, findSchedules } from '@_api/schedule/scheduleAPI';
+import { ScheduleStatus, type ScheduleRetrieveResponse } from '@_api/schedule/scheduleTypes';
 import { findThemesByIds } from '@_api/theme/themeAPI';
 import { Difficulty } from '@_api/theme/themeTypes';
 import '@_css/reservation-v2-1.css';
@@ -68,7 +67,9 @@ const ReservationStep1PageV21: React.FC = () => {
             const dateStr = selectedDate.toLocaleDateString('en-CA'); // yyyy-mm-dd
             findAvailableThemesByDate(dateStr)
                 .then(res => {
+                    console.log('Available themes response:', res);
                     const themeIds: string[] = res.themeIds;
+                    console.log('Available theme IDs:', themeIds);
                     if (themeIds.length > 0) {
                         return findThemesByIds({ themeIds });
                     } else {
@@ -104,23 +105,26 @@ const ReservationStep1PageV21: React.FC = () => {
             alert('날짜, 테마, 시간을 모두 선택해주세요.');
             return;
         }
-        if (selectedSchedule.status !== 'AVAILABLE') {
+        if (selectedSchedule.status !== ScheduleStatus.AVAILABLE) {
             alert('예약할 수 없는 시간입니다.');
             return;
         }
         setIsConfirmModalOpen(true);
     };
 
-    const handleConfirmPayment = () => {
-        if (!selectedDate || !selectedTheme || !selectedSchedule) return;
+    const handleConfirmReservation = () => {
+        if (!selectedSchedule) return;
 
-        const reservationData = {
-            scheduleId: selectedSchedule.id,
-        };
-
-        createPendingReservation(reservationData)
-            .then((res) => {
-                navigate('/v2-1/reservation/payment', { state: { reservation: res } });
+        holdSchedule(selectedSchedule.id)
+            .then(() => {
+                navigate('/v2/reservation/form', { 
+                    state: { 
+                        scheduleId: selectedSchedule.id,
+                        theme: selectedTheme,
+                        date: selectedDate.toLocaleDateString('en-CA'),
+                        time: selectedSchedule.time,
+                    } 
+                });
             })
             .catch(handleError)
             .finally(() => setIsConfirmModalOpen(false));
@@ -197,8 +201,19 @@ const ReservationStep1PageV21: React.FC = () => {
         setSelectedTheme(theme);
         setIsThemeModalOpen(true);
     };
+    
+    const getStatusText = (status: ScheduleStatus) => {
+        switch (status) {
+            case ScheduleStatus.AVAILABLE:
+                return '예약가능';
+            case ScheduleStatus.HOLD:
+                return '예약 진행중';
+            default:
+                return '예약불가';
+        }
+    };
 
-    const isButtonDisabled = !selectedDate || !selectedTheme || !selectedSchedule || selectedSchedule.status !== 'AVAILABLE';
+    const isButtonDisabled = !selectedDate || !selectedTheme || !selectedSchedule || selectedSchedule.status !== ScheduleStatus.AVAILABLE;
 
     return (
         <div className="reservation-v21-container">
@@ -221,7 +236,7 @@ const ReservationStep1PageV21: React.FC = () => {
                             <div className="theme-info">
                                 <h4>{theme.name}</h4>
                                 <div className="theme-meta">
-                                    <p><strong>가격:</strong> {theme.price.toLocaleString()}원</p>
+                                    <p><strong>1인당 요금:</strong> {theme.price.toLocaleString()}원</p>
                                     <p><strong>난이도:</strong> {getDifficultyText(theme.difficulty)}</p>
                                     <p><strong>참여 가능 인원:</strong> {theme.minParticipants} ~ {theme.maxParticipants}명</p>
                                     <p><strong>예상 소요 시간:</strong> {theme.expectedMinutesFrom} ~ {theme.expectedMinutesTo}분</p>
@@ -240,11 +255,11 @@ const ReservationStep1PageV21: React.FC = () => {
                     {schedules.length > 0 ? schedules.map(schedule => (
                         <div
                             key={schedule.id}
-                            className={`time-slot ${selectedSchedule?.id === schedule.id ? 'active' : ''} ${schedule.status !== 'AVAILABLE' ? 'disabled' : ''}`}
-                            onClick={() => schedule.status === 'AVAILABLE' && setSelectedSchedule(schedule)}
+                            className={`time-slot ${selectedSchedule?.id === schedule.id ? 'active' : ''} ${schedule.status !== ScheduleStatus.AVAILABLE ? 'disabled' : ''}`}
+                            onClick={() => schedule.status === ScheduleStatus.AVAILABLE && setSelectedSchedule(schedule)}
                         >
                             {schedule.time}
-                            <span className="time-availability">{schedule.status === 'AVAILABLE' ? '예약가능' : '예약불가'}</span>
+                            <span className="time-availability">{getStatusText(schedule.status)}</span>
                         </div>
                     )) : <div className="no-times">선택 가능한 시간이 없습니다.</div>}
                 </div>
@@ -252,7 +267,7 @@ const ReservationStep1PageV21: React.FC = () => {
 
             <div className="next-step-button-container">
                 <button className="next-step-button" disabled={isButtonDisabled} onClick={handleNextStep}>
-                    결제하기
+                    예약하기
                 </button>
             </div>
 
@@ -267,7 +282,7 @@ const ReservationStep1PageV21: React.FC = () => {
                             <p><strong>난이도:</strong> {getDifficultyText(selectedTheme.difficulty)}</p>
                             <p><strong>참여 인원:</strong> {selectedTheme.minParticipants} ~ {selectedTheme.maxParticipants}명</p>
                             <p><strong>소요 시간:</strong> {selectedTheme.expectedMinutesFrom} ~ {selectedTheme.expectedMinutesTo}분</p>
-                            <p><strong>가격:</strong> {selectedTheme.price.toLocaleString()}원</p>
+                            <p><strong>1인당 요금:</strong> {selectedTheme.price.toLocaleString()}원</p>
                         </div>
                         <div className="modal-section">
                             <h3>소개</h3>
@@ -286,11 +301,10 @@ const ReservationStep1PageV21: React.FC = () => {
                             <p><strong>날짜:</strong> {formatDate(selectedDate!!.toLocaleDateString('ko-KR'))}</p>
                             <p><strong>테마:</strong> {selectedTheme!!.name}</p>
                             <p><strong>시간:</strong> {formatTime(selectedSchedule!!.time)}</p>
-                            <p><strong>결제금액:</strong> {selectedTheme!!.price.toLocaleString()}원</p>
                         </div>
                         <div className="modal-actions">
                             <button className="cancel-button" onClick={() => setIsConfirmModalOpen(false)}>취소</button>
-                            <button className="confirm-button" onClick={handleConfirmPayment}>결제하기</button>
+                            <button className="confirm-button" onClick={handleConfirmReservation}>예약하기</button>
                         </div>
                     </div>
                 </div>
diff --git a/frontend/src/pages/v2/ReservationStep2Page.tsx b/frontend/src/pages/v2/ReservationStep2Page.tsx
index 302a3de5..5ed29d85 100644
--- a/frontend/src/pages/v2/ReservationStep2Page.tsx
+++ b/frontend/src/pages/v2/ReservationStep2Page.tsx
@@ -1,8 +1,10 @@
+import { isLoginRequiredError } from '@_api/apiClient';
+import { confirmReservationPayment } from '@_api/reservation/reservationAPI';
+import { type ReservationCreateResponse, type ReservationPaymentRequest } from '@_api/reservation/reservationTypes';
 import React, { useEffect, useRef } from 'react';
 import { useLocation, useNavigate } from 'react-router-dom';
-import { confirmReservationPayment } from '@_api/reservation/reservationAPI';
-import { isLoginRequiredError } from '@_api/apiClient';
-import { PaymentType, type ReservationCreateResponse, type ReservationPaymentRequest } from '@_api/reservation/reservationTypes';
+
+import { PaymentType } from '@_api/payment/PaymentTypes';
 import '@_css/reservation-v2.css';
 
 declare global {
@@ -49,7 +51,7 @@ const ReservationStep2Page: React.FC = () => {
 
             const paymentMethods = paymentWidget.renderPaymentMethods(
                 "#payment-method",
-                { value: 1000 }, // TODO: 테마별 가격 적용
+                { value: 1000 }, // TODO: 테마별 요금 적용
                 { variantKey: "DEFAULT" }
             );
             paymentMethodsRef.current = paymentMethods;
diff --git a/frontend/src/pages/v2/ReservationStep2PageV21.tsx b/frontend/src/pages/v2/ReservationStep2PageV21.tsx
index ae384929..0da89b2a 100644
--- a/frontend/src/pages/v2/ReservationStep2PageV21.tsx
+++ b/frontend/src/pages/v2/ReservationStep2PageV21.tsx
@@ -1,7 +1,8 @@
 import { isLoginRequiredError } from '@_api/apiClient';
-import { confirmReservationPayment } from '@_api/reservation/reservationAPI';
-import { PaymentType, type ReservationCreateResponse, type ReservationPaymentRequest } from '@_api/reservation/reservationTypes';
-import '@_css/reservation-v2-1.css'; // Reuse the new CSS for consistency
+import { confirmPayment } from '@_api/payment/paymentAPI';
+import { PaymentType, type PaymentConfirmRequest } from '@_api/payment/PaymentTypes';
+import { confirmReservation } from '@_api/reservation/reservationAPIV2';
+import '@_css/reservation-v2-1.css';
 import React, { useEffect, useRef } from 'react';
 import { useLocation, useNavigate } from 'react-router-dom';
 import { formatDate, formatTime } from 'src/util/DateTimeFormatter';
@@ -12,16 +13,14 @@ declare global {
     }
 }
 
-// This component is designed to work with the state passed from ReservationStep1PageV21
 const ReservationStep2PageV21: React.FC = () => {
     const navigate = useNavigate();
     const location = useLocation();
     const paymentWidgetRef = useRef<any>(null);
     const paymentMethodsRef = useRef<any>(null);
 
-    // The reservation object now contains the price
-    const reservation: ReservationCreateResponse & { price: number } | undefined = location.state?.reservation;
-    console.log(reservation)
+    const { reservationId, themeName, date, startAt, price } = location.state || {};
+
     const handleError = (err: any) => {
         if (isLoginRequiredError(err)) {
             alert('로그인이 필요해요.');
@@ -34,7 +33,7 @@ const ReservationStep2PageV21: React.FC = () => {
     };
 
     useEffect(() => {
-        if (!reservation) {
+        if (!reservationId) {
             alert('잘못된 접근입니다.');
             navigate('/v2-1/reservation');
             return;
@@ -52,15 +51,15 @@ const ReservationStep2PageV21: React.FC = () => {
 
             const paymentMethods = paymentWidget.renderPaymentMethods(
                 "#payment-method",
-                { value: reservation.price }, // Use the price from the reservation object
+                { value: price },
                 { variantKey: "DEFAULT" }
             );
             paymentMethodsRef.current = paymentMethods;
         };
-    }, [reservation, navigate]);
+    }, [reservationId, price, navigate]);
 
     const handlePayment = () => {
-        if (!paymentWidgetRef.current || !reservation) {
+        if (!paymentWidgetRef.current || !reservationId) {
             alert('결제 위젯이 로드되지 않았거나 예약 정보가 없습니다.');
             return;
         }
@@ -70,24 +69,27 @@ const ReservationStep2PageV21: React.FC = () => {
 
         paymentWidgetRef.current.requestPayment({
             orderId: generateRandomString(),
-            orderName: `${reservation.themeName} 예약 결제`,
-            amount: reservation.price, 
+            orderName: `${themeName} 예약 결제`,
+            amount: price,
         }).then((data: any) => {
-            const paymentData: ReservationPaymentRequest = {
+            const paymentData: PaymentConfirmRequest = {
                 paymentKey: data.paymentKey,
                 orderId: data.orderId,
-                amount: data.amount,
+                amount: price, // Use the price from component state instead of widget response
                 paymentType: data.paymentType || PaymentType.NORMAL,
             };
-            confirmReservationPayment(reservation.reservationId, paymentData)
-                .then((res) => {
-                    // Navigate to the new success page
+
+            confirmPayment(reservationId, paymentData)
+                .then(() => {
+                    return confirmReservation(reservationId);
+                })
+                .then(() => {
+                    alert('결제가 완료되었어요!');
                     navigate('/v2-1/reservation/success', {
                         state: {
-                            reservation: res,
-                            themeName: reservation.themeName,
-                            date: reservation.date,
-                            startAt: reservation.startAt,
+                            themeName,
+                            date,
+                            startAt,
                         }
                     });
                 })
@@ -98,22 +100,19 @@ const ReservationStep2PageV21: React.FC = () => {
         });
     };
 
-    if (!reservation) {
+    if (!reservationId) {
         return null;
     }
 
-    const date = formatDate(reservation.date)
-    const time = formatTime(reservation.startAt);
-
     return (
         <div className="reservation-v21-container">
-             <h2 className="page-title">결제하기</h2>
+            <h2 className="page-title">결제하기</h2>
             <div className="step-section">
                 <h3>결제 정보 확인</h3>
-                <p><strong>테마:</strong> {reservation.themeName}</p>
-                <p><strong>날짜:</strong> {date}</p>
-                <p><strong>시간:</strong> {time}</p>
-                <p><strong>금액:</strong> {reservation.price.toLocaleString()}원</p>
+                <p><strong>테마:</strong> {themeName}</p>
+                <p><strong>날짜:</strong> {formatDate(date)}</p>
+                <p><strong>시간:</strong> {formatTime(startAt)}</p>
+                <p><strong>금액:</strong> {price.toLocaleString()}원</p>
             </div>
             <div className="step-section">
                 <h3>결제 수단</h3>
@@ -122,7 +121,7 @@ const ReservationStep2PageV21: React.FC = () => {
             </div>
             <div className="next-step-button-container">
                 <button onClick={handlePayment} className="next-step-button">
-                    {reservation.price.toLocaleString()}원 결제하기
+                    {price.toLocaleString()}원 결제하기
                 </button>
             </div>
         </div>
diff --git a/frontend/src/pages/v2/ReservationSuccessPageV21.tsx b/frontend/src/pages/v2/ReservationSuccessPageV21.tsx
index 4694ff65..defa9797 100644
--- a/frontend/src/pages/v2/ReservationSuccessPageV21.tsx
+++ b/frontend/src/pages/v2/ReservationSuccessPageV21.tsx
@@ -1,25 +1,16 @@
-import React from 'react';
-import { useLocation, useNavigate, Link } from 'react-router-dom';
-import type { ReservationPaymentResponse } from '@_api/reservation/reservationTypes';
 import '@_css/reservation-v2-1.css'; // Reuse the new CSS
+import React from 'react';
+import { Link, useLocation } from 'react-router-dom';
 import { formatDate, formatTime } from 'src/util/DateTimeFormatter';
 
 const ReservationSuccessPageV21: React.FC = () => {
     const location = useLocation();
-    const navigate = useNavigate();
-    const { reservation, themeName, date, startAt } = (location.state as {
-        reservation: ReservationPaymentResponse;
+    const { themeName, date, startAt } = (location.state as {
         themeName: string;
         date: string;
         startAt: string;
     }) || {};
 
-    if (!reservation) {
-        React.useEffect(() => {
-            navigate('/v2-1/reservation'); // Redirect to the new reservation page on error
-        }, [navigate]);
-        return null;
-    }
     const formattedDate = formatDate(date)
     const formattedTime = formatTime(startAt);
 
diff --git a/src/main/kotlin/roomescape/common/entity/BaseEntity.kt b/src/main/kotlin/roomescape/common/entity/BaseEntity.kt
index ae6d1516..3c821aa3 100644
--- a/src/main/kotlin/roomescape/common/entity/BaseEntity.kt
+++ b/src/main/kotlin/roomescape/common/entity/BaseEntity.kt
@@ -42,7 +42,7 @@ abstract class PersistableBaseEntity(
 
     @Transient
     private var isNewEntity: Boolean = true
-): Persistable<Long> {
+) : Persistable<Long> {
     @PostLoad
     @PostPersist
     fun markNotNew() {
diff --git a/src/main/kotlin/roomescape/common/entity/BaseEntityV2.kt b/src/main/kotlin/roomescape/common/entity/BaseEntityV2.kt
index f0f94700..021f4730 100644
--- a/src/main/kotlin/roomescape/common/entity/BaseEntityV2.kt
+++ b/src/main/kotlin/roomescape/common/entity/BaseEntityV2.kt
@@ -1,11 +1,6 @@
 package roomescape.common.entity
 
-import jakarta.persistence.Column
-import jakarta.persistence.EntityListeners
-import jakarta.persistence.Id
-import jakarta.persistence.MappedSuperclass
-import jakarta.persistence.PostLoad
-import jakarta.persistence.PrePersist
+import jakarta.persistence.*
 import org.springframework.data.annotation.CreatedBy
 import org.springframework.data.annotation.CreatedDate
 import org.springframework.data.annotation.LastModifiedBy
@@ -13,10 +8,32 @@ import org.springframework.data.annotation.LastModifiedDate
 import org.springframework.data.domain.Persistable
 import org.springframework.data.jpa.domain.support.AuditingEntityListener
 import java.time.LocalDateTime
+import kotlin.jvm.Transient
 
 @MappedSuperclass
 @EntityListeners(AuditingEntityListener::class)
 abstract class AuditingBaseEntity(
+    id: Long,
+) : BaseEntityV2(id) {
+    @Column(updatable = false)
+    @CreatedDate
+    lateinit var createdAt: LocalDateTime
+
+    @Column(updatable = false)
+    @CreatedBy
+    var createdBy: Long = 0L
+
+    @Column
+    @LastModifiedDate
+    lateinit var updatedAt: LocalDateTime
+
+    @Column
+    @LastModifiedBy
+    var updatedBy: Long = 0L
+}
+
+@MappedSuperclass
+abstract class BaseEntityV2(
     @Id
     @Column(name = "id")
     private val _id: Long,
@@ -24,25 +41,6 @@ abstract class AuditingBaseEntity(
     @Transient
     private var isNewEntity: Boolean = true
 ) : Persistable<Long> {
-    @Column(updatable = false)
-    @CreatedDate
-    lateinit var createdAt: LocalDateTime
-        protected set
-
-    @Column(updatable = false)
-    @CreatedBy
-    var createdBy: Long = 0L
-        protected set
-
-    @Column
-    @LastModifiedDate
-    lateinit var updatedAt: LocalDateTime
-        protected set
-
-    @Column
-    @LastModifiedBy
-    var updatedBy: Long = 0L
-        protected set
 
     @PostLoad
     @PrePersist
diff --git a/src/main/kotlin/roomescape/common/exception/ExceptionControllerAdvice.kt b/src/main/kotlin/roomescape/common/exception/ExceptionControllerAdvice.kt
index 25b83831..b7f0d101 100644
--- a/src/main/kotlin/roomescape/common/exception/ExceptionControllerAdvice.kt
+++ b/src/main/kotlin/roomescape/common/exception/ExceptionControllerAdvice.kt
@@ -2,6 +2,7 @@ package roomescape.common.exception
 
 import io.github.oshai.kotlinlogging.KLogger
 import io.github.oshai.kotlinlogging.KotlinLogging
+import jakarta.servlet.http.HttpServletRequest
 import org.slf4j.MDC
 import org.springframework.http.HttpStatus
 import org.springframework.http.ResponseEntity
@@ -14,6 +15,7 @@ import roomescape.common.dto.response.CommonErrorResponse
 import roomescape.common.log.ApiLogMessageConverter
 import roomescape.common.log.ConvertResponseMessageRequest
 import roomescape.common.log.LogType
+import roomescape.common.log.getEndpoint
 
 private val log: KLogger = KotlinLogging.logger {}
 
@@ -22,7 +24,10 @@ class ExceptionControllerAdvice(
     private val messageConverter: ApiLogMessageConverter
 ) {
     @ExceptionHandler(value = [RoomescapeException::class])
-    fun handleRoomException(e: RoomescapeException): ResponseEntity<CommonErrorResponse> {
+    fun handleRoomException(
+        servletRequest: HttpServletRequest,
+        e: RoomescapeException
+    ): ResponseEntity<CommonErrorResponse> {
         val errorCode: ErrorCode = e.errorCode
         val httpStatus: HttpStatus = errorCode.httpStatus
         val errorResponse = CommonErrorResponse(errorCode)
@@ -30,6 +35,7 @@ class ExceptionControllerAdvice(
         val type = if (e is AuthException) LogType.AUTHENTICATION_FAILURE else LogType.APPLICATION_FAILURE
         logException(
             type = type,
+            servletRequest = servletRequest,
             httpStatus = httpStatus.value(),
             errorResponse = errorResponse,
             exception = e
@@ -41,7 +47,10 @@ class ExceptionControllerAdvice(
     }
 
     @ExceptionHandler(value = [MethodArgumentNotValidException::class, HttpMessageNotReadableException::class])
-    fun handleInvalidRequestValueException(e: Exception): ResponseEntity<CommonErrorResponse> {
+    fun handleInvalidRequestValueException(
+        servletRequest: HttpServletRequest,
+        e: Exception
+    ): ResponseEntity<CommonErrorResponse> {
         val message: String = if (e is MethodArgumentNotValidException) {
             e.bindingResult.allErrors
                 .mapNotNull { it.defaultMessage }
@@ -57,6 +66,7 @@ class ExceptionControllerAdvice(
 
         logException(
             type = LogType.APPLICATION_FAILURE,
+            servletRequest = servletRequest,
             httpStatus = httpStatus.value(),
             errorResponse = errorResponse,
             exception = e
@@ -68,7 +78,10 @@ class ExceptionControllerAdvice(
     }
 
     @ExceptionHandler(value = [Exception::class])
-    fun handleException(e: Exception): ResponseEntity<CommonErrorResponse> {
+    fun handleException(
+        servletRequest: HttpServletRequest,
+        e: Exception
+    ): ResponseEntity<CommonErrorResponse> {
         log.error(e) { "[ExceptionControllerAdvice] Unexpected exception occurred: ${e.message}" }
 
         val errorCode: ErrorCode = CommonErrorCode.UNEXPECTED_SERVER_ERROR
@@ -77,6 +90,7 @@ class ExceptionControllerAdvice(
 
         logException(
             type = LogType.UNHANDLED_EXCEPTION,
+            servletRequest = servletRequest,
             httpStatus = httpStatus.value(),
             errorResponse = errorResponse,
             exception = e
@@ -89,12 +103,14 @@ class ExceptionControllerAdvice(
 
     private fun logException(
         type: LogType,
+        servletRequest: HttpServletRequest,
         httpStatus: Int,
         errorResponse: CommonErrorResponse,
         exception: Exception
     ) {
         val commonRequest = ConvertResponseMessageRequest(
             type = type,
+            endpoint = servletRequest.getEndpoint(),
             httpStatus = httpStatus,
             startTime = MDC.get("startTime")?.toLongOrNull(),
             body = errorResponse,
diff --git a/src/main/kotlin/roomescape/common/log/ApiLogMessageConverter.kt b/src/main/kotlin/roomescape/common/log/ApiLogMessageConverter.kt
index ff3cec66..dd41a26e 100644
--- a/src/main/kotlin/roomescape/common/log/ApiLogMessageConverter.kt
+++ b/src/main/kotlin/roomescape/common/log/ApiLogMessageConverter.kt
@@ -45,6 +45,7 @@ class ApiLogMessageConverter(
     fun convertToResponseMessage(request: ConvertResponseMessageRequest): String {
         val payload: MutableMap<String, Any> = mutableMapOf()
         payload["type"] = request.type
+        payload["endpoint"] = request.endpoint
         payload["status_code"] = request.httpStatus
 
         MDC.get(MDC_MEMBER_ID_KEY)?.toLongOrNull()
@@ -75,8 +76,11 @@ class ApiLogMessageConverter(
 
 data class ConvertResponseMessageRequest(
     val type: LogType,
+    val endpoint: String,
     val httpStatus: Int = 200,
     val startTime: Long? = null,
     val body: Any? = null,
     val exception: Exception? = null
 )
+
+fun HttpServletRequest.getEndpoint(): String = "${this.method} ${this.requestURI}"
diff --git a/src/main/kotlin/roomescape/common/log/ControllerLoggingAspect.kt b/src/main/kotlin/roomescape/common/log/ControllerLoggingAspect.kt
index 5ed3f8a6..a56c19de 100644
--- a/src/main/kotlin/roomescape/common/log/ControllerLoggingAspect.kt
+++ b/src/main/kotlin/roomescape/common/log/ControllerLoggingAspect.kt
@@ -33,28 +33,31 @@ class ControllerLoggingAspect(
         val startTime: Long = MDC.get("startTime").toLongOrNull() ?: System.currentTimeMillis()
         val controllerPayload: Map<String, Any> = parsePayload(joinPoint)
 
+        val servletRequest: HttpServletRequest = servletRequest()
+
         log.info {
-            messageConverter.convertToControllerInvokedMessage(servletRequest(), controllerPayload)
+            messageConverter.convertToControllerInvokedMessage(servletRequest, controllerPayload)
         }
 
         try {
             return joinPoint.proceed()
-                .also { logSuccess(startTime, it) }
+                .also { logSuccess(servletRequest.getEndpoint(), startTime, it) }
         } catch (e: Exception) {
             throw e
         }
     }
 
-    private fun logSuccess(startTime: Long, result: Any) {
+    private fun logSuccess(endpoint: String, startTime: Long, result: Any) {
         val responseEntity = result as ResponseEntity<*>
         var convertResponseMessageRequest = ConvertResponseMessageRequest(
             type = LogType.CONTROLLER_SUCCESS,
+            endpoint = endpoint,
             httpStatus = responseEntity.statusCode.value(),
             startTime = startTime,
         )
 
         if (log.isDebugEnabled()) {
-           convertResponseMessageRequest = convertResponseMessageRequest.copy(
+            convertResponseMessageRequest = convertResponseMessageRequest.copy(
                 body = responseEntity.body
             )
         }
diff --git a/src/main/kotlin/roomescape/member/business/MemberService.kt b/src/main/kotlin/roomescape/member/business/MemberService.kt
index 1ab7afa2..7df26417 100644
--- a/src/main/kotlin/roomescape/member/business/MemberService.kt
+++ b/src/main/kotlin/roomescape/member/business/MemberService.kt
@@ -5,7 +5,6 @@ import org.springframework.stereotype.Service
 import org.springframework.transaction.annotation.Transactional
 import roomescape.member.implement.MemberFinder
 import roomescape.member.implement.MemberWriter
-import roomescape.member.infrastructure.persistence.MemberEntity
 import roomescape.member.infrastructure.persistence.Role
 import roomescape.member.web.*
 
@@ -26,11 +25,14 @@ class MemberService(
     }
 
     @Transactional(readOnly = true)
-    fun findById(memberId: Long): MemberEntity {
-        log.debug { "[MemberService.findById] 시작" }
+    fun findSummaryById(id: Long): MemberSummaryRetrieveResponse {
+        log.debug { "[MemberService.findSummaryById] 시작" }
 
-        return memberFinder.findById(memberId)
-            .also { log.info { "[MemberService.findById] 완료. memberId=${memberId}, email=${it.email}" } }
+        return memberFinder.findById(id)
+            .toSummaryRetrieveResponse()
+            .also {
+                log.info { "[MemberService.findSummaryById] 완료. memberId=${id}, email=${it.email}" }
+            }
     }
 
     @Transactional
diff --git a/src/main/kotlin/roomescape/member/infrastructure/persistence/MemberEntity.kt b/src/main/kotlin/roomescape/member/infrastructure/persistence/MemberEntity.kt
index 7ea5665d..2b287722 100644
--- a/src/main/kotlin/roomescape/member/infrastructure/persistence/MemberEntity.kt
+++ b/src/main/kotlin/roomescape/member/infrastructure/persistence/MemberEntity.kt
@@ -22,7 +22,7 @@ class MemberEntity(
     @Column(name = "role", nullable = false, length = 20)
     @Enumerated(value = EnumType.STRING)
     var role: Role
-): BaseEntity() {
+) : BaseEntity() {
     override fun getId(): Long? = _id
 
     fun isAdmin(): Boolean = role == Role.ADMIN
diff --git a/src/main/kotlin/roomescape/member/web/MemberDTO.kt b/src/main/kotlin/roomescape/member/web/MemberDTO.kt
index 1d36e37e..c1a77927 100644
--- a/src/main/kotlin/roomescape/member/web/MemberDTO.kt
+++ b/src/main/kotlin/roomescape/member/web/MemberDTO.kt
@@ -2,6 +2,7 @@ package roomescape.member.web
 
 import io.swagger.v3.oas.annotations.media.Schema
 import roomescape.member.infrastructure.persistence.MemberEntity
+import roomescape.member.infrastructure.persistence.Role
 
 fun MemberEntity.toRetrieveResponse(): MemberRetrieveResponse = MemberRetrieveResponse(
     id = id!!,
@@ -39,3 +40,17 @@ fun MemberEntity.toSignupResponse(): SignupResponse = SignupResponse(
     id = this.id!!,
     name = this.name
 )
+
+data class MemberSummaryRetrieveResponse(
+    val id: Long,
+    val name: String,
+    val email: String,
+    val role: Role
+)
+
+fun MemberEntity.toSummaryRetrieveResponse() = MemberSummaryRetrieveResponse(
+    id = this.id!!,
+    name = this.name,
+    email = this.email,
+    role = this.role
+)
diff --git a/src/main/kotlin/roomescape/payment/business/PaymentService.kt b/src/main/kotlin/roomescape/payment/business/PaymentService.kt
index b560ec06..8885dc18 100644
--- a/src/main/kotlin/roomescape/payment/business/PaymentService.kt
+++ b/src/main/kotlin/roomescape/payment/business/PaymentService.kt
@@ -1,99 +1,101 @@
 package roomescape.payment.business
 
+import io.github.oshai.kotlinlogging.KLogger
 import io.github.oshai.kotlinlogging.KotlinLogging
 import org.springframework.stereotype.Service
 import org.springframework.transaction.annotation.Transactional
-import roomescape.payment.implement.PaymentFinder
-import roomescape.payment.implement.PaymentWriter
-import roomescape.payment.infrastructure.client.PaymentApproveResponse
-import roomescape.payment.infrastructure.persistence.CanceledPaymentEntity
-import roomescape.payment.infrastructure.persistence.PaymentEntity
-import roomescape.payment.web.PaymentCancelRequest
-import roomescape.payment.web.PaymentCancelResponse
-import roomescape.payment.web.PaymentCreateResponse
-import roomescape.payment.web.toCreateResponse
-import roomescape.reservation.infrastructure.persistence.ReservationEntity
-import java.time.OffsetDateTime
+import roomescape.common.util.TransactionExecutionUtil
+import roomescape.payment.exception.PaymentErrorCode
+import roomescape.payment.exception.PaymentException
+import roomescape.payment.infrastructure.client.PaymentClientCancelResponse
+import roomescape.payment.infrastructure.client.PaymentClientConfirmResponse
+import roomescape.payment.infrastructure.client.TosspayClient
+import roomescape.payment.infrastructure.persistence.*
+import roomescape.payment.web.*
 
-private val log = KotlinLogging.logger {}
+private val log: KLogger = KotlinLogging.logger {}
 
 @Service
 class PaymentService(
-    private val paymentFinder: PaymentFinder,
-    private val paymentWriter: PaymentWriter
+    private val paymentClient: TosspayClient,
+    private val paymentRepository: PaymentRepository,
+    private val paymentDetailRepository: PaymentDetailRepository,
+    private val canceledPaymentRepository: CanceledPaymentRepository,
+    private val paymentWriter: PaymentWriter,
+    private val transactionExecutionUtil: TransactionExecutionUtil,
 ) {
-    @Transactional(readOnly = true)
-    fun existsByReservationId(reservationId: Long): Boolean {
-        log.debug { "[PaymentService.existsByReservationId] 시작: reservationId=$reservationId" }
-
-        return paymentFinder.existsPaymentByReservationId(reservationId)
-            .also { log.info { "[PaymentService.existsByReservationId] 완료: reservationId=$reservationId, isPaid=$it" } }
-    }
-
-    @Transactional
-    fun createPayment(
-        approvedPaymentInfo: PaymentApproveResponse,
-        reservation: ReservationEntity,
-    ): PaymentCreateResponse {
-        log.debug { "[PaymentService.createPayment] 시작: paymentKey=${approvedPaymentInfo.paymentKey}, reservationId=${reservation.id}" }
-
-        val created: PaymentEntity = paymentWriter.create(
-            paymentKey = approvedPaymentInfo.paymentKey,
-            orderId = approvedPaymentInfo.orderId,
-            totalAmount = approvedPaymentInfo.totalAmount,
-            approvedAt = approvedPaymentInfo.approvedAt,
-            reservation = reservation
+    fun confirm(reservationId: Long, request: PaymentConfirmRequest): PaymentCreateResponse {
+        val clientConfirmResponse: PaymentClientConfirmResponse = paymentClient.confirm(
+            paymentKey = request.paymentKey,
+            orderId = request.orderId,
+            amount = request.amount,
         )
 
-        return created.toCreateResponse()
-            .also { log.info { "[PaymentService.createPayment] 완료: paymentKey=${it.paymentKey}, reservationId=${reservation.id}, paymentId=${it.id}" } }
-    }
+        return transactionExecutionUtil.withNewTransaction(isReadOnly = false) {
+            val payment: PaymentEntity = paymentWriter.createPayment(
+                reservationId = reservationId,
+                orderId = request.orderId,
+                paymentType = request.paymentType,
+                paymentClientConfirmResponse = clientConfirmResponse
+            )
+            val detail: PaymentDetailEntity = paymentWriter.createDetail(clientConfirmResponse, payment.id)
 
-    @Transactional
-    fun createCanceledPayment(
-        canceledPaymentInfo: PaymentCancelResponse,
-        approvedAt: OffsetDateTime,
-        paymentKey: String,
-    ): CanceledPaymentEntity {
-        log.debug { "[PaymentService.createCanceledPayment] 시작: paymentKey=$paymentKey" }
-
-        val created: CanceledPaymentEntity = paymentWriter.createCanceled(
-            cancelReason = canceledPaymentInfo.cancelReason,
-            cancelAmount = canceledPaymentInfo.cancelAmount,
-            canceledAt = canceledPaymentInfo.canceledAt,
-            approvedAt = approvedAt,
-            paymentKey = paymentKey
-        )
-
-        return created.also {
-            log.info { "[PaymentService.createCanceledPayment] 완료: paymentKey=${paymentKey}, canceledPaymentId=${it.id}" }
+            PaymentCreateResponse(paymentId = payment.id, detailId = detail.id)
         }
     }
 
-    @Transactional
-    fun createCanceledPayment(reservationId: Long): PaymentCancelRequest {
-        log.debug { "[PaymentService.createCanceledPayment] 시작: reservationId=$reservationId" }
+    fun cancel(memberId: Long, request: PaymentCancelRequest) {
+        val payment: PaymentEntity = findByReservationIdOrThrow(request.reservationId)
 
-        val payment: PaymentEntity = paymentFinder.findByReservationId(reservationId)
-        val canceled: CanceledPaymentEntity = paymentWriter.createCanceled(
-            payment = payment,
-            cancelReason = "예약 취소",
-            canceledAt = OffsetDateTime.now(),
+        val clientCancelResponse: PaymentClientCancelResponse = paymentClient.cancel(
+            paymentKey = payment.paymentKey,
+            amount = payment.totalAmount,
+            cancelReason = request.cancelReason
         )
 
-        return PaymentCancelRequest(canceled.paymentKey, canceled.cancelAmount, canceled.cancelReason)
-            .also { log.info { "[PaymentService.createCanceledPayment] 완료: reservationId=$reservationId, paymentKey=${it.paymentKey}" } }
+        transactionExecutionUtil.withNewTransaction(isReadOnly = false) {
+            paymentWriter.cancel(
+                memberId = memberId,
+                payment = payment,
+                requestedAt = request.requestedAt,
+                cancelResponse = clientCancelResponse
+            )
+        }.also {
+            log.info { "[PaymentService.cancel] 결제 취소 완료: paymentId=${payment.id}" }
+        }
     }
 
-    @Transactional
-    fun updateCanceledTime(
-        paymentKey: String,
-        canceledAt: OffsetDateTime,
-    ) {
-        log.debug { "[PaymentService.updateCanceledTime] 시작: paymentKey=$paymentKey, canceledAt=$canceledAt" }
+    @Transactional(readOnly = true)
+    fun findDetailByReservationId(reservationId: Long): PaymentRetrieveResponse {
+        val payment: PaymentEntity = findByReservationIdOrThrow(reservationId)
+        val paymentDetail: PaymentDetailEntity = findDetailByPaymentIdOrThrow(payment.id)
+        val cancelDetail: CanceledPaymentEntity? = canceledPaymentRepository.findByPaymentId(payment.id)
 
-        paymentFinder.findCanceledByKey(paymentKey).apply { this.canceledAt = canceledAt }
+        return payment.toRetrieveResponse(
+            detail = paymentDetail.toPaymentDetailResponse(),
+            cancel = cancelDetail?.toCancelDetailResponse()
+        )
+    }
 
-        log.info { "[PaymentService.updateCanceledTime] 완료: paymentKey=$paymentKey, canceledAt=$canceledAt" }
+    private fun findByReservationIdOrThrow(reservationId: Long): PaymentEntity {
+        log.info { "[PaymentService.findByReservationIdOrThrow] 결제 정보 조회 시작: reservationId=: $reservationId" }
+
+        return paymentRepository.findByReservationId(reservationId)
+            ?.also { log.info { "[PaymentService.findByReservationIdOrThrow] 결제 정보 조회 완료: reservationId=$reservationId, paymentId=${it.id}" } }
+            ?: run {
+                log.warn { "[PaymentService.findByReservationIdOrThrow] 결제 정보 조회 실패: reservationId=$reservationId" }
+                throw PaymentException(PaymentErrorCode.PAYMENT_NOT_FOUND)
+            }
+    }
+
+    private fun findDetailByPaymentIdOrThrow(paymentId: Long): PaymentDetailEntity {
+        log.info { "[PaymentService.findDetailByPaymentIdOrThrow] 결제 상세 정보 조회 시작: paymentId=$paymentId" }
+
+        return paymentDetailRepository.findByPaymentId(paymentId)
+            ?.also { log.info { "[PaymentService.findDetailByPaymentIdOrThrow] 결제 상세 정보 조회 완료: paymentId=$paymentId, detailId=${it.id}}" } }
+            ?: run {
+                log.warn { "[PaymentService.findDetailByPaymentIdOrThrow] 결제 상세 정보 조회 실패: paymentId=$paymentId" }
+                throw PaymentException(PaymentErrorCode.PAYMENT_DETAIL_NOT_FOUND)
+            }
     }
 }
diff --git a/src/main/kotlin/roomescape/payment/implement/PaymentWriterV2.kt b/src/main/kotlin/roomescape/payment/business/PaymentWriter.kt
similarity index 51%
rename from src/main/kotlin/roomescape/payment/implement/PaymentWriterV2.kt
rename to src/main/kotlin/roomescape/payment/business/PaymentWriter.kt
index 3def90da..52f9de11 100644
--- a/src/main/kotlin/roomescape/payment/implement/PaymentWriterV2.kt
+++ b/src/main/kotlin/roomescape/payment/business/PaymentWriter.kt
@@ -1,4 +1,4 @@
-package roomescape.payment.implement
+package roomescape.payment.business
 
 import com.github.f4b6a3.tsid.TsidFactory
 import io.github.oshai.kotlinlogging.KLogger
@@ -7,39 +7,40 @@ import org.springframework.stereotype.Component
 import roomescape.common.config.next
 import roomescape.payment.exception.PaymentErrorCode
 import roomescape.payment.exception.PaymentException
-import roomescape.payment.infrastructure.client.v2.*
+import roomescape.payment.infrastructure.client.*
 import roomescape.payment.infrastructure.common.PaymentMethod
-import roomescape.payment.infrastructure.persistence.v2.*
-import roomescape.reservation.web.ReservationPaymentRequest
+import roomescape.payment.infrastructure.common.PaymentType
+import roomescape.payment.infrastructure.persistence.*
 import java.time.LocalDateTime
 
 private val log: KLogger = KotlinLogging.logger {}
 
 @Component
-class PaymentWriterV2(
-    private val paymentRepository: PaymentRepositoryV2,
+class PaymentWriter(
+    private val paymentRepository: PaymentRepository,
     private val paymentDetailRepository: PaymentDetailRepository,
-    private val canceledPaymentRepository: CanceledPaymentRepositoryV2,
+    private val canceledPaymentRepository: CanceledPaymentRepository,
     private val tsidFactory: TsidFactory,
 ) {
+
     fun createPayment(
         reservationId: Long,
-        request: ReservationPaymentRequest,
-        paymentConfirmResponse: PaymentConfirmResponse
-    ): PaymentEntityV2 {
-        log.debug { "[PaymentWriterV2.createPayment] 결제 승인 및 결제 정보 저장 시작: reservationId=${reservationId}, paymentKey=${request.paymentKey}" }
+        orderId: String,
+        paymentType: PaymentType,
+        paymentClientConfirmResponse: PaymentClientConfirmResponse
+    ): PaymentEntity {
+        log.info { "[PaymentWriterV2.createPayment] 결제 승인 및 결제 정보 저장 시작: reservationId=${reservationId}, paymentKey=${paymentClientConfirmResponse.paymentKey}" }
 
-        return paymentConfirmResponse.toEntity(
-            id = tsidFactory.next(), reservationId, request.orderId, request.paymentType
+        return paymentClientConfirmResponse.toEntity(
+            id = tsidFactory.next(), reservationId, orderId, paymentType
         ).also {
             paymentRepository.save(it)
-            createDetail(paymentConfirmResponse, it.id)
-            log.debug { "[PaymentWriterV2.createPayment] 결제 승인 및 결제 정보 저장 완료: reservationId=${reservationId}, paymentId=${it.id}" }
+            log.info { "[PaymentWriterV2.createPayment] 결제 승인 및 결제 정보 저장 완료: reservationId=${reservationId}, payment.id=${it.id}" }
         }
     }
 
-    private fun createDetail(
-        paymentResponse: PaymentConfirmResponse,
+    fun createDetail(
+        paymentResponse: PaymentClientConfirmResponse,
         paymentId: Long,
     ): PaymentDetailEntity {
         val method: PaymentMethod = paymentResponse.method
@@ -57,24 +58,24 @@ class PaymentWriterV2(
         throw PaymentException(PaymentErrorCode.NOT_SUPPORTED_PAYMENT_TYPE)
     }
 
-    fun createCanceledPayment(
+    fun cancel(
         memberId: Long,
-        payment: PaymentEntityV2,
+        payment: PaymentEntity,
         requestedAt: LocalDateTime,
-        cancelResponse: PaymentCancelResponseV2
-    ) {
-        log.debug { "[PaymentWriterV2.cancelPayment] 취소된 결제 정보 저장 시작: paymentId=${payment.id}, paymentKey=${payment.paymentKey}" }
+        cancelResponse: PaymentClientCancelResponse
+    ): CanceledPaymentEntity {
+        log.debug { "[PaymentWriterV2.cancelPayment] 결제 취소 정보 저장 시작: payment.id=${payment.id}" }
 
-        val canceledPayment: CanceledPaymentEntityV2 = cancelResponse.cancels.toEntity(
+        paymentRepository.save(payment.apply { this.cancel() })
+
+        return cancelResponse.cancels.toEntity(
             id = tsidFactory.next(),
             paymentId = payment.id,
             cancelRequestedAt = requestedAt,
             canceledBy = memberId
-        )
-
-        canceledPaymentRepository.save(canceledPayment).also {
-            payment.cancel()
-            log.debug { "[PaymentWriterV2.cancelPayment] 취소된 결제 정보 저장 완료: paymentId=${payment.id}, canceledPaymentId=${it.id}, paymentKey=${payment.paymentKey}" }
+        ).also {
+            canceledPaymentRepository.save(it)
+            log.debug { "[PaymentWriterV2.cancelPayment] 결제 취소 정보 저장 완료: payment.id=${payment.id}" }
         }
     }
 }
diff --git a/src/main/kotlin/roomescape/payment/docs/PaymentAPI.kt b/src/main/kotlin/roomescape/payment/docs/PaymentAPI.kt
new file mode 100644
index 00000000..98633997
--- /dev/null
+++ b/src/main/kotlin/roomescape/payment/docs/PaymentAPI.kt
@@ -0,0 +1,35 @@
+package roomescape.payment.docs
+
+import io.swagger.v3.oas.annotations.Operation
+import io.swagger.v3.oas.annotations.Parameter
+import io.swagger.v3.oas.annotations.responses.ApiResponse
+import io.swagger.v3.oas.annotations.responses.ApiResponses
+import jakarta.validation.Valid
+import org.springframework.http.ResponseEntity
+import org.springframework.web.bind.annotation.RequestBody
+import org.springframework.web.bind.annotation.RequestParam
+import roomescape.auth.web.support.LoginRequired
+import roomescape.auth.web.support.MemberId
+import roomescape.common.dto.response.CommonApiResponse
+import roomescape.payment.web.PaymentCancelRequest
+import roomescape.payment.web.PaymentConfirmRequest
+import roomescape.payment.web.PaymentCreateResponse
+
+interface PaymentAPI {
+
+    @LoginRequired
+    @Operation(summary = "결제 승인", tags = ["로그인이 필요한 API"])
+    @ApiResponses(ApiResponse(responseCode = "200", description = "성공", useReturnTypeSchema = true))
+    fun confirmPayment(
+        @RequestParam(required = true) reservationId: Long,
+        @Valid @RequestBody request: PaymentConfirmRequest
+    ): ResponseEntity<CommonApiResponse<PaymentCreateResponse>>
+
+    @LoginRequired
+    @Operation(summary = "결제 취소", tags = ["로그인이 필요한 API"])
+    @ApiResponses(ApiResponse(responseCode = "200", description = "성공", useReturnTypeSchema = true))
+    fun cancelPayment(
+        @MemberId @Parameter(hidden = true) memberId: Long,
+        @Valid @RequestBody request: PaymentCancelRequest
+    ): ResponseEntity<CommonApiResponse<Unit>>
+}
diff --git a/src/main/kotlin/roomescape/payment/implement/PaymentFinder.kt b/src/main/kotlin/roomescape/payment/implement/PaymentFinder.kt
deleted file mode 100644
index 84a64d17..00000000
--- a/src/main/kotlin/roomescape/payment/implement/PaymentFinder.kt
+++ /dev/null
@@ -1,48 +0,0 @@
-package roomescape.payment.implement
-
-import io.github.oshai.kotlinlogging.KLogger
-import io.github.oshai.kotlinlogging.KotlinLogging
-import org.springframework.stereotype.Component
-import roomescape.payment.exception.PaymentErrorCode
-import roomescape.payment.exception.PaymentException
-import roomescape.payment.infrastructure.persistence.CanceledPaymentEntity
-import roomescape.payment.infrastructure.persistence.CanceledPaymentRepository
-import roomescape.payment.infrastructure.persistence.PaymentEntity
-import roomescape.payment.infrastructure.persistence.PaymentRepository
-
-private val log: KLogger = KotlinLogging.logger {}
-
-@Component
-class PaymentFinder(
-    private val paymentRepository: PaymentRepository,
-    private val canceledPaymentRepository: CanceledPaymentRepository,
-) {
-    fun existsPaymentByReservationId(reservationId: Long): Boolean {
-        log.debug { "[PaymentFinder.existsPaymentByReservationId] 시작: reservationId=$reservationId" }
-
-        return paymentRepository.existsByReservationId(reservationId)
-            .also { log.debug { "[PaymentFinder.existsPaymentByReservationId] 완료: reservationId=$reservationId, isExist=$it" } }
-    }
-
-    fun findByReservationId(reservationId: Long): PaymentEntity {
-        log.debug { "[PaymentFinder.findByReservationId] 시작: reservationId=$reservationId" }
-
-        return paymentRepository.findByReservationId(reservationId)
-            ?.also { log.debug { "[PaymentFinder.findByReservationId] 완료: reservationId=$reservationId" } }
-            ?: run {
-                log.warn { "[PaymentFinder.findByReservationId] 실패: reservationId=$reservationId" }
-                throw PaymentException(PaymentErrorCode.PAYMENT_NOT_FOUND)
-            }
-    }
-
-    fun findCanceledByKey(paymentKey: String): CanceledPaymentEntity {
-        log.debug { "[PaymentFinder.findCanceledByKey] 시작: paymentKey=$paymentKey" }
-
-        return canceledPaymentRepository.findByPaymentKey(paymentKey)
-            ?.also { log.debug { "[PaymentFinder.findCanceledByKey] 완료: canceledPaymentId=${it.id}" } }
-            ?: run {
-                log.warn { "[PaymentFinder.findCanceledByKey] 실패: paymentKey=$paymentKey" }
-                throw PaymentException(PaymentErrorCode.CANCELED_PAYMENT_NOT_FOUND)
-            }
-    }
-}
diff --git a/src/main/kotlin/roomescape/payment/implement/PaymentFinderV2.kt b/src/main/kotlin/roomescape/payment/implement/PaymentFinderV2.kt
deleted file mode 100644
index 8b2a5a7f..00000000
--- a/src/main/kotlin/roomescape/payment/implement/PaymentFinderV2.kt
+++ /dev/null
@@ -1,53 +0,0 @@
-package roomescape.payment.implement
-
-import io.github.oshai.kotlinlogging.KLogger
-import io.github.oshai.kotlinlogging.KotlinLogging
-import org.springframework.stereotype.Component
-import roomescape.payment.exception.PaymentErrorCode
-import roomescape.payment.exception.PaymentException
-import roomescape.payment.infrastructure.persistence.v2.CanceledPaymentEntityV2
-import roomescape.payment.infrastructure.persistence.v2.CanceledPaymentRepositoryV2
-import roomescape.payment.infrastructure.persistence.v2.PaymentDetailEntity
-import roomescape.payment.infrastructure.persistence.v2.PaymentDetailRepository
-import roomescape.payment.infrastructure.persistence.v2.PaymentEntityV2
-import roomescape.payment.infrastructure.persistence.v2.PaymentRepositoryV2
-
-private val log: KLogger = KotlinLogging.logger {}
-
-@Component
-class PaymentFinderV2(
-    private val paymentRepository: PaymentRepositoryV2,
-    private val paymentDetailRepository: PaymentDetailRepository,
-    private val canceledPaymentRepository: CanceledPaymentRepositoryV2
-) {
-
-    fun findPaymentByReservationId(reservationId: Long): PaymentEntityV2 {
-        log.debug { "[PaymentFinderV2.findByReservationId] 시작: reservationId=$reservationId" }
-
-        return paymentRepository.findByReservationId(reservationId)?.also {
-            log.debug { "[PaymentFinderV2.findByReservationId] 완료: reservationId=$reservationId, paymentId=${it.id}" }
-        } ?: run {
-            log.warn { "[PaymentFinderV2.findByReservationId] 실패: reservationId=$reservationId" }
-            throw PaymentException(PaymentErrorCode.PAYMENT_NOT_FOUND)
-        }
-    }
-
-    fun findPaymentDetailByPaymentId(paymentId: Long): PaymentDetailEntity {
-        log.debug { "[PaymentFinderV2.findPaymentDetailByPaymentId] 시작: paymentId=$paymentId" }
-
-        return paymentDetailRepository.findByPaymentId(paymentId)?.also {
-            log.debug { "[PaymentFinderV2.findPaymentDetailByPaymentId] 완료: paymentId=$paymentId, detailId=${it.id}" }
-        } ?: run {
-            log.warn { "[PaymentFinderV2.findPaymentDetailByPaymentId] 실패: paymentId=$paymentId" }
-            throw PaymentException(PaymentErrorCode.PAYMENT_DETAIL_NOT_FOUND)
-        }
-    }
-
-    fun findCanceledPaymentByPaymentIdOrNull(paymentId: Long): CanceledPaymentEntityV2? {
-        log.debug { "[PaymentFinderV2.findCanceledPaymentByKey] 시작: paymentId=$paymentId" }
-
-        return canceledPaymentRepository.findByPaymentId(paymentId)?.also {
-            log.debug { "[PaymentFinderV2.findCanceledPaymentByKey] 완료: paymentId=$paymentId, canceledPaymentId=${it.id}" }
-        }
-    }
-}
diff --git a/src/main/kotlin/roomescape/payment/implement/PaymentRequester.kt b/src/main/kotlin/roomescape/payment/implement/PaymentRequester.kt
deleted file mode 100644
index bb34a34a..00000000
--- a/src/main/kotlin/roomescape/payment/implement/PaymentRequester.kt
+++ /dev/null
@@ -1,21 +0,0 @@
-package roomescape.payment.implement
-
-import org.springframework.stereotype.Component
-import roomescape.payment.infrastructure.client.v2.*
-
-@Component
-class PaymentRequester(
-    private val client: TosspaymentClientV2
-) {
-    fun requestConfirmPayment(paymentKey: String, orderId: String, amount: Int): PaymentConfirmResponse {
-        val request = PaymentConfirmRequest(paymentKey, orderId, amount)
-
-        return client.confirm(request)
-    }
-
-    fun requestCancelPayment(paymentKey: String, amount: Int, cancelReason: String): PaymentCancelResponseV2 {
-        val request = PaymentCancelRequestV2(paymentKey, amount, cancelReason)
-
-        return client.cancel(request)
-    }
-}
diff --git a/src/main/kotlin/roomescape/payment/implement/PaymentWriter.kt b/src/main/kotlin/roomescape/payment/implement/PaymentWriter.kt
deleted file mode 100644
index be815940..00000000
--- a/src/main/kotlin/roomescape/payment/implement/PaymentWriter.kt
+++ /dev/null
@@ -1,81 +0,0 @@
-package roomescape.payment.implement
-
-import com.github.f4b6a3.tsid.TsidFactory
-import io.github.oshai.kotlinlogging.KLogger
-import io.github.oshai.kotlinlogging.KotlinLogging
-import org.springframework.stereotype.Component
-import roomescape.common.config.next
-import roomescape.payment.infrastructure.persistence.CanceledPaymentEntity
-import roomescape.payment.infrastructure.persistence.CanceledPaymentRepository
-import roomescape.payment.infrastructure.persistence.PaymentEntity
-import roomescape.payment.infrastructure.persistence.PaymentRepository
-import roomescape.reservation.infrastructure.persistence.ReservationEntity
-import java.time.OffsetDateTime
-
-private val log: KLogger = KotlinLogging.logger {}
-
-@Component
-class PaymentWriter(
-    private val paymentRepository: PaymentRepository,
-    private val canceledPaymentRepository: CanceledPaymentRepository,
-    private val tsidFactory: TsidFactory,
-) {
-    fun create(
-        paymentKey: String,
-        orderId: String,
-        totalAmount: Long,
-        approvedAt: OffsetDateTime,
-        reservation: ReservationEntity
-    ): PaymentEntity {
-        log.debug { "[PaymentWriter.create] 시작: paymentKey=${paymentKey}, reservationId=${reservation.id}" }
-
-        val payment = PaymentEntity(
-            _id = tsidFactory.next(),
-            orderId = orderId,
-            paymentKey = paymentKey,
-            totalAmount = totalAmount,
-            reservation = reservation,
-            approvedAt = approvedAt
-        )
-
-        return paymentRepository.save(payment)
-            .also { log.debug { "[PaymentWriter.create] 완료: paymentId=${it.id}, reservationId=${reservation.id}" } }
-    }
-
-    fun createCanceled(
-        payment: PaymentEntity,
-        cancelReason: String,
-        canceledAt: OffsetDateTime,
-    ): CanceledPaymentEntity = createCanceled(
-        cancelReason = cancelReason,
-        canceledAt = canceledAt,
-        cancelAmount = payment.totalAmount,
-        approvedAt = payment.approvedAt,
-        paymentKey = payment.paymentKey
-    )
-
-    fun createCanceled(
-        cancelReason: String,
-        cancelAmount: Long,
-        canceledAt: OffsetDateTime,
-        approvedAt: OffsetDateTime,
-        paymentKey: String,
-    ): CanceledPaymentEntity {
-        log.debug { "[PaymentWriter.createCanceled] 시작: paymentKey=$paymentKey cancelAmount=$cancelAmount" }
-
-        val canceledPayment = CanceledPaymentEntity(
-            _id = tsidFactory.next(),
-            paymentKey = paymentKey,
-            cancelReason = cancelReason,
-            cancelAmount = cancelAmount,
-            approvedAt = approvedAt,
-            canceledAt = canceledAt
-        )
-
-        return canceledPaymentRepository.save(canceledPayment)
-            .also {
-                paymentRepository.deleteByPaymentKey(paymentKey)
-                log.debug { "[PaymentWriter.createCanceled] 완료: paymentKey=${paymentKey}, canceledPaymentId=${it.id}" }
-            }
-    }
-}
diff --git a/src/main/kotlin/roomescape/payment/infrastructure/client/PaymentCancelResponseDeserializer.kt b/src/main/kotlin/roomescape/payment/infrastructure/client/PaymentCancelResponseDeserializer.kt
deleted file mode 100644
index 3dc16b95..00000000
--- a/src/main/kotlin/roomescape/payment/infrastructure/client/PaymentCancelResponseDeserializer.kt
+++ /dev/null
@@ -1,29 +0,0 @@
-package roomescape.payment.infrastructure.client
-
-import com.fasterxml.jackson.core.JsonParser
-import com.fasterxml.jackson.core.TreeNode
-import com.fasterxml.jackson.databind.DeserializationContext
-import com.fasterxml.jackson.databind.JsonNode
-import com.fasterxml.jackson.databind.deser.std.StdDeserializer
-import roomescape.payment.web.PaymentCancelResponse
-import java.time.OffsetDateTime
-
-class PaymentCancelResponseDeserializer(
-    vc: Class<PaymentCancelResponse>? = null
-) : StdDeserializer<PaymentCancelResponse>(vc) {
-    override fun deserialize(
-        jsonParser: JsonParser,
-        deserializationContext: DeserializationContext?
-    ): PaymentCancelResponse {
-        val cancels: JsonNode = jsonParser.codec.readTree<TreeNode>(jsonParser)
-            .get("cancels")
-            .get(0) as JsonNode
-
-        return PaymentCancelResponse(
-            cancels.get("cancelStatus").asText(),
-            cancels.get("cancelReason").asText(),
-            cancels.get("cancelAmount").asLong(),
-            OffsetDateTime.parse(cancels.get("canceledAt").asText())
-        )
-    }
-}
\ No newline at end of file
diff --git a/src/main/kotlin/roomescape/payment/infrastructure/client/PaymentConfig.kt b/src/main/kotlin/roomescape/payment/infrastructure/client/PaymentConfig.kt
index b19c1062..ea8e2b18 100644
--- a/src/main/kotlin/roomescape/payment/infrastructure/client/PaymentConfig.kt
+++ b/src/main/kotlin/roomescape/payment/infrastructure/client/PaymentConfig.kt
@@ -15,7 +15,7 @@ import java.util.*
 class PaymentConfig {
 
     @Bean
-    fun tossPaymentClientBuilder(
+    fun tosspayClientBuilder(
         paymentProperties: PaymentProperties,
     ): RestClient.Builder {
         val settings: ClientHttpRequestFactorySettings = ClientHttpRequestFactorySettings.defaults().also {
diff --git a/src/main/kotlin/roomescape/payment/infrastructure/client/TossPaymentClient.kt b/src/main/kotlin/roomescape/payment/infrastructure/client/TossPaymentClient.kt
deleted file mode 100644
index ae56e451..00000000
--- a/src/main/kotlin/roomescape/payment/infrastructure/client/TossPaymentClient.kt
+++ /dev/null
@@ -1,108 +0,0 @@
-package roomescape.payment.infrastructure.client
-
-import com.fasterxml.jackson.databind.ObjectMapper
-import io.github.oshai.kotlinlogging.KLogger
-import io.github.oshai.kotlinlogging.KotlinLogging
-import org.springframework.http.HttpRequest
-import org.springframework.http.HttpStatusCode
-import org.springframework.http.MediaType
-import org.springframework.http.client.ClientHttpResponse
-import org.springframework.stereotype.Component
-import org.springframework.web.client.RestClient
-import roomescape.payment.exception.PaymentErrorCode
-import roomescape.payment.exception.PaymentException
-import roomescape.payment.web.PaymentCancelRequest
-import roomescape.payment.web.PaymentCancelResponse
-import java.util.Map
-
-private val log: KLogger = KotlinLogging.logger {}
-
-@Component
-class TossPaymentClient(
-    private val objectMapper: ObjectMapper,
-    tossPaymentClientBuilder: RestClient.Builder,
-) {
-    companion object {
-        private const val CONFIRM_URL: String = "/v1/payments/confirm"
-        private const val CANCEL_URL: String = "/v1/payments/{paymentKey}/cancel"
-    }
-
-    private val tossPaymentClient: RestClient = tossPaymentClientBuilder.build()
-
-    fun confirm(paymentRequest: PaymentApproveRequest): PaymentApproveResponse {
-        logPaymentInfo(paymentRequest)
-
-        return tossPaymentClient.post()
-            .uri(CONFIRM_URL)
-            .contentType(MediaType.APPLICATION_JSON)
-            .body(paymentRequest)
-            .retrieve()
-            .onStatus(
-                { status: HttpStatusCode -> status.is4xxClientError || status.is5xxServerError },
-                { req: HttpRequest, res: ClientHttpResponse -> handlePaymentError(res, "confirm") }
-            )
-            .body(PaymentApproveResponse::class.java)
-            ?: run {
-                log.error { "[TossPaymentClient] 응답 변환 오류" }
-                throw PaymentException(PaymentErrorCode.PAYMENT_PROVIDER_ERROR)
-            }
-    }
-
-    fun cancel(cancelRequest: PaymentCancelRequest): PaymentCancelResponse {
-        logPaymentCancelInfo(cancelRequest)
-        val param = Map.of<String, String>("cancelReason", cancelRequest.cancelReason)
-
-        return tossPaymentClient.post()
-            .uri(CANCEL_URL, cancelRequest.paymentKey)
-            .contentType(MediaType.APPLICATION_JSON)
-            .body(param)
-            .retrieve()
-            .onStatus(
-                { status: HttpStatusCode -> status.is4xxClientError || status.is5xxServerError },
-                { req: HttpRequest, res: ClientHttpResponse -> handlePaymentError(res, "cancel") }
-            )
-            .body(PaymentCancelResponse::class.java)
-            ?: run {
-                log.error { "[TossPaymentClient] 응답 변환 오류" }
-                throw PaymentException(PaymentErrorCode.PAYMENT_PROVIDER_ERROR)
-            }
-    }
-
-    private fun logPaymentInfo(paymentRequest: PaymentApproveRequest) {
-        log.info {
-            "[TossPaymentClient.confirm] 결제 승인 요청: request: $paymentRequest"
-        }
-    }
-
-    private fun logPaymentCancelInfo(cancelRequest: PaymentCancelRequest) {
-        log.info {
-            "[TossPaymentClient.cancel] 결제 취소 요청: request: $cancelRequest"
-        }
-    }
-
-    private fun handlePaymentError(
-        res: ClientHttpResponse,
-        calledBy: String
-    ): Nothing {
-        getErrorCodeByHttpStatus(res.statusCode).also {
-            logTossPaymentError(res, calledBy)
-            throw PaymentException(it)
-        }
-    }
-
-    private fun logTossPaymentError(res: ClientHttpResponse, calledBy: String): TossPaymentErrorResponse {
-        val body = res.body
-        val errorResponse = objectMapper.readValue(body, TossPaymentErrorResponse::class.java)
-        body.close()
-
-        log.error { "[TossPaymentClient.$calledBy] 요청 실패: response: $errorResponse" }
-        return errorResponse
-    }
-
-    private fun getErrorCodeByHttpStatus(statusCode: HttpStatusCode): PaymentErrorCode {
-        if (statusCode.is4xxClientError) {
-            return PaymentErrorCode.PAYMENT_CLIENT_ERROR
-        }
-        return PaymentErrorCode.PAYMENT_PROVIDER_ERROR
-    }
-}
diff --git a/src/main/kotlin/roomescape/payment/infrastructure/client/TossPaymentDTO.kt b/src/main/kotlin/roomescape/payment/infrastructure/client/TossPaymentDTO.kt
deleted file mode 100644
index 442bcf98..00000000
--- a/src/main/kotlin/roomescape/payment/infrastructure/client/TossPaymentDTO.kt
+++ /dev/null
@@ -1,22 +0,0 @@
-package roomescape.payment.infrastructure.client
-
-import java.time.OffsetDateTime
-
-data class TossPaymentErrorResponse(
-    val code: String,
-    val message: String
-)
-
-data class PaymentApproveRequest(
-    val paymentKey: String,
-    val orderId: String,
-    val amount: Long,
-    val paymentType: String
-)
-
-data class PaymentApproveResponse(
-    val paymentKey: String,
-    val orderId: String,
-    val totalAmount: Long,
-    val approvedAt: OffsetDateTime
-)
diff --git a/src/main/kotlin/roomescape/payment/infrastructure/client/v2/TosspaymentCancelDTO.kt b/src/main/kotlin/roomescape/payment/infrastructure/client/TosspayCancelDTO.kt
similarity index 82%
rename from src/main/kotlin/roomescape/payment/infrastructure/client/v2/TosspaymentCancelDTO.kt
rename to src/main/kotlin/roomescape/payment/infrastructure/client/TosspayCancelDTO.kt
index 57d440e2..551e7ae5 100644
--- a/src/main/kotlin/roomescape/payment/infrastructure/client/v2/TosspaymentCancelDTO.kt
+++ b/src/main/kotlin/roomescape/payment/infrastructure/client/TosspayCancelDTO.kt
@@ -1,22 +1,15 @@
-package roomescape.payment.infrastructure.client.v2
+package roomescape.payment.infrastructure.client
 
 import com.fasterxml.jackson.core.JsonParser
 import com.fasterxml.jackson.databind.DeserializationContext
-import com.fasterxml.jackson.databind.JsonDeserializer
 import com.fasterxml.jackson.databind.JsonNode
 import com.fasterxml.jackson.databind.annotation.JsonDeserialize
 import roomescape.payment.infrastructure.common.PaymentStatus
-import roomescape.payment.infrastructure.persistence.v2.CanceledPaymentEntityV2
+import roomescape.payment.infrastructure.persistence.CanceledPaymentEntity
 import java.time.LocalDateTime
 import java.time.OffsetDateTime
 
-data class PaymentCancelRequestV2(
-    val paymentKey: String,
-    val amount: Int,
-    val cancelReason: String
-)
-
-data class PaymentCancelResponseV2(
+data class PaymentClientCancelResponse(
     val status: PaymentStatus,
     @JsonDeserialize(using = CancelDetailDeserializer::class)
     val cancels: CancelDetail,
@@ -36,7 +29,7 @@ fun CancelDetail.toEntity(
     paymentId: Long,
     canceledBy: Long,
     cancelRequestedAt: LocalDateTime
-) = CanceledPaymentEntityV2(
+) = CanceledPaymentEntity(
     id = id,
     canceledAt = this.canceledAt,
     requestedAt = cancelRequestedAt,
@@ -49,7 +42,7 @@ fun CancelDetail.toEntity(
     easypayDiscountAmount = this.easyPayDiscountAmount
 )
 
-class CancelDetailDeserializer : JsonDeserializer<CancelDetail>() {
+class CancelDetailDeserializer : com.fasterxml.jackson.databind.JsonDeserializer<CancelDetail>() {
     override fun deserialize(
         p: JsonParser,
         ctxt: DeserializationContext
diff --git a/src/main/kotlin/roomescape/payment/infrastructure/client/TosspayClient.kt b/src/main/kotlin/roomescape/payment/infrastructure/client/TosspayClient.kt
new file mode 100644
index 00000000..c8ea2652
--- /dev/null
+++ b/src/main/kotlin/roomescape/payment/infrastructure/client/TosspayClient.kt
@@ -0,0 +1,167 @@
+package roomescape.payment.infrastructure.client
+
+import com.fasterxml.jackson.databind.ObjectMapper
+import io.github.oshai.kotlinlogging.KLogger
+import io.github.oshai.kotlinlogging.KotlinLogging
+import org.springframework.http.HttpMethod
+import org.springframework.http.HttpStatusCode
+import org.springframework.http.MediaType
+import org.springframework.http.client.ClientHttpResponse
+import org.springframework.stereotype.Component
+import org.springframework.web.client.ResponseErrorHandler
+import org.springframework.web.client.RestClient
+import roomescape.payment.exception.PaymentErrorCode
+import roomescape.payment.exception.PaymentException
+import java.net.URI
+
+private val log: KLogger = KotlinLogging.logger {}
+
+@Component
+class TosspayClient(
+    objectMapper: ObjectMapper,
+    tosspayClientBuilder: RestClient.Builder
+) {
+    private val confirmClient = ConfirmClient(objectMapper, tosspayClientBuilder.build())
+    private val cancelClient = CancelClient(objectMapper, tosspayClientBuilder.build())
+
+    fun confirm(
+        paymentKey: String,
+        orderId: String,
+        amount: Int,
+    ): PaymentClientConfirmResponse {
+        log.info { "[TosspayClient.confirm] 결제 승인 요청: paymentKey=$paymentKey, orderId=$orderId, amount=$amount" }
+
+        return confirmClient.request(paymentKey, orderId, amount)
+            .also {
+                log.info { "[TosspayClient.confirm] 결제 승인 완료: response=$it" }
+            }
+
+    }
+
+    fun cancel(
+        paymentKey: String,
+        amount: Int,
+        cancelReason: String
+    ): PaymentClientCancelResponse {
+        log.info { "[TosspayClient.cancel] 결제 취소 요청: paymentKey=$paymentKey, amount=$amount, cancelReason=$cancelReason" }
+
+        return cancelClient.request(paymentKey, amount, cancelReason).also {
+            log.info { "[TosspayClient.cancel] 결제 취소 완료: response=$it" }
+        }
+    }
+}
+
+private class ConfirmClient(
+    private val objectMapper: ObjectMapper,
+    private val client: RestClient,
+) {
+    companion object {
+        private const val CONFIRM_URI: String = "/v1/payments/confirm"
+    }
+
+    private val errorHandler: TosspayErrorHandler = TosspayErrorHandler(objectMapper)
+
+    fun request(paymentKey: String, orderId: String, amount: Int): PaymentClientConfirmResponse {
+        val response = client.post()
+            .uri(CONFIRM_URI)
+            .contentType(MediaType.APPLICATION_JSON)
+            .body(
+                mapOf(
+                    "paymentKey" to paymentKey,
+                    "orderId" to orderId,
+                    "amount" to amount
+                )
+            )
+            .retrieve()
+            .onStatus(errorHandler)
+            .body(String::class.java)
+            ?: run {
+                log.error { "[TosspayClient] 응답 바디 변환 실패" }
+                throw PaymentException(PaymentErrorCode.PAYMENT_UNEXPECTED_ERROR)
+            }
+
+        log.debug { "[TosspayClient.confirm] 응답 수신: json = $response" }
+
+        return objectMapper.readValue(response, PaymentClientConfirmResponse::class.java)
+    }
+}
+
+private class CancelClient(
+    private val objectMapper: ObjectMapper,
+    private val client: RestClient,
+) {
+    companion object {
+        private const val CANCEL_URI: String = "/v1/payments/{paymentKey}/cancel"
+    }
+
+    private val errorHandler: TosspayErrorHandler = TosspayErrorHandler(objectMapper)
+
+    fun request(
+        paymentKey: String,
+        amount: Int,
+        cancelReason: String
+    ): PaymentClientCancelResponse {
+        val response = client.post()
+            .uri(CANCEL_URI, paymentKey)
+            .body(
+                mapOf(
+                    "cancelReason" to cancelReason,
+                    "cancelAmount" to amount,
+                )
+            )
+            .retrieve()
+            .onStatus(errorHandler)
+            .body(String::class.java)
+            ?: run {
+                log.error { "[TosspayClient] 응답 바디 변환 실패" }
+                throw PaymentException(PaymentErrorCode.PAYMENT_UNEXPECTED_ERROR)
+            }
+
+        log.debug { "[TosspayClient.cancel] 응답 수신: json = $response" }
+        return objectMapper.readValue(response, PaymentClientCancelResponse::class.java)
+    }
+}
+
+private class TosspayErrorHandler(
+    private val objectMapper: ObjectMapper
+) : ResponseErrorHandler {
+    override fun hasError(response: ClientHttpResponse): Boolean {
+        val statusCode: HttpStatusCode = response.statusCode
+
+        return statusCode.is4xxClientError || statusCode.is5xxServerError
+    }
+
+    override fun handleError(
+        url: URI,
+        method: HttpMethod,
+        response: ClientHttpResponse
+    ): Nothing {
+        val requestType: String = paymentRequestType(url)
+        log.warn { "[TosspayClient] $requestType 요청 실패: response: ${parseResponse(response)}" }
+
+        throw PaymentException(paymentErrorCode(response.statusCode))
+    }
+
+    private fun paymentRequestType(url: URI): String {
+        val type = url.path.split("/").last()
+
+        if (type == "cancel") {
+            return "취소"
+        }
+        return "승인"
+    }
+
+    private fun paymentErrorCode(statusCode: HttpStatusCode) = if (statusCode.is4xxClientError) {
+        PaymentErrorCode.PAYMENT_CLIENT_ERROR
+    } else {
+        PaymentErrorCode.PAYMENT_PROVIDER_ERROR
+    }
+
+    private fun parseResponse(response: ClientHttpResponse): TosspayErrorResponse {
+        val body = response.body
+
+        return objectMapper.readValue(body, TosspayErrorResponse::class.java).also {
+            body.close()
+        }
+    }
+}
diff --git a/src/main/kotlin/roomescape/payment/infrastructure/client/v2/TosspaymentConfirmDTO.kt b/src/main/kotlin/roomescape/payment/infrastructure/client/TosspayConfirmDTO.kt
similarity index 79%
rename from src/main/kotlin/roomescape/payment/infrastructure/client/v2/TosspaymentConfirmDTO.kt
rename to src/main/kotlin/roomescape/payment/infrastructure/client/TosspayConfirmDTO.kt
index 0c5a3ce8..ebe0ef20 100644
--- a/src/main/kotlin/roomescape/payment/infrastructure/client/v2/TosspaymentConfirmDTO.kt
+++ b/src/main/kotlin/roomescape/payment/infrastructure/client/TosspayConfirmDTO.kt
@@ -1,21 +1,15 @@
-package roomescape.payment.infrastructure.client.v2
+package roomescape.payment.infrastructure.client
 
 import roomescape.payment.exception.PaymentErrorCode
 import roomescape.payment.exception.PaymentException
 import roomescape.payment.infrastructure.common.*
-import roomescape.payment.infrastructure.persistence.v2.PaymentBankTransferDetailEntity
-import roomescape.payment.infrastructure.persistence.v2.PaymentCardDetailEntity
-import roomescape.payment.infrastructure.persistence.v2.PaymentEasypayPrepaidDetailEntity
-import roomescape.payment.infrastructure.persistence.v2.PaymentEntityV2
+import roomescape.payment.infrastructure.persistence.PaymentBankTransferDetailEntity
+import roomescape.payment.infrastructure.persistence.PaymentCardDetailEntity
+import roomescape.payment.infrastructure.persistence.PaymentEasypayPrepaidDetailEntity
+import roomescape.payment.infrastructure.persistence.PaymentEntity
 import java.time.OffsetDateTime
 
-data class PaymentConfirmRequest(
-    val paymentKey: String,
-    val orderId: String,
-    val amount: Int,
-)
-
-data class PaymentConfirmResponse(
+data class PaymentClientConfirmResponse(
     val paymentKey: String,
     val status: PaymentStatus,
     val totalAmount: Int,
@@ -29,12 +23,12 @@ data class PaymentConfirmResponse(
     val approvedAt: OffsetDateTime,
 )
 
-fun PaymentConfirmResponse.toEntity(
+fun PaymentClientConfirmResponse.toEntity(
     id: Long,
     reservationId: Long,
     orderId: String,
     paymentType: PaymentType
-) = PaymentEntityV2(
+) = PaymentEntity(
     id = id,
     reservationId = reservationId,
     paymentKey = this.paymentKey,
@@ -58,7 +52,7 @@ data class CardDetail(
     val installmentPlanMonths: Int
 )
 
-fun PaymentConfirmResponse.toCardDetailEntity(id: Long, paymentId: Long): PaymentCardDetailEntity {
+fun PaymentClientConfirmResponse.toCardDetailEntity(id: Long, paymentId: Long): PaymentCardDetailEntity {
     val cardDetail = this.card ?: throw PaymentException(PaymentErrorCode.PAYMENT_UNEXPECTED_ERROR)
 
     return PaymentCardDetailEntity(
@@ -85,7 +79,7 @@ data class EasyPayDetail(
     val discountAmount: Int,
 )
 
-fun PaymentConfirmResponse.toEasypayPrepaidDetailEntity(
+fun PaymentClientConfirmResponse.toEasypayPrepaidDetailEntity(
     id: Long,
     paymentId: Long
 ): PaymentEasypayPrepaidDetailEntity {
@@ -107,7 +101,7 @@ data class TransferDetail(
     val settlementStatus: String,
 )
 
-fun PaymentConfirmResponse.toTransferDetailEntity(
+fun PaymentClientConfirmResponse.toTransferDetailEntity(
     id: Long,
     paymentId: Long
 ): PaymentBankTransferDetailEntity {
diff --git a/src/main/kotlin/roomescape/payment/infrastructure/client/TosspayErrorResponse.kt b/src/main/kotlin/roomescape/payment/infrastructure/client/TosspayErrorResponse.kt
new file mode 100644
index 00000000..fbb20ccc
--- /dev/null
+++ b/src/main/kotlin/roomescape/payment/infrastructure/client/TosspayErrorResponse.kt
@@ -0,0 +1,6 @@
+package roomescape.payment.infrastructure.client
+
+data class TosspayErrorResponse(
+    val code: String,
+    val message: String
+)
\ No newline at end of file
diff --git a/src/main/kotlin/roomescape/payment/infrastructure/client/v2/TosspaymentClientV2.kt b/src/main/kotlin/roomescape/payment/infrastructure/client/v2/TosspaymentClientV2.kt
deleted file mode 100644
index 35816231..00000000
--- a/src/main/kotlin/roomescape/payment/infrastructure/client/v2/TosspaymentClientV2.kt
+++ /dev/null
@@ -1,136 +0,0 @@
-package roomescape.payment.infrastructure.client.v2
-
-import com.fasterxml.jackson.databind.ObjectMapper
-import io.github.oshai.kotlinlogging.KLogger
-import io.github.oshai.kotlinlogging.KotlinLogging
-import org.springframework.http.HttpMethod
-import org.springframework.http.HttpStatusCode
-import org.springframework.http.MediaType
-import org.springframework.http.client.ClientHttpResponse
-import org.springframework.stereotype.Component
-import org.springframework.web.client.ResponseErrorHandler
-import org.springframework.web.client.RestClient
-import roomescape.payment.exception.PaymentErrorCode
-import roomescape.payment.exception.PaymentException
-import roomescape.payment.infrastructure.client.TossPaymentErrorResponse
-import java.net.URI
-
-private val log: KLogger = KotlinLogging.logger {}
-
-@Component
-class TosspaymentClientV2(
-    objectMapper: ObjectMapper,
-    tossPaymentClientBuilder: RestClient.Builder
-) {
-    private val confirmClient = ConfirmClient(objectMapper, tossPaymentClientBuilder.build())
-    private val cancelClient = CancelClient(objectMapper, tossPaymentClientBuilder.build())
-
-    fun confirm(request: PaymentConfirmRequest): PaymentConfirmResponse {
-        log.info { "[TossPaymentClientV2.confirm] 결제 승인 요청: request=$request" }
-
-        return confirmClient.request(request).also {
-            log.info { "[TossPaymentClientV2.confirm] 결제 승인 완료: response=$it" }
-        }
-    }
-
-    fun cancel(request: PaymentCancelRequestV2): PaymentCancelResponseV2 {
-        log.info { "[TossPaymentClient.cancel] 결제 취소 요청: request=$request" }
-
-        return cancelClient.request(request).also {
-            log.info { "[TossPaymentClient.cancel] 결제 취소 완료: response=$it" }
-        }
-    }
-}
-
-private class ConfirmClient(
-    objectMapper: ObjectMapper,
-    private val client: RestClient,
-) {
-    companion object {
-        private const val CONFIRM_URI: String = "/v1/payments/confirm"
-    }
-
-    private val errorHandler: TosspayErrorHandler = TosspayErrorHandler(objectMapper)
-
-    fun request(request: PaymentConfirmRequest): PaymentConfirmResponse = client.post()
-        .uri(CONFIRM_URI)
-        .contentType(MediaType.APPLICATION_JSON)
-        .body(request)
-        .retrieve()
-        .onStatus(errorHandler)
-        .body(PaymentConfirmResponse::class.java) ?: run {
-            log.error { "[TossPaymentConfirmClient.request] 응답 바디 변환 실패" }
-            throw PaymentException(PaymentErrorCode.PAYMENT_UNEXPECTED_ERROR)
-        }
-}
-
-private class CancelClient(
-    objectMapper: ObjectMapper,
-    private val client: RestClient,
-) {
-    companion object {
-        private const val CANCEL_URI: String = "/v1/payments/{paymentKey}/cancel"
-    }
-
-    private val errorHandler: TosspayErrorHandler = TosspayErrorHandler(objectMapper)
-
-    fun request(request: PaymentCancelRequestV2): PaymentCancelResponseV2 = client.post()
-        .uri(CANCEL_URI, request.paymentKey)
-        .body(
-            mapOf(
-                "cancelReason" to request.cancelReason,
-                "cancelAmount" to request.amount,
-            )
-        )
-        .retrieve()
-        .onStatus(errorHandler)
-        .body(PaymentCancelResponseV2::class.java)
-        ?: run {
-            log.error { "[TossPaymentClient] 응답 바디 변환 실패" }
-            throw PaymentException(PaymentErrorCode.PAYMENT_UNEXPECTED_ERROR)
-        }
-}
-
-private class TosspayErrorHandler(
-    private val objectMapper: ObjectMapper
-) : ResponseErrorHandler {
-    override fun hasError(response: ClientHttpResponse): Boolean {
-        val statusCode: HttpStatusCode = response.statusCode
-
-        return statusCode.is4xxClientError || statusCode.is5xxServerError
-    }
-
-    override fun handleError(
-        url: URI,
-        method: HttpMethod,
-        response: ClientHttpResponse
-    ): Nothing {
-        val requestType: String = paymentRequestType(url)
-        log.warn { "[TossPaymentClient] $requestType 요청 실패: response: ${parseResponse(response)}" }
-
-        throw PaymentException(paymentErrorCode(response.statusCode))
-    }
-
-    private fun paymentRequestType(url: URI): String {
-        val type = url.path.split("/").last()
-
-        if (type == "cancel") {
-            return "취소"
-        }
-        return "승인"
-    }
-
-    private fun paymentErrorCode(statusCode: HttpStatusCode) = if (statusCode.is4xxClientError) {
-        PaymentErrorCode.PAYMENT_CLIENT_ERROR
-    } else {
-        PaymentErrorCode.PAYMENT_PROVIDER_ERROR
-    }
-
-    private fun parseResponse(response: ClientHttpResponse): TossPaymentErrorResponse {
-        val body = response.body
-
-        return objectMapper.readValue(body, TossPaymentErrorResponse::class.java).also {
-            body.close()
-        }
-    }
-}
diff --git a/src/main/kotlin/roomescape/payment/infrastructure/common/PaymentTypes.kt b/src/main/kotlin/roomescape/payment/infrastructure/common/PaymentTypes.kt
index c2c5bf79..6ecabb80 100644
--- a/src/main/kotlin/roomescape/payment/infrastructure/common/PaymentTypes.kt
+++ b/src/main/kotlin/roomescape/payment/infrastructure/common/PaymentTypes.kt
@@ -23,9 +23,9 @@ enum class PaymentType(
         @JsonCreator(mode = JsonCreator.Mode.DELEGATING)
         fun get(name: String): PaymentType {
             return CACHE[name.uppercase()] ?: run {
-                    log.warn { "[PaymentTypes.PaymentType] 결제 타입 조회 실패: type=$name" }
-                    throw PaymentException(PaymentErrorCode.TYPE_NOT_FOUND)
-                }
+                log.warn { "[PaymentTypes.PaymentType] 결제 타입 조회 실패: type=$name" }
+                throw PaymentException(PaymentErrorCode.TYPE_NOT_FOUND)
+            }
         }
     }
 }
@@ -163,9 +163,9 @@ enum class BankCode(
             val parsedCode = if (code.length == 2) "0$code" else code
 
             return CACHE[parsedCode] ?: run {
-                    log.error { "[PaymentCode.BankCode] 은행 코드 조회 실패: code=$code" }
-                    throw PaymentException(PaymentErrorCode.ORGANIZATION_CODE_NOT_FOUND)
-                }
+                log.error { "[PaymentCode.BankCode] 은행 코드 조회 실패: code=$code" }
+                throw PaymentException(PaymentErrorCode.ORGANIZATION_CODE_NOT_FOUND)
+            }
         }
     }
 }
@@ -207,9 +207,9 @@ enum class CardIssuerCode(
         @JsonCreator(mode = JsonCreator.Mode.DELEGATING)
         fun get(code: String): CardIssuerCode {
             return CACHE[code] ?: run {
-                    log.error { "[PaymentCode.CardIssuerCode] 카드사 코드 조회 실패: code=$code" }
-                    throw PaymentException(PaymentErrorCode.ORGANIZATION_CODE_NOT_FOUND)
-                }
+                log.error { "[PaymentCode.CardIssuerCode] 카드사 코드 조회 실패: code=$code" }
+                throw PaymentException(PaymentErrorCode.ORGANIZATION_CODE_NOT_FOUND)
+            }
         }
     }
 }
diff --git a/src/main/kotlin/roomescape/payment/infrastructure/persistence/CanceledPaymentEntity.kt b/src/main/kotlin/roomescape/payment/infrastructure/persistence/CanceledPaymentEntity.kt
index 133e3eb4..f9085e7c 100644
--- a/src/main/kotlin/roomescape/payment/infrastructure/persistence/CanceledPaymentEntity.kt
+++ b/src/main/kotlin/roomescape/payment/infrastructure/persistence/CanceledPaymentEntity.kt
@@ -1,33 +1,24 @@
 package roomescape.payment.infrastructure.persistence
 
-import jakarta.persistence.Column
 import jakarta.persistence.Entity
-import jakarta.persistence.Id
 import jakarta.persistence.Table
-import roomescape.common.entity.BaseEntity
+import roomescape.common.entity.PersistableBaseEntity
+import java.time.LocalDateTime
 import java.time.OffsetDateTime
 
 @Entity
-@Table(name = "canceled_payments")
+@Table(name = "canceled_payment")
 class CanceledPaymentEntity(
-    @Id
-    @Column(name = "canceled_payment_id")
-    private var _id: Long?,
+    id: Long,
 
-    @Column(name = "payment_key", nullable = false)
-    var paymentKey: String,
+    val paymentId: Long,
+    val requestedAt: LocalDateTime,
+    val canceledAt: OffsetDateTime,
+    val canceledBy: Long,
+    val cancelReason: String,
+    val cancelAmount: Int,
+    val cardDiscountAmount: Int,
+    val transferDiscountAmount: Int,
+    val easypayDiscountAmount: Int,
+) : PersistableBaseEntity(id)
 
-    @Column(name = "cancel_reason", nullable = false)
-    var cancelReason: String,
-
-    @Column(name = "cancel_amount", nullable = false)
-    var cancelAmount: Long,
-
-    @Column(name = "approved_at", nullable = false)
-    var approvedAt: OffsetDateTime,
-
-    @Column(name = "canceled_at", nullable = false)
-    var canceledAt: OffsetDateTime,
-): BaseEntity() {
-    override fun getId(): Long? = _id
-}
diff --git a/src/main/kotlin/roomescape/payment/infrastructure/persistence/CanceledPaymentRepository.kt b/src/main/kotlin/roomescape/payment/infrastructure/persistence/CanceledPaymentRepository.kt
index 70466653..75028118 100644
--- a/src/main/kotlin/roomescape/payment/infrastructure/persistence/CanceledPaymentRepository.kt
+++ b/src/main/kotlin/roomescape/payment/infrastructure/persistence/CanceledPaymentRepository.kt
@@ -3,5 +3,5 @@ package roomescape.payment.infrastructure.persistence
 import org.springframework.data.jpa.repository.JpaRepository
 
 interface CanceledPaymentRepository : JpaRepository<CanceledPaymentEntity, Long> {
-    fun findByPaymentKey(paymentKey: String): CanceledPaymentEntity?
+    fun findByPaymentId(paymentId: Long): CanceledPaymentEntity?
 }
diff --git a/src/main/kotlin/roomescape/payment/infrastructure/persistence/v2/PaymentDetailEntity.kt b/src/main/kotlin/roomescape/payment/infrastructure/persistence/PaymentDetailEntity.kt
similarity index 92%
rename from src/main/kotlin/roomescape/payment/infrastructure/persistence/v2/PaymentDetailEntity.kt
rename to src/main/kotlin/roomescape/payment/infrastructure/persistence/PaymentDetailEntity.kt
index 43969ef6..807aaaf3 100644
--- a/src/main/kotlin/roomescape/payment/infrastructure/persistence/v2/PaymentDetailEntity.kt
+++ b/src/main/kotlin/roomescape/payment/infrastructure/persistence/PaymentDetailEntity.kt
@@ -1,9 +1,8 @@
-package roomescape.payment.infrastructure.persistence.v2
+package roomescape.payment.infrastructure.persistence
 
 import jakarta.persistence.*
 import roomescape.common.entity.PersistableBaseEntity
 import roomescape.payment.infrastructure.common.*
-import kotlin.jvm.Transient
 
 @Entity
 @Table(name = "payment_detail")
@@ -14,9 +13,6 @@ open class PaymentDetailEntity(
     open val paymentId: Long,
     open val suppliedAmount: Int,
     open val vat: Int,
-
-    @Transient
-    private var isNewEntity: Boolean = true
 ) : PersistableBaseEntity(id)
 
 @Entity
diff --git a/src/main/kotlin/roomescape/payment/infrastructure/persistence/PaymentDetailRepository.kt b/src/main/kotlin/roomescape/payment/infrastructure/persistence/PaymentDetailRepository.kt
new file mode 100644
index 00000000..0efd93ae
--- /dev/null
+++ b/src/main/kotlin/roomescape/payment/infrastructure/persistence/PaymentDetailRepository.kt
@@ -0,0 +1,7 @@
+package roomescape.payment.infrastructure.persistence
+
+import org.springframework.data.jpa.repository.JpaRepository
+
+interface PaymentDetailRepository : JpaRepository<PaymentDetailEntity, Long> {
+    fun findByPaymentId(paymentId: Long): PaymentDetailEntity?
+}
diff --git a/src/main/kotlin/roomescape/payment/infrastructure/persistence/PaymentEntity.kt b/src/main/kotlin/roomescape/payment/infrastructure/persistence/PaymentEntity.kt
index f3c80bd6..748dad84 100644
--- a/src/main/kotlin/roomescape/payment/infrastructure/persistence/PaymentEntity.kt
+++ b/src/main/kotlin/roomescape/payment/infrastructure/persistence/PaymentEntity.kt
@@ -1,32 +1,38 @@
 package roomescape.payment.infrastructure.persistence
 
-import jakarta.persistence.*
-import roomescape.common.entity.BaseEntity
-import roomescape.reservation.infrastructure.persistence.ReservationEntity
+import jakarta.persistence.Entity
+import jakarta.persistence.EnumType
+import jakarta.persistence.Enumerated
+import jakarta.persistence.Table
+import roomescape.common.entity.PersistableBaseEntity
+import roomescape.payment.infrastructure.common.PaymentMethod
+import roomescape.payment.infrastructure.common.PaymentStatus
+import roomescape.payment.infrastructure.common.PaymentType
 import java.time.OffsetDateTime
 
 @Entity
-@Table(name = "payments")
+@Table(name = "payment")
 class PaymentEntity(
-    @Id
-    @Column(name = "payment_id")
-    private var _id: Long?,
+    id: Long,
 
-    @Column(name = "order_id", nullable = false)
-    var orderId: String,
+    val reservationId: Long,
+    val paymentKey: String,
+    val orderId: String,
+    val totalAmount: Int,
+    val requestedAt: OffsetDateTime,
+    val approvedAt: OffsetDateTime,
 
-    @Column(name="payment_key", nullable = false)
-    var paymentKey: String,
+    @Enumerated(EnumType.STRING)
+    val type: PaymentType,
 
-    @Column(name="total_amount", nullable = false)
-    var totalAmount: Long,
+    @Enumerated(EnumType.STRING)
+    val method: PaymentMethod,
 
-    @OneToOne(fetch = FetchType.LAZY)
-    @JoinColumn(name = "reservation_id", nullable = false)
-    var reservation: ReservationEntity,
+    @Enumerated(EnumType.STRING)
+    var status: PaymentStatus
+) : PersistableBaseEntity(id) {
 
-    @Column(name="approved_at", nullable = false)
-    var approvedAt: OffsetDateTime
-): BaseEntity() {
-    override fun getId(): Long? = _id
+    fun cancel() {
+        this.status = PaymentStatus.CANCELED
+    }
 }
diff --git a/src/main/kotlin/roomescape/payment/infrastructure/persistence/PaymentRepository.kt b/src/main/kotlin/roomescape/payment/infrastructure/persistence/PaymentRepository.kt
index 52180c4d..9b872d25 100644
--- a/src/main/kotlin/roomescape/payment/infrastructure/persistence/PaymentRepository.kt
+++ b/src/main/kotlin/roomescape/payment/infrastructure/persistence/PaymentRepository.kt
@@ -4,9 +4,5 @@ import org.springframework.data.jpa.repository.JpaRepository
 
 interface PaymentRepository : JpaRepository<PaymentEntity, Long> {
 
-    fun existsByReservationId(reservationId: Long): Boolean
-
     fun findByReservationId(reservationId: Long): PaymentEntity?
-
-    fun deleteByPaymentKey(paymentKey: String)
 }
diff --git a/src/main/kotlin/roomescape/payment/infrastructure/persistence/v2/CanceledPaymentEntityV2.kt b/src/main/kotlin/roomescape/payment/infrastructure/persistence/v2/CanceledPaymentEntityV2.kt
deleted file mode 100644
index 3c7bc1a6..00000000
--- a/src/main/kotlin/roomescape/payment/infrastructure/persistence/v2/CanceledPaymentEntityV2.kt
+++ /dev/null
@@ -1,24 +0,0 @@
-package roomescape.payment.infrastructure.persistence.v2
-
-import jakarta.persistence.Entity
-import jakarta.persistence.Table
-import roomescape.common.entity.PersistableBaseEntity
-import java.time.LocalDateTime
-import java.time.OffsetDateTime
-
-@Entity
-@Table(name = "canceled_payment1")
-class CanceledPaymentEntityV2(
-    id: Long,
-
-    val paymentId: Long,
-    val requestedAt: LocalDateTime,
-    val canceledAt: OffsetDateTime,
-    val canceledBy: Long,
-    val cancelReason: String,
-    val cancelAmount: Int,
-    val cardDiscountAmount: Int,
-    val transferDiscountAmount: Int,
-    val easypayDiscountAmount: Int,
-) : PersistableBaseEntity(id)
-
diff --git a/src/main/kotlin/roomescape/payment/infrastructure/persistence/v2/CanceledPaymentRepositoryV2.kt b/src/main/kotlin/roomescape/payment/infrastructure/persistence/v2/CanceledPaymentRepositoryV2.kt
deleted file mode 100644
index 59814c7e..00000000
--- a/src/main/kotlin/roomescape/payment/infrastructure/persistence/v2/CanceledPaymentRepositoryV2.kt
+++ /dev/null
@@ -1,7 +0,0 @@
-package roomescape.payment.infrastructure.persistence.v2
-
-import org.springframework.data.jpa.repository.JpaRepository
-
-interface CanceledPaymentRepositoryV2 : JpaRepository<CanceledPaymentEntityV2, Long> {
-    fun findByPaymentId(paymentId: Long): CanceledPaymentEntityV2?
-}
diff --git a/src/main/kotlin/roomescape/payment/infrastructure/persistence/v2/PaymentDetailRepository.kt b/src/main/kotlin/roomescape/payment/infrastructure/persistence/v2/PaymentDetailRepository.kt
deleted file mode 100644
index 516b7d04..00000000
--- a/src/main/kotlin/roomescape/payment/infrastructure/persistence/v2/PaymentDetailRepository.kt
+++ /dev/null
@@ -1,7 +0,0 @@
-package roomescape.payment.infrastructure.persistence.v2
-
-import org.springframework.data.jpa.repository.JpaRepository
-
-interface PaymentDetailRepository: JpaRepository<PaymentDetailEntity, Long> {
-    fun findByPaymentId(paymentId: Long) : PaymentDetailEntity?
-}
diff --git a/src/main/kotlin/roomescape/payment/infrastructure/persistence/v2/PaymentEntityV2.kt b/src/main/kotlin/roomescape/payment/infrastructure/persistence/v2/PaymentEntityV2.kt
deleted file mode 100644
index 2d9e18cc..00000000
--- a/src/main/kotlin/roomescape/payment/infrastructure/persistence/v2/PaymentEntityV2.kt
+++ /dev/null
@@ -1,38 +0,0 @@
-package roomescape.payment.infrastructure.persistence.v2
-
-import jakarta.persistence.Entity
-import jakarta.persistence.EnumType
-import jakarta.persistence.Enumerated
-import jakarta.persistence.Table
-import roomescape.common.entity.PersistableBaseEntity
-import roomescape.payment.infrastructure.common.PaymentMethod
-import roomescape.payment.infrastructure.common.PaymentStatus
-import roomescape.payment.infrastructure.common.PaymentType
-import java.time.OffsetDateTime
-
-@Entity
-@Table(name = "payment1")
-class PaymentEntityV2(
-    id: Long,
-
-    val reservationId: Long,
-    val paymentKey: String,
-    val orderId: String,
-    val totalAmount: Int,
-    val requestedAt: OffsetDateTime,
-    val approvedAt: OffsetDateTime,
-
-    @Enumerated(EnumType.STRING)
-    val type: PaymentType,
-
-    @Enumerated(EnumType.STRING)
-    val method: PaymentMethod,
-
-    @Enumerated(EnumType.STRING)
-    var status: PaymentStatus
-) : PersistableBaseEntity(id) {
-
-    fun cancel() {
-        this.status = PaymentStatus.CANCELED
-    }
-}
diff --git a/src/main/kotlin/roomescape/payment/infrastructure/persistence/v2/PaymentRepositoryV2.kt b/src/main/kotlin/roomescape/payment/infrastructure/persistence/v2/PaymentRepositoryV2.kt
deleted file mode 100644
index 6fd16b94..00000000
--- a/src/main/kotlin/roomescape/payment/infrastructure/persistence/v2/PaymentRepositoryV2.kt
+++ /dev/null
@@ -1,8 +0,0 @@
-package roomescape.payment.infrastructure.persistence.v2
-
-import org.springframework.data.jpa.repository.JpaRepository
-
-interface PaymentRepositoryV2: JpaRepository<PaymentEntityV2, Long> {
-
-    fun findByReservationId(reservationId: Long): PaymentEntityV2?
-}
diff --git a/src/main/kotlin/roomescape/payment/web/PaymentController.kt b/src/main/kotlin/roomescape/payment/web/PaymentController.kt
new file mode 100644
index 00000000..9e3dc906
--- /dev/null
+++ b/src/main/kotlin/roomescape/payment/web/PaymentController.kt
@@ -0,0 +1,39 @@
+package roomescape.payment.web
+
+import io.swagger.v3.oas.annotations.Parameter
+import jakarta.validation.Valid
+import org.springframework.http.ResponseEntity
+import org.springframework.web.bind.annotation.PostMapping
+import org.springframework.web.bind.annotation.RequestBody
+import org.springframework.web.bind.annotation.RequestParam
+import org.springframework.web.bind.annotation.RestController
+import roomescape.auth.web.support.MemberId
+import roomescape.common.dto.response.CommonApiResponse
+import roomescape.payment.business.PaymentService
+import roomescape.payment.docs.PaymentAPI
+
+@RestController
+class PaymentController(
+    private val paymentService: PaymentService
+) : PaymentAPI {
+
+    @PostMapping("/payments")
+    override fun confirmPayment(
+        @RequestParam(required = true) reservationId: Long,
+        @Valid @RequestBody request: PaymentConfirmRequest
+    ): ResponseEntity<CommonApiResponse<PaymentCreateResponse>> {
+        val response = paymentService.confirm(reservationId, request)
+
+        return ResponseEntity.ok(CommonApiResponse(response))
+    }
+
+    @PostMapping("/payments/cancel")
+    override fun cancelPayment(
+        @MemberId @Parameter(hidden = true) memberId: Long,
+        @Valid @RequestBody request: PaymentCancelRequest
+    ): ResponseEntity<CommonApiResponse<Unit>> {
+        paymentService.cancel(memberId, request)
+
+        return ResponseEntity.ok(CommonApiResponse())
+    }
+}
diff --git a/src/main/kotlin/roomescape/payment/web/PaymentDTO.kt b/src/main/kotlin/roomescape/payment/web/PaymentDTO.kt
index 44c069e9..4f6089c6 100644
--- a/src/main/kotlin/roomescape/payment/web/PaymentDTO.kt
+++ b/src/main/kotlin/roomescape/payment/web/PaymentDTO.kt
@@ -1,38 +1,136 @@
 package roomescape.payment.web
 
-import com.fasterxml.jackson.databind.annotation.JsonDeserialize
-import roomescape.payment.infrastructure.client.PaymentCancelResponseDeserializer
-import roomescape.payment.infrastructure.persistence.PaymentEntity
+import roomescape.payment.exception.PaymentErrorCode
+import roomescape.payment.exception.PaymentException
+import roomescape.payment.infrastructure.common.PaymentStatus
+import roomescape.payment.infrastructure.common.PaymentType
+import roomescape.payment.infrastructure.persistence.*
+import roomescape.payment.web.PaymentDetailResponse.*
+import java.time.LocalDateTime
 import java.time.OffsetDateTime
 
-data class PaymentCancelRequest(
+data class PaymentConfirmRequest(
     val paymentKey: String,
-    val amount: Long,
-    val cancelReason: String
-)
-
-@JsonDeserialize(using = PaymentCancelResponseDeserializer::class)
-data class PaymentCancelResponse(
-    val cancelStatus: String,
-    val cancelReason: String,
-    val cancelAmount: Long,
-    val canceledAt: OffsetDateTime
+    val orderId: String,
+    val amount: Int,
+    val paymentType: PaymentType
 )
 
 data class PaymentCreateResponse(
-    val id: Long,
-    val orderId: String,
-    val paymentKey: String,
-    val totalAmount: Long,
-    val reservationId: Long,
-    val approvedAt: OffsetDateTime
+    val paymentId: Long,
+    val detailId: Long
 )
 
-fun PaymentEntity.toCreateResponse() = PaymentCreateResponse(
-    id = this.id!!,
-    orderId = this.orderId,
-    paymentKey = this.paymentKey,
-    totalAmount = this.totalAmount,
-    reservationId = this.reservation.id!!,
-    approvedAt = this.approvedAt
+data class PaymentCancelRequest(
+    val reservationId: Long,
+    val cancelReason: String,
+    val requestedAt: LocalDateTime = LocalDateTime.now()
 )
+
+data class PaymentRetrieveResponse(
+    val orderId: String,
+    val totalAmount: Int,
+    val method: String,
+    val status: PaymentStatus,
+    val requestedAt: OffsetDateTime,
+    val approvedAt: OffsetDateTime,
+    val detail: PaymentDetailResponse,
+    val cancel: PaymentCancelDetailResponse?,
+)
+
+fun PaymentEntity.toRetrieveResponse(
+    detail: PaymentDetailResponse,
+    cancel: PaymentCancelDetailResponse?
+): PaymentRetrieveResponse {
+    return PaymentRetrieveResponse(
+        orderId = this.orderId,
+        totalAmount = this.totalAmount,
+        method = this.method.koreanName,
+        status = this.status,
+        requestedAt = this.requestedAt,
+        approvedAt = this.approvedAt,
+        detail = detail,
+        cancel = cancel
+    )
+}
+
+sealed class PaymentDetailResponse {
+
+    data class CardDetailResponse(
+        val type: String = "CARD",
+        val issuerCode: String,
+        val cardType: String,
+        val ownerType: String,
+        val cardNumber: String,
+        val amount: Int,
+        val approvalNumber: String,
+        val installmentPlanMonths: Int,
+        val easypayProviderName: String?,
+        val easypayDiscountAmount: Int?,
+    ) : PaymentDetailResponse()
+
+    data class BankTransferDetailResponse(
+        val type: String = "BANK_TRANSFER",
+        val bankName: String,
+    ) : PaymentDetailResponse()
+
+    data class EasyPayPrepaidDetailResponse(
+        val type: String = "EASYPAY_PREPAID",
+        val providerName: String,
+        val amount: Int,
+        val discountAmount: Int,
+    ) : PaymentDetailResponse()
+}
+
+fun PaymentDetailEntity.toPaymentDetailResponse(): PaymentDetailResponse {
+    return when (this) {
+        is PaymentCardDetailEntity -> this.toCardDetailResponse()
+        is PaymentBankTransferDetailEntity -> this.toBankTransferDetailResponse()
+        is PaymentEasypayPrepaidDetailEntity -> this.toEasyPayPrepaidDetailResponse()
+        else -> throw PaymentException(PaymentErrorCode.NOT_SUPPORTED_PAYMENT_TYPE)
+    }
+}
+
+fun PaymentCardDetailEntity.toCardDetailResponse(): CardDetailResponse {
+    return CardDetailResponse(
+        issuerCode = this.issuerCode.koreanName,
+        cardType = this.cardType.koreanName,
+        ownerType = this.ownerType.koreanName,
+        cardNumber = this.cardNumber,
+        amount = this.amount,
+        approvalNumber = this.approvalNumber,
+        installmentPlanMonths = this.installmentPlanMonths,
+        easypayProviderName = this.easypayProviderCode?.koreanName,
+        easypayDiscountAmount = this.easypayDiscountAmount
+    )
+}
+
+fun PaymentBankTransferDetailEntity.toBankTransferDetailResponse(): BankTransferDetailResponse {
+    return BankTransferDetailResponse(
+        bankName = this.bankCode.koreanName
+    )
+}
+
+fun PaymentEasypayPrepaidDetailEntity.toEasyPayPrepaidDetailResponse(): EasyPayPrepaidDetailResponse {
+    return EasyPayPrepaidDetailResponse(
+        providerName = this.easypayProviderCode.koreanName,
+        amount = this.amount,
+        discountAmount = this.discountAmount
+    )
+}
+
+data class PaymentCancelDetailResponse(
+    val cancellationRequestedAt: LocalDateTime,
+    val cancellationApprovedAt: OffsetDateTime?,
+    val cancelReason: String,
+    val canceledBy: Long,
+)
+
+fun CanceledPaymentEntity.toCancelDetailResponse(): PaymentCancelDetailResponse {
+    return PaymentCancelDetailResponse(
+        cancellationRequestedAt = this.requestedAt,
+        cancellationApprovedAt = this.canceledAt,
+        cancelReason = this.cancelReason,
+        canceledBy = this.canceledBy
+    )
+}
diff --git a/src/main/kotlin/roomescape/reservation/business/MyReservationFindService.kt b/src/main/kotlin/roomescape/reservation/business/MyReservationFindService.kt
deleted file mode 100644
index 7f0c9e24..00000000
--- a/src/main/kotlin/roomescape/reservation/business/MyReservationFindService.kt
+++ /dev/null
@@ -1,54 +0,0 @@
-package roomescape.reservation.business
-
-import io.github.oshai.kotlinlogging.KLogger
-import io.github.oshai.kotlinlogging.KotlinLogging
-import org.springframework.stereotype.Service
-import org.springframework.transaction.annotation.Transactional
-import roomescape.payment.implement.PaymentFinderV2
-import roomescape.payment.infrastructure.persistence.v2.CanceledPaymentEntityV2
-import roomescape.payment.infrastructure.persistence.v2.PaymentDetailEntity
-import roomescape.payment.infrastructure.persistence.v2.PaymentEntityV2
-import roomescape.reservation.implement.ReservationFinder
-import roomescape.reservation.infrastructure.persistence.ReservationEntity
-import roomescape.reservation.web.ReservationDetailRetrieveResponse
-import roomescape.reservation.web.ReservationSummaryRetrieveListResponse
-import roomescape.reservation.web.toCancelDetailResponse
-import roomescape.reservation.web.toPaymentDetailResponse
-import roomescape.reservation.web.toReservationDetailRetrieveResponse
-import roomescape.reservation.web.toRetrieveResponse
-import roomescape.reservation.web.toSummaryListResponse
-
-private val log: KLogger = KotlinLogging.logger {}
-
-@Service
-class MyReservationFindService(
-    private val reservationFinder: ReservationFinder,
-    private val paymentFinder: PaymentFinderV2
-) {
-
-    @Transactional(readOnly = true)
-    fun findReservationsByMemberId(memberId: Long): ReservationSummaryRetrieveListResponse {
-        log.debug { "[ReservationFindServiceV2.findReservationsByMemberId] 시작: memberId=$memberId" }
-
-        return reservationFinder.findAllByMemberIdV2(memberId)
-            .toSummaryListResponse()
-            .also { log.info { "[ReservationFindServiceV2.findReservationsByMemberId] ${it.reservations.size}개의 예약 조회 완료: memberId=$memberId" } }
-    }
-
-    @Transactional(readOnly = true)
-    fun showReservationDetails(reservationId: Long): ReservationDetailRetrieveResponse {
-        log.debug { "[ReservationFindServiceV2.showReservationDetails] 시작: reservationId=$reservationId" }
-
-        val reservation: ReservationEntity = reservationFinder.findById(reservationId)
-        val payment: PaymentEntityV2 = paymentFinder.findPaymentByReservationId(reservationId)
-        val paymentDetail: PaymentDetailEntity = paymentFinder.findPaymentDetailByPaymentId(payment.id)
-        val canceledPayment: CanceledPaymentEntityV2? = paymentFinder.findCanceledPaymentByPaymentIdOrNull(payment.id)
-
-        return reservation.toReservationDetailRetrieveResponse(
-            payment = payment.toRetrieveResponse(detail = paymentDetail.toPaymentDetailResponse()),
-            cancellation = canceledPayment?.toCancelDetailResponse()
-        ).also {
-            log.info { "[ReservationFindServiceV2.showReservationDetails] 예약 상세 조회 완료: reservationId=$reservationId" }
-        }
-    }
-}
diff --git a/src/main/kotlin/roomescape/reservation/business/ReservationFindService.kt b/src/main/kotlin/roomescape/reservation/business/ReservationFindService.kt
deleted file mode 100644
index 3b2bf390..00000000
--- a/src/main/kotlin/roomescape/reservation/business/ReservationFindService.kt
+++ /dev/null
@@ -1,56 +0,0 @@
-package roomescape.reservation.business
-
-import io.github.oshai.kotlinlogging.KotlinLogging
-import org.springframework.stereotype.Service
-import org.springframework.transaction.annotation.Transactional
-import roomescape.reservation.implement.ReservationFinder
-import roomescape.reservation.infrastructure.persistence.ReservationStatus
-import roomescape.reservation.web.MyReservationRetrieveListResponse
-import roomescape.reservation.web.ReservationRetrieveListResponse
-import roomescape.reservation.web.toRetrieveListResponse
-import java.time.LocalDate
-
-private val log = KotlinLogging.logger {}
-
-@Service
-@Transactional(readOnly = true)
-class ReservationFindService(
-    private val reservationFinder: ReservationFinder
-) {
-    fun findReservations(): ReservationRetrieveListResponse {
-        log.debug { "[ReservationService.findReservations] 시작" }
-
-        return reservationFinder.findAllByStatuses(*ReservationStatus.confirmedStatus())
-            .toRetrieveListResponse()
-            .also { log.info { "[ReservationService.findReservations] ${it.reservations.size}개의 예약 조회 완료" } }
-    }
-
-    fun findAllWaiting(): ReservationRetrieveListResponse {
-        log.debug { "[ReservationService.findAllWaiting] 시작" }
-
-        return reservationFinder.findAllByStatuses(ReservationStatus.WAITING)
-            .toRetrieveListResponse()
-            .also { log.info { "[ReservationService.findAllWaiting] ${it.reservations.size}개의 대기 조회 완료" } }
-    }
-
-    fun findReservationsByMemberId(memberId: Long): MyReservationRetrieveListResponse {
-        log.debug { "[ReservationService.findReservationsByMemberId] 시작: memberId=$memberId" }
-
-        return reservationFinder.findAllByMemberId(memberId)
-            .toRetrieveListResponse()
-            .also { log.info { "[ReservationService.findReservationsByMemberId] ${it.reservations.size}개의 예약 조회 완료: memberId=$memberId" } }
-    }
-
-    fun searchReservations(
-        themeId: Long?,
-        memberId: Long?,
-        startFrom: LocalDate?,
-        endAt: LocalDate?,
-    ): ReservationRetrieveListResponse {
-        log.debug { "[ReservationService.searchReservations] 시작: themeId=$themeId, memberId=$memberId, dateFrom=$startFrom, dateTo=$endAt" }
-
-        return reservationFinder.searchReservations(themeId, memberId, startFrom, endAt)
-            .toRetrieveListResponse()
-            .also { log.info { "[ReservationService.searchReservations] ${it.reservations.size}개의 예약 조회 완료: themeId=$themeId, memberId=$memberId, dateFrom=$startFrom, dateTo=$endAt" } }
-    }
-}
diff --git a/src/main/kotlin/roomescape/reservation/business/ReservationService.kt b/src/main/kotlin/roomescape/reservation/business/ReservationService.kt
new file mode 100644
index 00000000..fc67d4cd
--- /dev/null
+++ b/src/main/kotlin/roomescape/reservation/business/ReservationService.kt
@@ -0,0 +1,168 @@
+package roomescape.reservation.business
+
+import com.github.f4b6a3.tsid.TsidFactory
+import io.github.oshai.kotlinlogging.KLogger
+import io.github.oshai.kotlinlogging.KotlinLogging
+import org.springframework.data.repository.findByIdOrNull
+import org.springframework.stereotype.Service
+import org.springframework.transaction.annotation.Transactional
+import roomescape.common.config.next
+import roomescape.member.business.MemberService
+import roomescape.member.infrastructure.persistence.Role
+import roomescape.member.web.MemberSummaryRetrieveResponse
+import roomescape.payment.business.PaymentService
+import roomescape.payment.web.PaymentRetrieveResponse
+import roomescape.reservation.exception.ReservationErrorCode
+import roomescape.reservation.exception.ReservationException
+import roomescape.reservation.infrastructure.persistence.*
+import roomescape.reservation.web.*
+import roomescape.schedule.business.ScheduleService
+import roomescape.schedule.infrastructure.persistence.ScheduleStatus
+import roomescape.schedule.web.ScheduleSummaryResponse
+import roomescape.schedule.web.ScheduleUpdateRequest
+import roomescape.theme.business.ThemeService
+import roomescape.theme.web.ThemeSummaryResponse
+import java.time.LocalDateTime
+
+private val log: KLogger = KotlinLogging.logger {}
+
+@Service
+class ReservationService(
+    private val reservationRepository: ReservationRepository,
+    private val reservationValidator: ReservationValidator,
+    private val scheduleService: ScheduleService,
+    private val memberService: MemberService,
+    private val themeService: ThemeService,
+    private val canceledReservationRepository: CanceledReservationRepository,
+    private val tsidFactory: TsidFactory,
+    private val paymentService: PaymentService
+) {
+
+    @Transactional
+    fun createPendingReservation(
+        memberId: Long,
+        request: PendingReservationCreateRequest
+    ): PendingReservationCreateResponse {
+        log.info { "[ReservationService.createPendingReservation] Pending 예약 생성 시작: schedule=${request.scheduleId}" }
+
+        validateCanCreate(request)
+
+        val reservation: ReservationEntity = request.toEntity(id = tsidFactory.next(), memberId = memberId)
+
+        return PendingReservationCreateResponse(reservationRepository.save(reservation).id)
+            .also { "[ReservationService.createPendingReservation] Pending 예약 생성 완료: reservationId=${it}, schedule=${request.scheduleId}" }
+    }
+
+    @Transactional
+    fun confirmReservation(id: Long) {
+        log.info { "[ReservationService.confirmReservation] Pending 예약 확정 시작: reservationId=${id}" }
+        val reservation: ReservationEntity = findOrThrow(id)
+
+        run {
+            reservation.confirm()
+            scheduleService.updateSchedule(
+                reservation.scheduleId,
+                ScheduleUpdateRequest(status = ScheduleStatus.RESERVED)
+            )
+        }.also {
+            log.info { "[ReservationService.confirmReservation] Pending 예약 확정 완료: reservationId=${id}" }
+        }
+    }
+
+    @Transactional
+    fun cancelReservation(memberId: Long, reservationId: Long, request: ReservationCancelRequest) {
+        log.info { "[ReservationService.cancelReservation] 예약 취소 시작: memberId=${memberId}, reservationId=${reservationId}" }
+
+        val reservation: ReservationEntity = findOrThrow(reservationId)
+        val member: MemberSummaryRetrieveResponse = memberService.findSummaryById(memberId)
+
+        run {
+            scheduleService.updateSchedule(
+                reservation.scheduleId,
+                ScheduleUpdateRequest(status = ScheduleStatus.AVAILABLE)
+            )
+            saveCanceledReservation(member, reservation, request.cancelReason)
+            reservation.cancel()
+        }.also {
+            log.info { "[ReservationService.cancelReservation] 예약 취소 완료: reservationId=${reservationId}" }
+        }
+    }
+
+    @Transactional(readOnly = true)
+    fun findSummaryByMemberId(memberId: Long): ReservationSummaryRetrieveListResponse {
+        log.info { "[ReservationService.findSummaryByMemberId] 예약 조회 시작: memberId=${memberId}" }
+
+        val reservations: List<ReservationEntity> = reservationRepository.findAllByMemberId(memberId)
+
+        return ReservationSummaryRetrieveListResponse(reservations.map {
+            val schedule: ScheduleSummaryResponse = scheduleService.findSummaryById(it.scheduleId)
+            val theme: ThemeSummaryResponse = themeService.findSummaryById(schedule.themeId)
+
+            ReservationSummaryRetrieveResponse(
+                id = it.id,
+                themeName = theme.name,
+                date = schedule.date,
+                startAt = schedule.time,
+                status = it.status
+            )
+        }).also {
+            log.info { "[ReservationService.findSummaryByMemberId] ${it.reservations.size}개의 예약 조회 완료: memberId=${memberId}" }
+        }
+    }
+
+    @Transactional(readOnly = true)
+    fun findDetailById(id: Long): ReservationDetailRetrieveResponse {
+        log.info { "[ReservationService.findDetailById] 예약 상세 조회 시작: reservationId=${id}" }
+
+        val reservation: ReservationEntity = findOrThrow(id)
+        val member: MemberSummaryRetrieveResponse = memberService.findSummaryById(reservation.memberId)
+        val paymentDetail: PaymentRetrieveResponse = paymentService.findDetailByReservationId(id)
+
+        return reservation.toReservationDetailRetrieveResponse(
+            member = member,
+            payment = paymentDetail
+        ).also {
+            log.info { "[ReservationService.findDetailById] 예약 상세 조회 완료: reservationId=${id}" }
+        }
+    }
+
+    private fun findOrThrow(id: Long): ReservationEntity {
+        log.info { "[ReservationService.findOrThrow] 예약 조회 시작: reservationId=${id}" }
+
+        return reservationRepository.findByIdOrNull(id)
+            ?.also { log.info { "[ReservationService.findOrThrow] 예약 조회 완료: reservationId=${id}" } }
+            ?: run {
+                log.warn { "[ReservationService.findOrThrow] 예약 조회 실패: reservationId=${id}" }
+                throw ReservationException(ReservationErrorCode.RESERVATION_NOT_FOUND)
+            }
+    }
+
+    private fun saveCanceledReservation(
+        member: MemberSummaryRetrieveResponse,
+        reservation: ReservationEntity,
+        cancelReason: String
+    ) {
+        if (member.role != Role.ADMIN && reservation.memberId != member.id) {
+            log.warn { "[ReservationService.createCanceledPayment] 예약자 본인 또는 관리자가 아닌 회원의 취소 요청: reservationId=${reservation.id}, memberId=${member.id}" }
+            throw ReservationException(ReservationErrorCode.NO_PERMISSION_TO_CANCEL_RESERVATION)
+        }
+
+        CanceledReservationEntity(
+            id = tsidFactory.next(),
+            reservationId = reservation.id,
+            canceledBy = member.id,
+            cancelReason = cancelReason,
+            canceledAt = LocalDateTime.now(),
+            status = CanceledReservationStatus.PROCESSING
+        ).also {
+            canceledReservationRepository.save(it)
+        }
+    }
+
+    private fun validateCanCreate(request: PendingReservationCreateRequest) {
+        val schedule = scheduleService.findSummaryById(request.scheduleId)
+        val theme = themeService.findSummaryById(schedule.themeId)
+
+        reservationValidator.validateCanCreate(schedule, theme, request)
+    }
+}
diff --git a/src/main/kotlin/roomescape/reservation/business/ReservationValidator.kt b/src/main/kotlin/roomescape/reservation/business/ReservationValidator.kt
new file mode 100644
index 00000000..2bcdaea8
--- /dev/null
+++ b/src/main/kotlin/roomescape/reservation/business/ReservationValidator.kt
@@ -0,0 +1,38 @@
+package roomescape.reservation.business
+
+import io.github.oshai.kotlinlogging.KLogger
+import io.github.oshai.kotlinlogging.KotlinLogging
+import org.springframework.stereotype.Component
+import roomescape.reservation.exception.ReservationErrorCode
+import roomescape.reservation.exception.ReservationException
+import roomescape.reservation.web.PendingReservationCreateRequest
+import roomescape.schedule.infrastructure.persistence.ScheduleStatus
+import roomescape.schedule.web.ScheduleSummaryResponse
+import roomescape.theme.web.ThemeSummaryResponse
+
+private val log: KLogger = KotlinLogging.logger {}
+
+@Component
+class ReservationValidator {
+
+    fun validateCanCreate(
+        schedule: ScheduleSummaryResponse,
+        theme: ThemeSummaryResponse,
+        request: PendingReservationCreateRequest
+    ) {
+        if (schedule.status != ScheduleStatus.HOLD) {
+            log.warn { "[ReservationValidator.validateCanCreate] ${schedule.status}인 일정으로 인한 예약 실패" }
+            throw ReservationException(ReservationErrorCode.SCHEDULE_NOT_HOLD)
+        }
+
+        if (theme.minParticipants > request.participantCount) {
+            log.info { "[ReservationValidator.validateCanCreate] 최소 인원 미달로 인한 예약 실패: minParticipants=${theme.minParticipants}, participantCount=${request.participantCount}" }
+            throw ReservationException(ReservationErrorCode.INVALID_PARTICIPANT_COUNT)
+        }
+
+        if (theme.maxParticipants < request.participantCount) {
+            log.info { "[ReservationValidator.validateCanCreate] 최대 인원 초과로 인한 예약 실패: minParticipants=${theme.minParticipants}, participantCount=${request.participantCount}" }
+            throw ReservationException(ReservationErrorCode.INVALID_PARTICIPANT_COUNT)
+        }
+    }
+}
diff --git a/src/main/kotlin/roomescape/reservation/business/ReservationWithPaymentService.kt b/src/main/kotlin/roomescape/reservation/business/ReservationWithPaymentService.kt
deleted file mode 100644
index 3c50e5de..00000000
--- a/src/main/kotlin/roomescape/reservation/business/ReservationWithPaymentService.kt
+++ /dev/null
@@ -1,75 +0,0 @@
-package roomescape.reservation.business
-
-import io.github.oshai.kotlinlogging.KotlinLogging
-import org.springframework.stereotype.Service
-import org.springframework.transaction.annotation.Transactional
-import roomescape.payment.business.PaymentService
-import roomescape.payment.infrastructure.client.PaymentApproveResponse
-import roomescape.payment.web.PaymentCancelRequest
-import roomescape.payment.web.PaymentCancelResponse
-import roomescape.reservation.infrastructure.persistence.ReservationEntity
-import roomescape.reservation.web.ReservationCreateResponse
-import roomescape.reservation.web.ReservationCreateWithPaymentRequest
-import roomescape.reservation.web.toCreateResponse
-import java.time.OffsetDateTime
-
-private val log = KotlinLogging.logger {}
-
-@Service
-@Transactional
-class ReservationWithPaymentService(
-    private val reservationWriteService: ReservationWriteService,
-    private val paymentService: PaymentService,
-) {
-    fun createReservationAndPayment(
-        request: ReservationCreateWithPaymentRequest,
-        approvedPaymentInfo: PaymentApproveResponse,
-        memberId: Long,
-    ): ReservationCreateResponse {
-        log.info { "[ReservationWithPaymentService.createReservationAndPayment] 시작: memberId=$memberId, paymentInfo=$approvedPaymentInfo" }
-
-        val reservation: ReservationEntity = reservationWriteService.createReservationWithPayment(request, memberId)
-            .also { paymentService.createPayment(approvedPaymentInfo, it) }
-
-        return reservation.toCreateResponse()
-            .also { log.info { "[ReservationWithPaymentService.createReservationAndPayment] 완료: reservationId=${reservation.id}, paymentId=${it.id}" } }
-    }
-
-    fun createCanceledPayment(
-        canceledPaymentInfo: PaymentCancelResponse,
-        approvedAt: OffsetDateTime,
-        paymentKey: String,
-    ) {
-        paymentService.createCanceledPayment(canceledPaymentInfo, approvedAt, paymentKey)
-    }
-
-    fun deleteReservationAndPayment(
-        reservationId: Long,
-        memberId: Long,
-    ): PaymentCancelRequest {
-        log.info { "[ReservationWithPaymentService.deleteReservationAndPayment] 시작: reservationId=$reservationId" }
-        val paymentCancelRequest = paymentService.createCanceledPayment(reservationId)
-
-        reservationWriteService.deleteReservation(reservationId, memberId)
-        log.info { "[ReservationWithPaymentService.deleteReservationAndPayment] 완료: reservationId=$reservationId" }
-        return paymentCancelRequest
-    }
-
-    @Transactional(readOnly = true)
-    fun isNotPaidReservation(reservationId: Long): Boolean {
-        log.info { "[ReservationWithPaymentService.isNotPaidReservation] 시작: reservationId=$reservationId" }
-
-        val notPaid: Boolean = !paymentService.existsByReservationId(reservationId)
-
-        return notPaid.also {
-            log.info { "[ReservationWithPaymentService.isNotPaidReservation] 완료: reservationId=$reservationId, isPaid=${notPaid}" }
-        }
-    }
-
-    fun updateCanceledTime(
-        paymentKey: String,
-        canceledAt: OffsetDateTime,
-    ) {
-        paymentService.updateCanceledTime(paymentKey, canceledAt)
-    }
-}
diff --git a/src/main/kotlin/roomescape/reservation/business/ReservationWithPaymentServiceV2.kt b/src/main/kotlin/roomescape/reservation/business/ReservationWithPaymentServiceV2.kt
deleted file mode 100644
index 0c7fef87..00000000
--- a/src/main/kotlin/roomescape/reservation/business/ReservationWithPaymentServiceV2.kt
+++ /dev/null
@@ -1,108 +0,0 @@
-package roomescape.reservation.business
-
-import io.github.oshai.kotlinlogging.KLogger
-import io.github.oshai.kotlinlogging.KotlinLogging
-import jakarta.transaction.Transactional
-import org.springframework.stereotype.Service
-import roomescape.common.util.TransactionExecutionUtil
-import roomescape.payment.implement.PaymentFinderV2
-import roomescape.payment.implement.PaymentRequester
-import roomescape.payment.implement.PaymentWriterV2
-import roomescape.payment.infrastructure.client.v2.PaymentConfirmResponse
-import roomescape.payment.infrastructure.persistence.v2.PaymentEntityV2
-import roomescape.reservation.implement.ReservationFinder
-import roomescape.reservation.implement.ReservationWriter
-import roomescape.reservation.infrastructure.persistence.ReservationEntity
-import roomescape.reservation.infrastructure.persistence.ReservationStatus
-import roomescape.reservation.web.*
-
-private val log: KLogger = KotlinLogging.logger {}
-
-@Service
-class ReservationWithPaymentServiceV2(
-    private val reservationWriter: ReservationWriter,
-    private val reservationFinder: ReservationFinder,
-    private val paymentRequester: PaymentRequester,
-    private val paymentFinder: PaymentFinderV2,
-    private val paymentWriter: PaymentWriterV2,
-    private val transactionExecutionUtil: TransactionExecutionUtil,
-) {
-    @Transactional
-    fun createPendingReservation(memberId: Long, request: ReservationCreateRequest): ReservationCreateResponseV2 {
-        log.info {
-            "[ReservationWithPaymentServiceV2.createPendingReservation] " +
-                    "PENDING 예약 저장 시작: memberId=$memberId, request=$request"
-        }
-
-        val reservation: ReservationEntity = reservationWriter.create(
-            date = request.date,
-            timeId = request.timeId,
-            themeId = request.themeId,
-            status = ReservationStatus.PENDING,
-            memberId = memberId,
-            requesterId = memberId
-        )
-
-        return reservation.toCreateResponseV2().also {
-            log.info {
-                "[ReservationWithPaymentServiceV2.createPendingReservation] " +
-                        "PENDING 예약 저장 완료: reservationId=${reservation.id}, response=$it"
-            }
-        }
-    }
-
-    fun payReservation(
-        memberId: Long,
-        reservationId: Long,
-        request: ReservationPaymentRequest
-    ): ReservationPaymentResponse {
-        log.info {
-            "[ReservationWithPaymentServiceV2.payReservation] " +
-                    "예약 결제 시작: memberId=$memberId, reservationId=$reservationId, request=$request"
-        }
-
-        val paymentConfirmResponse: PaymentConfirmResponse = paymentRequester.requestConfirmPayment(
-            paymentKey = request.paymentKey,
-            orderId = request.orderId,
-            amount = request.amount
-        )
-
-        return transactionExecutionUtil.withNewTransaction(isReadOnly = false) {
-            val payment: PaymentEntityV2 = paymentWriter.createPayment(reservationId, request, paymentConfirmResponse)
-            val reservation: ReservationEntity =
-                reservationWriter.modifyStatusFromPendingToConfirmed(reservationId, memberId)
-
-            ReservationPaymentResponse(reservationId, reservation.status, payment.id, payment.status)
-                .also { log.info { "[ReservationWithPaymentServiceV2.payReservation] 예약 결제 완료: response=${it}" } }
-        }
-    }
-
-    fun cancelReservation(
-        memberId: Long,
-        reservationId: Long,
-        request: ReservationCancelRequest
-    ) {
-        log.info {
-            "[ReservationWithPaymentServiceV2.cancelReservation] " +
-                    "예약 취소 시작: memberId=$memberId, reservationId=$reservationId, request=$request"
-        }
-
-        val reservation: ReservationEntity = reservationFinder.findById(reservationId)
-        val payment: PaymentEntityV2 = paymentFinder.findPaymentByReservationId(reservationId)
-        val paymentCancelResponse = paymentRequester.requestCancelPayment(
-            paymentKey = payment.paymentKey,
-            amount = payment.totalAmount,
-            cancelReason = request.cancelReason
-        )
-
-        transactionExecutionUtil.withNewTransaction(isReadOnly = false) {
-            paymentWriter.createCanceledPayment(memberId, payment, request.requestedAt, paymentCancelResponse)
-            reservationWriter.modifyStatusToCanceledByUser(reservation, memberId)
-        }.also {
-            log.info {
-                "[ReservationWithPaymentServiceV2.cancelReservation] " +
-                        "예약 취소 완료: reservationId=$reservationId, memberId=$memberId, cancelReason=${request.cancelReason}"
-            }
-        }
-    }
-}
diff --git a/src/main/kotlin/roomescape/reservation/business/ReservationWriteService.kt b/src/main/kotlin/roomescape/reservation/business/ReservationWriteService.kt
deleted file mode 100644
index 56cbe099..00000000
--- a/src/main/kotlin/roomescape/reservation/business/ReservationWriteService.kt
+++ /dev/null
@@ -1,104 +0,0 @@
-package roomescape.reservation.business
-
-import io.github.oshai.kotlinlogging.KLogger
-import io.github.oshai.kotlinlogging.KotlinLogging
-import jakarta.transaction.Transactional
-import org.springframework.stereotype.Service
-import roomescape.reservation.implement.ReservationFinder
-import roomescape.reservation.implement.ReservationWriter
-import roomescape.reservation.infrastructure.persistence.ReservationEntity
-import roomescape.reservation.infrastructure.persistence.ReservationStatus
-import roomescape.reservation.web.*
-
-private val log: KLogger = KotlinLogging.logger {}
-
-@Service
-@Transactional
-class ReservationWriteService(
-    private val reservationFinder: ReservationFinder,
-    private val reservationWriter: ReservationWriter
-) {
-    fun createReservationWithPayment(
-        request: ReservationCreateWithPaymentRequest,
-        memberId: Long
-    ): ReservationEntity {
-        log.debug { "[ReservationCommandService.createReservationByAdmin] 시작: date=${request.date}, timeId=${request.timeId}, themeId=${request.themeId}, memberId=${memberId}" }
-
-        val created: ReservationEntity = reservationWriter.create(
-            date = request.date,
-            timeId = request.timeId,
-            themeId = request.themeId,
-            status = ReservationStatus.CONFIRMED,
-            memberId = memberId,
-            requesterId = memberId
-        )
-
-        return created.also {
-            log.info { "[ReservationCommandService.createReservationByAdmin] 완료: reservationId=${it.id}" }
-        }
-    }
-
-    fun createReservationByAdmin(
-        request: AdminReservationCreateRequest,
-        memberId: Long
-    ): ReservationCreateResponse {
-        log.debug { "[ReservationCommandService.createReservationByAdmin] 시작: date=${request.date}, timeId=${request.timeId}, themeId=${request.themeId}, memberId=${request.memberId} by adminId=${memberId}" }
-
-        val created: ReservationEntity = reservationWriter.create(
-            date = request.date,
-            timeId = request.timeId,
-            themeId = request.themeId,
-            status = ReservationStatus.CONFIRMED_PAYMENT_REQUIRED,
-            memberId = request.memberId,
-            requesterId = memberId
-        )
-
-        return created.toCreateResponse()
-            .also {
-                log.info { "[ReservationCommandService.createReservationByAdmin] 관리자 예약 추가 완료: reservationId=${it.id}" }
-            }
-    }
-
-    fun createWaiting(request: WaitingCreateRequest, memberId: Long): ReservationCreateResponse {
-        log.debug { "[ReservationCommandService.createWaiting] 시작: date=${request.date}, timeId=${request.timeId}, themeId=${request.themeId}, memberId=${memberId}" }
-
-        val created: ReservationEntity = reservationWriter.create(
-            date = request.date,
-            timeId = request.timeId,
-            themeId = request.themeId,
-            status = ReservationStatus.WAITING,
-            memberId = memberId,
-            requesterId = memberId
-        )
-
-        return created.toCreateResponse()
-            .also {
-                log.info { "[ReservationCommandService.createWaiting] 완료: reservationId=${it.id}" }
-            }
-    }
-
-    fun deleteReservation(reservationId: Long, memberId: Long) {
-        log.debug { "[ReservationCommandService.deleteReservation] 시작: reservationId=${reservationId}, memberId=$memberId" }
-
-        val reservation: ReservationEntity = reservationFinder.findById(reservationId)
-
-        reservationWriter.deleteConfirmed(reservation, requesterId = memberId)
-            .also { log.info { "[ReservationCommandService.deleteReservation] 완료: reservationId=${reservationId}" } }
-    }
-
-    fun confirmWaiting(reservationId: Long, memberId: Long) {
-        log.debug { "[ReservationCommandService.confirmWaiting] 시작: reservationId=$reservationId (by adminId=$memberId)" }
-
-        reservationWriter.confirm(reservationId)
-            .also { log.info { "[ReservationCommandService.confirmWaiting] 완료: reservationId=$reservationId" } }
-    }
-
-    fun deleteWaiting(reservationId: Long, memberId: Long) {
-        log.debug { "[ReservationCommandService.deleteWaiting] 시작: reservationId=$reservationId (by adminId=$memberId)" }
-
-        val reservation: ReservationEntity = reservationFinder.findById(reservationId)
-
-        reservationWriter.deleteWaiting(reservation, requesterId = memberId)
-            .also { log.info { "[ReservationCommandService.deleteWaiting] 완료: reservationId=$reservationId" } }
-    }
-}
diff --git a/src/main/kotlin/roomescape/reservation/docs/MyReservationAPI.kt b/src/main/kotlin/roomescape/reservation/docs/MyReservationAPI.kt
deleted file mode 100644
index 62799114..00000000
--- a/src/main/kotlin/roomescape/reservation/docs/MyReservationAPI.kt
+++ /dev/null
@@ -1,33 +0,0 @@
-package roomescape.reservation.docs
-
-import io.swagger.v3.oas.annotations.Operation
-import io.swagger.v3.oas.annotations.Parameter
-import io.swagger.v3.oas.annotations.responses.ApiResponse
-import io.swagger.v3.oas.annotations.responses.ApiResponses
-import org.springframework.http.ResponseEntity
-import org.springframework.web.bind.annotation.PathVariable
-import roomescape.auth.web.support.LoginRequired
-import roomescape.auth.web.support.MemberId
-import roomescape.common.dto.response.CommonApiResponse
-import roomescape.reservation.web.ReservationDetailRetrieveResponse
-import roomescape.reservation.web.ReservationSummaryRetrieveListResponse
-
-interface MyReservationAPI {
-    @LoginRequired
-    @Operation(summary = "내 예약 개요 조회", tags = ["로그인이 필요한 API"])
-    @ApiResponses(
-        ApiResponse(responseCode = "200", description = "성공"),
-    )
-    fun findAllMyReservations(
-        @MemberId @Parameter(hidden = true) memberId: Long
-    ): ResponseEntity<CommonApiResponse<ReservationSummaryRetrieveListResponse>>
-
-    @LoginRequired
-    @Operation(summary = "예약 상세 조회", tags = ["로그인이 필요한 API"])
-    @ApiResponses(
-        ApiResponse(responseCode = "200", description = "성공"),
-    )
-    fun showReservationDetails(
-        @PathVariable("id") reservationId: Long
-    ): ResponseEntity<CommonApiResponse<ReservationDetailRetrieveResponse>>
-}
diff --git a/src/main/kotlin/roomescape/reservation/docs/ReservationAPI.kt b/src/main/kotlin/roomescape/reservation/docs/ReservationAPI.kt
index fb5b7dd3..dd3e6612 100644
--- a/src/main/kotlin/roomescape/reservation/docs/ReservationAPI.kt
+++ b/src/main/kotlin/roomescape/reservation/docs/ReservationAPI.kt
@@ -2,150 +2,54 @@ package roomescape.reservation.docs
 
 import io.swagger.v3.oas.annotations.Operation
 import io.swagger.v3.oas.annotations.Parameter
-import io.swagger.v3.oas.annotations.headers.Header
-import io.swagger.v3.oas.annotations.media.Schema
 import io.swagger.v3.oas.annotations.responses.ApiResponse
 import io.swagger.v3.oas.annotations.responses.ApiResponses
-import io.swagger.v3.oas.annotations.tags.Tag
 import jakarta.validation.Valid
-import org.springframework.http.HttpHeaders
 import org.springframework.http.ResponseEntity
 import org.springframework.web.bind.annotation.PathVariable
 import org.springframework.web.bind.annotation.RequestBody
-import org.springframework.web.bind.annotation.RequestParam
-import roomescape.auth.web.support.Admin
 import roomescape.auth.web.support.LoginRequired
 import roomescape.auth.web.support.MemberId
 import roomescape.common.dto.response.CommonApiResponse
 import roomescape.reservation.web.*
-import java.time.LocalDate
 
-@Tag(name = "3. 예약 API", description = "예약 및 대기 정보를 추가 / 조회 / 삭제할 때 사용합니다.")
 interface ReservationAPI {
 
-    @Admin
-    @Operation(summary = "모든 예약 정보 조회", tags = ["관리자 로그인이 필요한 API"])
+    @LoginRequired
+    @Operation(summary = "결제 대기 예약 저장", tags = ["로그인이 필요한 API"])
     @ApiResponses(ApiResponse(responseCode = "200", description = "성공", useReturnTypeSchema = true))
-    fun findReservations(): ResponseEntity<CommonApiResponse<ReservationRetrieveListResponse>>
+    fun createPendingReservation(
+        @MemberId @Parameter(hidden = true) memberId: Long,
+        @Valid @RequestBody request: PendingReservationCreateRequest
+    ): ResponseEntity<CommonApiResponse<PendingReservationCreateResponse>>
 
     @LoginRequired
-    @Operation(summary = "자신의 예약 및 대기 조회", tags = ["로그인이 필요한 API"])
+    @Operation(summary = "예약 확정", tags = ["로그인이 필요한 API"])
     @ApiResponses(ApiResponse(responseCode = "200", description = "성공", useReturnTypeSchema = true))
-    fun findReservationsByMemberId(
-        @MemberId @Parameter(hidden = true) memberId: Long
-    ): ResponseEntity<CommonApiResponse<MyReservationRetrieveListResponse>>
-
-    @Admin
-    @Operation(summary = "관리자의 예약 검색", description = "특정 조건에 해당되는 예약 검색", tags = ["관리자 로그인이 필요한 API"])
-    @ApiResponses(
-        ApiResponse(responseCode = "200", description = "성공", useReturnTypeSchema = true)
-    )
-    fun searchReservations(
-        @RequestParam(required = false) themeId: Long?,
-        @RequestParam(required = false) memberId: Long?,
-        @RequestParam(required = false) dateFrom: LocalDate?,
-        @RequestParam(required = false) dateTo: LocalDate?
-    ): ResponseEntity<CommonApiResponse<ReservationRetrieveListResponse>>
-
-    @Admin
-    @Operation(summary = "관리자의 예약 취소", tags = ["관리자 로그인이 필요한 API"])
-    @ApiResponses(
-        ApiResponse(responseCode = "204", description = "성공"),
-    )
-    fun cancelReservationByAdmin(
-        @MemberId @Parameter(hidden = true) memberId: Long,
-        @PathVariable("id") reservationId: Long
+    fun confirmReservation(
+        @PathVariable("id") id: Long
     ): ResponseEntity<CommonApiResponse<Unit>>
 
     @LoginRequired
-    @Operation(summary = "예약 추가", tags = ["로그인이 필요한 API"])
-    @ApiResponses(
-        ApiResponse(
-            responseCode = "201",
-            description = "성공",
-            useReturnTypeSchema = true,
-            headers = [Header(
-                name = HttpHeaders.LOCATION,
-                description = "생성된 예약 정보 URL",
-                schema = Schema(example = "/reservations/1")
-            )]
-        )
-    )
-    fun createReservationWithPayment(
-        @Valid @RequestBody reservationCreateWithPaymentRequest: ReservationCreateWithPaymentRequest,
-        @MemberId @Parameter(hidden = true) memberId: Long
-    ): ResponseEntity<CommonApiResponse<ReservationCreateResponse>>
-
-    @Admin
-    @Operation(summary = "관리자 예약 추가", tags = ["관리자 로그인이 필요한 API"])
-    @ApiResponses(
-        ApiResponse(
-            responseCode = "201",
-            description = "성공",
-            useReturnTypeSchema = true,
-            headers = [Header(
-                name = HttpHeaders.LOCATION,
-                description = "생성된 예약 정보 URL",
-                schema = Schema(example = "/reservations/1")
-            )],
-        )
-    )
-    fun createReservationByAdmin(
-        @Valid @RequestBody adminReservationRequest: AdminReservationCreateRequest,
-        @MemberId @Parameter(hidden = true) memberId: Long
-    ): ResponseEntity<CommonApiResponse<ReservationCreateResponse>>
-
-    @Admin
-    @Operation(summary = "모든 예약 대기 조회", tags = ["관리자 로그인이 필요한 API"])
+    @Operation(summary = "예약 취소", tags = ["로그인이 필요한 API"])
     @ApiResponses(ApiResponse(responseCode = "200", description = "성공", useReturnTypeSchema = true))
-    fun findAllWaiting(): ResponseEntity<CommonApiResponse<ReservationRetrieveListResponse>>
+    fun cancelReservation(
+        @MemberId @Parameter(hidden = true) memberId: Long,
+        @PathVariable reservationId: Long,
+        @Valid @RequestBody request: ReservationCancelRequest
+    ): ResponseEntity<CommonApiResponse<Unit>>
 
     @LoginRequired
-    @Operation(summary = "예약 대기 신청", tags = ["로그인이 필요한 API"])
-    @ApiResponses(
-        ApiResponse(
-            responseCode = "201",
-            description = "성공",
-            useReturnTypeSchema = true,
-            headers = [Header(
-                name = HttpHeaders.LOCATION,
-                description = "생성된 예약 정보 URL",
-                schema = Schema(example = "/reservations/1")
-            )]
-        )
-    )
-    fun createWaiting(
-        @Valid @RequestBody waitingCreateRequest: WaitingCreateRequest,
-        @MemberId @Parameter(hidden = true) memberId: Long,
-    ): ResponseEntity<CommonApiResponse<ReservationCreateResponse>>
+    @Operation(summary = "회원별 예약 요약 목록 조회", tags = ["로그인이 필요한 API"])
+    @ApiResponses(ApiResponse(responseCode = "200", description = "성공", useReturnTypeSchema = true))
+    fun findSummaryByMemberId(
+        @MemberId @Parameter(hidden = true) memberId: Long
+    ): ResponseEntity<CommonApiResponse<ReservationSummaryRetrieveListResponse>>
 
     @LoginRequired
-    @Operation(summary = "예약 대기 취소", tags = ["로그인이 필요한 API"])
-    @ApiResponses(
-        ApiResponse(responseCode = "204", description = "성공"),
-    )
-    fun cancelWaitingByMember(
-        @MemberId @Parameter(hidden = true) memberId: Long,
-        @PathVariable("id") @Parameter(description = "예약 ID") reservationId: Long
-    ): ResponseEntity<CommonApiResponse<Unit>>
-
-    @Admin
-    @Operation(summary = "대기 중인 예약 승인", tags = ["관리자 로그인이 필요한 API"])
-    @ApiResponses(
-        ApiResponse(responseCode = "200", description = "성공"),
-    )
-    fun confirmWaiting(
-        @MemberId @Parameter(hidden = true) memberId: Long,
-        @PathVariable("id") @Parameter(description = "예약 ID") reservationId: Long
-    ): ResponseEntity<CommonApiResponse<Unit>>
-
-    @Admin
-    @Operation(summary = "대기 중인 예약 거절", tags = ["관리자 로그인이 필요한 API"])
-    @ApiResponses(
-        ApiResponse(responseCode = "204", description = "대기 중인 예약 거절 성공"),
-    )
-    fun rejectWaiting(
-        @MemberId @Parameter(hidden = true) memberId: Long,
-        @PathVariable("id") @Parameter(description = "예약 ID") reservationId: Long
-    ): ResponseEntity<CommonApiResponse<Unit>>
+    @Operation(summary = "특정 예약에 대한 상세 조회", tags = ["로그인이 필요한 API"])
+    @ApiResponses(ApiResponse(responseCode = "200", description = "성공", useReturnTypeSchema = true))
+    fun findDetailById(
+        @PathVariable("id") id: Long
+    ): ResponseEntity<CommonApiResponse<ReservationDetailRetrieveResponse>>
 }
diff --git a/src/main/kotlin/roomescape/reservation/docs/ReservationWithPaymentAPI.kt b/src/main/kotlin/roomescape/reservation/docs/ReservationWithPaymentAPI.kt
deleted file mode 100644
index ffeb3716..00000000
--- a/src/main/kotlin/roomescape/reservation/docs/ReservationWithPaymentAPI.kt
+++ /dev/null
@@ -1,61 +0,0 @@
-package roomescape.reservation.docs
-
-import io.swagger.v3.oas.annotations.Operation
-import io.swagger.v3.oas.annotations.Parameter
-import io.swagger.v3.oas.annotations.headers.Header
-import io.swagger.v3.oas.annotations.media.Schema
-import io.swagger.v3.oas.annotations.responses.ApiResponse
-import io.swagger.v3.oas.annotations.responses.ApiResponses
-import jakarta.validation.Valid
-import org.springframework.http.HttpHeaders
-import org.springframework.http.ResponseEntity
-import org.springframework.web.bind.annotation.PathVariable
-import org.springframework.web.bind.annotation.RequestBody
-import roomescape.auth.web.support.LoginRequired
-import roomescape.auth.web.support.MemberId
-import roomescape.common.dto.response.CommonApiResponse
-import roomescape.reservation.web.*
-
-interface ReservationWithPaymentAPI {
-
-    @LoginRequired
-    @Operation(summary = "예약 추가", tags = ["로그인이 필요한 API"])
-    @ApiResponses(
-        ApiResponse(
-            responseCode = "200",
-            description = "성공",
-            useReturnTypeSchema = true,
-            headers = [Header(
-                name = HttpHeaders.LOCATION,
-                description = "생성된 예약 정보 URL",
-                schema = Schema(example = "/reservations/1")
-            )]
-        )
-    )
-    fun createPendingReservation(
-        @MemberId @Parameter(hidden = true) memberId: Long,
-        @Valid @RequestBody reservationCreateWithPaymentRequest: ReservationCreateRequest
-    ): ResponseEntity<CommonApiResponse<ReservationCreateResponseV2>>
-
-    @LoginRequired
-    @Operation(summary = "예약 취소", tags = ["로그인이 필요한 API"])
-    @ApiResponses(
-        ApiResponse(responseCode = "204", description = "성공"),
-    )
-    fun cancelReservation(
-        @MemberId @Parameter(hidden = true) memberId: Long,
-        @PathVariable("id") reservationId: Long,
-        @Valid @RequestBody cancelRequest: ReservationCancelRequest
-    ): ResponseEntity<CommonApiResponse<Unit>>
-
-    @LoginRequired
-    @Operation(summary = "예약 결제", tags = ["로그인이 필요한 API"])
-    @ApiResponses(
-        ApiResponse(responseCode = "200", description = "성공"),
-    )
-    fun createPaymentAndConfirmReservation(
-        @MemberId @Parameter(hidden = true) memberId: Long,
-        @PathVariable("id") reservationId: Long,
-        @Valid @RequestBody request: ReservationPaymentRequest
-    ): ResponseEntity<CommonApiResponse<ReservationPaymentResponse>>
-}
diff --git a/src/main/kotlin/roomescape/reservation/exception/ReservationErrorCode.kt b/src/main/kotlin/roomescape/reservation/exception/ReservationErrorCode.kt
index 1ca04cfe..942b9984 100644
--- a/src/main/kotlin/roomescape/reservation/exception/ReservationErrorCode.kt
+++ b/src/main/kotlin/roomescape/reservation/exception/ReservationErrorCode.kt
@@ -9,14 +9,9 @@ enum class ReservationErrorCode(
     override val message: String
 ) : ErrorCode {
     RESERVATION_NOT_FOUND(HttpStatus.NOT_FOUND, "R001", "예약을 찾을 수 없어요."),
-    RESERVATION_DUPLICATED(HttpStatus.BAD_REQUEST, "R002", "이미 같은 예약이 있어요."),
-    ALREADY_RESERVE(HttpStatus.BAD_REQUEST, "R003", "같은 날짜, 시간, 테마에 대한 예약(대기)는 한 번만 가능해요."),
-    ALREADY_CONFIRMED(HttpStatus.CONFLICT, "R004", "이미 확정된 예약이에요"),
-    CONFIRMED_RESERVATION_ALREADY_EXISTS(HttpStatus.CONFLICT, "R005", "이미 확정된 예약이 있어서 승인할 수 없어요."),
-    PAST_REQUEST_DATETIME(HttpStatus.BAD_REQUEST, "R005", "과거 시간으로 예약할 수 없어요."),
-    NOT_RESERVATION_OWNER(HttpStatus.FORBIDDEN, "R006", "타인의 예약은 취소할 수 없어요."),
-    INVALID_SEARCH_DATE_RANGE(HttpStatus.BAD_REQUEST, "R007", "종료 날짜는 시작 날짜 이후여야 해요."),
-    NO_PERMISSION(HttpStatus.FORBIDDEN, "R008", "접근 권한이 없어요."),
-    RESERVATION_NOT_PENDING(HttpStatus.BAD_REQUEST, "R009", "결제 대기 중인 예약이 아니에요."),
+    NO_PERMISSION_TO_CANCEL_RESERVATION(HttpStatus.FORBIDDEN, "R002", "예약을 취소할 수 있는 권한이 없어요."),
+    INVALID_SEARCH_DATE_RANGE(HttpStatus.BAD_REQUEST, "R003", "종료 날짜는 시작 날짜 이후여야 해요."),
+    SCHEDULE_NOT_HOLD(HttpStatus.BAD_REQUEST, "R004", "이미 예약되었거나 예약이 불가능한 일정이에요."),
+    INVALID_PARTICIPANT_COUNT(HttpStatus.BAD_REQUEST, "R005", "참여 가능 인원 수를 확인해주세요.")
     ;
 }
diff --git a/src/main/kotlin/roomescape/reservation/implement/ReservationFinder.kt b/src/main/kotlin/roomescape/reservation/implement/ReservationFinder.kt
deleted file mode 100644
index 17d74611..00000000
--- a/src/main/kotlin/roomescape/reservation/implement/ReservationFinder.kt
+++ /dev/null
@@ -1,113 +0,0 @@
-package roomescape.reservation.implement
-
-import io.github.oshai.kotlinlogging.KLogger
-import io.github.oshai.kotlinlogging.KotlinLogging
-import org.springframework.data.jpa.domain.Specification
-import org.springframework.data.repository.findByIdOrNull
-import org.springframework.stereotype.Component
-import roomescape.reservation.exception.ReservationErrorCode
-import roomescape.reservation.exception.ReservationException
-import roomescape.reservation.infrastructure.persistence.ReservationEntity
-import roomescape.reservation.infrastructure.persistence.ReservationRepository
-import roomescape.reservation.infrastructure.persistence.ReservationSearchSpecification
-import roomescape.reservation.infrastructure.persistence.ReservationStatus
-import roomescape.reservation.web.MyReservationRetrieveResponse
-import roomescape.theme.infrastructure.persistence.ThemeEntity
-import roomescape.time.infrastructure.persistence.TimeEntity
-import java.time.LocalDate
-
-private val log: KLogger = KotlinLogging.logger {}
-
-@Component
-class ReservationFinder(
-    private val reservationRepository: ReservationRepository,
-    private val reservationValidator: ReservationValidator,
-) {
-    fun findById(id: Long): ReservationEntity {
-        log.debug { "[ReservationFinder.findById] 시작: id=$id" }
-
-        return reservationRepository.findByIdOrNull(id)
-            ?.also { log.debug { "[ReservationFinder.findById] 완료: reservationId=$id, date:${it.date}, timeId:${it.time.id}, themeId:${it.theme.id}" } }
-            ?: run {
-                log.warn { "[ReservationFinder.findById] 조회 실패: reservationId=$id" }
-                throw ReservationException(ReservationErrorCode.RESERVATION_NOT_FOUND)
-            }
-    }
-
-    fun findAllByStatuses(vararg statuses: ReservationStatus): List<ReservationEntity> {
-        log.debug { "[ReservationFinder.findAll] 시작: status=${statuses}" }
-
-        val spec = ReservationSearchSpecification()
-            .status(*statuses)
-            .build()
-
-        return reservationRepository.findAll(spec)
-            .also { log.debug { "[ReservationFinder.findAll] ${it.size}개 예약 조회 완료: status=${statuses}" } }
-    }
-
-    fun findAllByDateAndTheme(
-        date: LocalDate, theme: ThemeEntity
-    ): List<ReservationEntity> {
-        log.debug { "[ReservationFinder.findAllByDateAndTheme] 시작: date=$date, themeId=${theme.id}" }
-
-        return reservationRepository.findAllByDateAndTheme(date, theme)
-            .also { log.debug { "[ReservationFinder.findAllByDateAndTheme] ${it.size}개 조회 완료: date=$date, themeId=${theme.id}" } }
-    }
-
-    fun findAllByMemberIdV2(memberId: Long): List<ReservationEntity> {
-        log.debug { "[ReservationFinder.findAllByMember] 시작: memberId=${memberId}" }
-
-        return reservationRepository.findAllByMember_Id(memberId)
-            .filter { it.status == ReservationStatus.CONFIRMED || it.status == ReservationStatus.CANCELED_BY_USER }
-            .sortedByDescending { it.date }
-            .also { log.debug { "[ReservationFinder.findAllByMember] ${it.size}개 예약 조회 완료: memberId=${memberId}" } }
-    }
-
-    fun findAllByMemberId(memberId: Long): List<MyReservationRetrieveResponse> {
-        log.debug { "[ReservationFinder.findAllByMemberId] 시작: memberId=${memberId}" }
-
-        return reservationRepository.findAllByMemberId(memberId)
-            .also { log.debug { "[ReservationFinder.findAllByMemberId] ${it.size}개 예약(대기) 조회 완료: memberId=${memberId}" } }
-    }
-
-    fun searchReservations(
-        themeId: Long?,
-        memberId: Long?,
-        startFrom: LocalDate?,
-        endAt: LocalDate?,
-    ): List<ReservationEntity> {
-        reservationValidator.validateSearchDateRange(startFrom, endAt)
-
-        val spec: Specification<ReservationEntity> = ReservationSearchSpecification()
-            .sameThemeId(themeId)
-            .sameMemberId(memberId)
-            .dateStartFrom(startFrom)
-            .dateEndAt(endAt)
-            .status(ReservationStatus.CONFIRMED, ReservationStatus.CONFIRMED_PAYMENT_REQUIRED)
-            .build()
-
-        return reservationRepository.findAll(spec)
-            .also {
-                log.debug { "[ReservationFinder.searchReservations] ${it.size}개 예약 조회 완료. " +
-                    "themeId=${themeId}, memberId=${memberId}, startFrom=${startFrom}, endAt=${endAt}" }
-            }
-
-    }
-
-    fun isTimeReserved(time: TimeEntity): Boolean {
-        log.debug { "[ReservationFinder.isTimeReserved] 시작: timeId=${time.id}, startAt=${time.startAt}" }
-
-        return reservationRepository.existsByTime(time)
-            .also { log.debug { "[ReservationFinder.isTimeReserved] 완료: isExist=$it, timeId=${time.id}, startAt=${time.startAt}" } }
-    }
-
-    fun findPendingReservation(reservationId: Long, memberId: Long): ReservationEntity {
-        log.debug { "[ReservationFinder.findPendingReservationIfExists] 시작: reservationId=$reservationId, memberId=$memberId" }
-
-        return findById(reservationId).also {
-            reservationValidator.validateIsReservedByMemberAndPending(it, memberId)
-        }.also {
-            log.debug { "[ReservationFinder.findPendingReservationIfExists] 완료: reservationId=${it.id}, status=${it.status}" }
-        }
-    }
-}
diff --git a/src/main/kotlin/roomescape/reservation/implement/ReservationValidator.kt b/src/main/kotlin/roomescape/reservation/implement/ReservationValidator.kt
deleted file mode 100644
index 78285bda..00000000
--- a/src/main/kotlin/roomescape/reservation/implement/ReservationValidator.kt
+++ /dev/null
@@ -1,178 +0,0 @@
-package roomescape.reservation.implement
-
-import io.github.oshai.kotlinlogging.KLogger
-import io.github.oshai.kotlinlogging.KotlinLogging
-import org.springframework.data.jpa.domain.Specification
-import org.springframework.stereotype.Component
-import roomescape.member.infrastructure.persistence.MemberEntity
-import roomescape.reservation.exception.ReservationErrorCode
-import roomescape.reservation.exception.ReservationException
-import roomescape.reservation.infrastructure.persistence.ReservationEntity
-import roomescape.reservation.infrastructure.persistence.ReservationRepository
-import roomescape.reservation.infrastructure.persistence.ReservationSearchSpecification
-import roomescape.reservation.infrastructure.persistence.ReservationStatus
-import roomescape.theme.infrastructure.persistence.ThemeEntity
-import roomescape.time.infrastructure.persistence.TimeEntity
-import java.time.LocalDate
-import java.time.LocalDateTime
-import java.time.LocalTime
-
-private val log: KLogger = KotlinLogging.logger {}
-
-@Component
-class ReservationValidator(
-    private val reservationRepository: ReservationRepository,
-) {
-    fun validateIsPast(
-        requestDate: LocalDate,
-        requestTime: LocalTime,
-    ) {
-        val now = LocalDateTime.now()
-        val requestDateTime = LocalDateTime.of(requestDate, requestTime)
-        log.debug { "[ReservationValidator.validateIsPast] 시작. request=$requestDateTime, now=$now" }
-
-        if (requestDateTime.isBefore(now)) {
-            log.info { "[ReservationValidator.validateIsPast] 날짜 범위 오류. request=$requestDateTime, now=$now" }
-            throw ReservationException(ReservationErrorCode.PAST_REQUEST_DATETIME)
-        }
-
-        log.debug { "[ReservationValidator.validateIsPast] 완료. request=$requestDateTime, now=$now" }
-    }
-
-    fun validateSearchDateRange(startFrom: LocalDate?, endAt: LocalDate?) {
-        log.debug { "[ReservationValidator.validateSearchDateRange] 시작: startFrom=$startFrom, endAt=$endAt" }
-        if (startFrom == null || endAt == null) {
-            log.debug { "[ReservationValidator.validateSearchDateRange] 완료: startFrom=$startFrom, endAt=$endAt" }
-            return
-        }
-        if (startFrom.isAfter(endAt)) {
-            log.info { "[ReservationValidator.validateSearchDateRange] 날짜 범위 오류: startFrom=$startFrom, endAt=$endAt" }
-            throw ReservationException(ReservationErrorCode.INVALID_SEARCH_DATE_RANGE)
-        }
-        log.debug { "[ReservationValidator.validateSearchDateRange] 완료: startFrom=$startFrom, endAt=$endAt" }
-    }
-
-    fun validateIsAlreadyExists(date: LocalDate, time: TimeEntity, theme: ThemeEntity) {
-        val themeId = theme.id
-        val timeId = time.id
-
-        log.debug { "[ReservationValidator.validateIsAlreadyExists] 시작: date=$date, timeId=$timeId, themeId=$themeId" }
-
-        val spec: Specification<ReservationEntity> = ReservationSearchSpecification()
-            .sameThemeId(themeId)
-            .sameTimeId(timeId)
-            .sameDate(date)
-            .build()
-
-        if (reservationRepository.exists(spec)) {
-            log.warn { "[ReservationValidator.validateIsAlreadyExists] 중복된 예약 존재: date=$date, timeId=$timeId, themeId=$themeId" }
-            throw ReservationException(ReservationErrorCode.RESERVATION_DUPLICATED)
-        }
-
-        log.debug { "[ReservationValidator.validateIsAlreadyExists] 완료: date=$date, timeId=$timeId, themeId=$themeId" }
-    }
-
-    fun validateMemberAlreadyReserve(themeId: Long, timeId: Long, date: LocalDate, requesterId: Long) {
-        log.debug { "[ReservationValidator.validateMemberAlreadyReserve] 시작: themeId=$themeId, timeId=$timeId, date=$date, requesterId=$requesterId" }
-
-        val spec: Specification<ReservationEntity> = ReservationSearchSpecification()
-            .sameMemberId(requesterId)
-            .sameThemeId(themeId)
-            .sameTimeId(timeId)
-            .sameDate(date)
-            .build()
-
-        if (reservationRepository.exists(spec)) {
-            log.warn { "[ReservationValidator.validateMemberAlreadyReserve] 중복된 예약 존재: themeId=$themeId, timeId=$timeId, date=$date" }
-            throw ReservationException(ReservationErrorCode.ALREADY_RESERVE)
-        }
-
-        log.debug { "[ReservationValidator.validateMemberAlreadyReserve] 완료: themeId=$themeId, timeId=$timeId, date=$date, requesterId=$requesterId" }
-    }
-
-    fun validateIsWaiting(reservation: ReservationEntity) {
-        log.debug { "[ReservationValidator.validateIsWaiting] 시작: reservationId=${reservation.id}, status=${reservation.status}" }
-
-        if (!reservation.isWaiting()) {
-            log.warn { "[ReservationValidator.validateIsWaiting] 대기 상태가 아님: reservationId=${reservation.id}, status=${reservation.status}" }
-            throw ReservationException(ReservationErrorCode.ALREADY_CONFIRMED)
-        }
-
-        log.debug { "[ReservationValidator.validateIsWaiting] 완료: reservationId=${reservation.id}, status=${reservation.status}" }
-    }
-
-    fun validateCreateAuthority(requester: MemberEntity) {
-        log.debug { "[ReservationValidator.validateCreateAuthority] 시작: requesterId=${requester.id}" }
-
-        if (!requester.isAdmin()) {
-            log.error { "[ReservationValidator.validateCreateAuthority] 관리자가 아닌 다른 회원의 예약 시도: requesterId=${requester.id}" }
-            throw ReservationException(ReservationErrorCode.NO_PERMISSION)
-        }
-
-        log.debug { "[ReservationValidator.validateCreateAuthority] 완료: requesterId=${requester.id}" }
-    }
-
-    fun validateDeleteAuthority(reservation: ReservationEntity, requester: MemberEntity) {
-        val requesterId: Long = requester.id!!
-        log.debug { "[ReservationValidator.validateDeleteAuthority] 시작: reservationId=${reservation.id}, requesterId=${requesterId}" }
-
-        if (requester.isAdmin()) {
-            log.debug { "[ReservationValidator.validateDeleteAuthority] 완료: reservationId=${reservation.id} requesterId=${requesterId}(Admin)" }
-            return
-        }
-
-        if (!reservation.isReservedBy(requesterId)) {
-            log.error {
-                "[ReservationValidator.validateDeleteAuthority] 예약자 본인이 아님: reservationId=${reservation.id}" +
-                        ", memberId=${reservation.member.id} requesterId=${requesterId} "
-            }
-            throw ReservationException(ReservationErrorCode.NOT_RESERVATION_OWNER)
-        }
-
-        log.debug { "[ReservationValidator.validateDeleteAuthority] 완료: reservationId=${reservation.id}, requesterId=$requesterId" }
-    }
-
-    fun validateAlreadyConfirmed(reservationId: Long) {
-        log.debug { "[ReservationValidator.validateAlreadyConfirmed] 시작: reservationId=$reservationId" }
-
-        if (reservationRepository.isExistConfirmedReservation(reservationId)) {
-            log.warn { "[ReservationWriter.confirm] 이미 확정된 예약: reservationId=$reservationId" }
-            throw ReservationException(ReservationErrorCode.CONFIRMED_RESERVATION_ALREADY_EXISTS)
-        }
-
-        log.debug { "[ReservationValidator.validateAlreadyConfirmed] 완료: reservationId=$reservationId" }
-    }
-
-    fun validateIsReservedByMemberAndPending(reservation: ReservationEntity, requesterId: Long) {
-        if (reservation.member.id != requesterId) {
-            log.error { "[ReservationValidator.validateIsReservedByMemberAndPending] 예약자 본인이 아님: reservationId=${reservation.id}, reservation.memberId=${reservation.member.id} requesterId=$requesterId" }
-            throw ReservationException(ReservationErrorCode.NOT_RESERVATION_OWNER)
-        }
-        if (reservation.status != ReservationStatus.PENDING) {
-            log.warn { "[ReservationValidator.validateIsReservedByMemberAndPending] 예약 상태가 대기 중이 아님: reservationId=${reservation.id}, status=${reservation.status}" }
-            throw ReservationException(ReservationErrorCode.RESERVATION_NOT_PENDING)
-        }
-    }
-
-    fun validateIsPending(reservation: ReservationEntity) {
-        log.debug { "[ReservationValidator.validateIsPending] 시작: reservationId=${reservation.id}, status=${reservation.status}" }
-
-        if (reservation.status != ReservationStatus.PENDING) {
-            log.warn { "[ReservationValidator.validateIsPending] 예약 상태가 결제 대기 중이 아님: reservationId=${reservation.id}, status=${reservation.status}" }
-            throw ReservationException(ReservationErrorCode.RESERVATION_NOT_PENDING)
-        }
-
-        log.debug { "[ReservationValidator.validateIsPending] 완료: reservationId=${reservation.id}, status=${reservation.status}" }
-    }
-
-    fun validateModifyAuthority(reservation: ReservationEntity, memberId: Long) {
-        log.debug { "[ReservationValidator.validateModifyAuthority] 시작: reservationId=${reservation.id}, memberId=$memberId" }
-
-        if (reservation.member.id != memberId) {
-            log.error { "[ReservationValidator.validateModifyAuthority] 예약자 본인이 아님: reservationId=${reservation.id}, reservation.memberId=${reservation.member.id} memberId=$memberId" }
-            throw ReservationException(ReservationErrorCode.NOT_RESERVATION_OWNER)
-        }
-
-        log.debug { "[ReservationValidator.validateModifyAuthority] 완료: reservationId=${reservation.id}, memberId=$memberId" }
-    }
-}
diff --git a/src/main/kotlin/roomescape/reservation/implement/ReservationWriter.kt b/src/main/kotlin/roomescape/reservation/implement/ReservationWriter.kt
deleted file mode 100644
index add04a0d..00000000
--- a/src/main/kotlin/roomescape/reservation/implement/ReservationWriter.kt
+++ /dev/null
@@ -1,131 +0,0 @@
-package roomescape.reservation.implement
-
-import com.github.f4b6a3.tsid.TsidFactory
-import io.github.oshai.kotlinlogging.KLogger
-import io.github.oshai.kotlinlogging.KotlinLogging
-import org.springframework.data.repository.findByIdOrNull
-import org.springframework.stereotype.Component
-import roomescape.common.config.next
-import roomescape.member.implement.MemberFinder
-import roomescape.reservation.exception.ReservationErrorCode
-import roomescape.reservation.exception.ReservationException
-import roomescape.reservation.infrastructure.persistence.ReservationEntity
-import roomescape.reservation.infrastructure.persistence.ReservationRepository
-import roomescape.reservation.infrastructure.persistence.ReservationStatus
-import roomescape.theme.implement.ThemeFinder
-import roomescape.time.implement.TimeFinder
-import java.time.LocalDate
-
-private val log: KLogger = KotlinLogging.logger {}
-
-@Component
-class ReservationWriter(
-    private val reservationValidator: ReservationValidator,
-    private val reservationRepository: ReservationRepository,
-    private val memberFinder: MemberFinder,
-    private val timeFinder: TimeFinder,
-    private val themeFinder: ThemeFinder,
-    private val tsidFactory: TsidFactory,
-) {
-    fun create(
-        date: LocalDate,
-        timeId: Long,
-        themeId: Long,
-        memberId: Long,
-        status: ReservationStatus,
-        requesterId: Long
-    ): ReservationEntity {
-        log.debug {
-            "[ReservationWriter.create] 시작: " +
-                    "date=${date}, timeId=${timeId}, themeId=${themeId}, memberId=${memberId}, status=${status}"
-        }
-        val time = timeFinder.findById(timeId).also {
-            reservationValidator.validateIsPast(date, it.startAt)
-        }
-        val theme = themeFinder.findById(themeId)
-
-        val member = memberFinder.findById(memberId).also {
-            if (status == ReservationStatus.WAITING) {
-                reservationValidator.validateMemberAlreadyReserve(themeId, timeId, date, it.id!!)
-            } else {
-                reservationValidator.validateIsAlreadyExists(date, time, theme)
-            }
-
-            if (memberId != requesterId) {
-                val requester = memberFinder.findById(requesterId)
-                reservationValidator.validateCreateAuthority(requester)
-            }
-        }
-
-        val reservation = ReservationEntity(
-            _id = tsidFactory.next(),
-            date = date,
-            time = time,
-            theme = theme,
-            member = member,
-            status = status
-        )
-
-        return reservationRepository.save(reservation)
-            .also { log.debug { "[ReservationWriter.create] 완료: reservationId=${it.id}, status=${it.status}" } }
-    }
-
-    fun deleteWaiting(reservation: ReservationEntity, requesterId: Long) {
-        log.debug { "[ReservationWriter.deleteWaiting] 시작: reservationId=${reservation.id}, requesterId=${requesterId}" }
-
-        reservationValidator.validateIsWaiting(reservation)
-
-        delete(reservation, requesterId)
-            .also { log.debug { "[ReservationWriter.deleteWaiting] 완료: reservationId=${reservation.id}, status=${reservation.status}" } }
-    }
-
-    fun deleteConfirmed(reservation: ReservationEntity, requesterId: Long) {
-        log.debug { "[ReservationWriter.deleteConfirmed] 시작: reservationId=${reservation.id}, requesterId=${requesterId}" }
-
-        delete(reservation, requesterId)
-            .also { log.debug { "[ReservationWriter.deleteConfirmed] 완료: reservationId=${reservation.id}, status=${reservation.status}" } }
-    }
-
-    private fun delete(reservation: ReservationEntity, requesterId: Long) {
-        memberFinder.findById(requesterId)
-            .also { reservationValidator.validateDeleteAuthority(reservation, requester = it) }
-
-        reservationRepository.delete(reservation)
-    }
-
-    fun confirm(reservationId: Long) {
-        log.debug { "[ReservationWriter.confirm] 대기 여부 확인 시작: reservationId=$reservationId" }
-
-        reservationValidator.validateAlreadyConfirmed(reservationId)
-
-        reservationRepository.updateStatusByReservationId(reservationId, ReservationStatus.CONFIRMED_PAYMENT_REQUIRED)
-
-        log.debug { "[ReservationWriter.confirm] 완료: reservationId=$reservationId, status=${ReservationStatus.CONFIRMED_PAYMENT_REQUIRED}" }
-    }
-
-    fun modifyStatusToCanceledByUser(reservation: ReservationEntity, requesterId: Long) {
-        log.debug { "[ReservationWriter.cancel] 예약 취소 시작: reservationId=${reservation.id}, requesterId=$requesterId" }
-
-        memberFinder.findById(requesterId)
-            .also { reservationValidator.validateDeleteAuthority(reservation, requester = it) }
-
-        reservation.cancelByUser().also {
-            log.debug { "[ReservationWriter.cancel] 예약 취소 완료: reservationId=${reservation.id}" }
-        }
-    }
-
-    fun modifyStatusFromPendingToConfirmed(reservationId: Long, memberId: Long): ReservationEntity {
-        log.debug { "[ReservationWriter.confirmPendingReservation] 시작: reservationId=$reservationId, memberId=$memberId" }
-
-        return reservationRepository.findByIdOrNull(reservationId)?.also {
-            reservationValidator.validateIsPending(it)
-            reservationValidator.validateModifyAuthority(it, memberId)
-
-            it.confirm()
-            log.debug { "[ReservationWriter.confirmPendingReservation] 완료: reservationId=${it.id}, status=${it.status}" }
-        } ?: run {
-            log.warn { "[ReservationWriter.confirmPendingReservation] 예약을 찾을 수 없음: reservationId=$reservationId" }
-            throw ReservationException(ReservationErrorCode.RESERVATION_NOT_FOUND)
-        }
-    }
-}
diff --git a/src/main/kotlin/roomescape/reservation/infrastructure/persistence/CanceledReservationEntity.kt b/src/main/kotlin/roomescape/reservation/infrastructure/persistence/CanceledReservationEntity.kt
new file mode 100644
index 00000000..7d8f7d0b
--- /dev/null
+++ b/src/main/kotlin/roomescape/reservation/infrastructure/persistence/CanceledReservationEntity.kt
@@ -0,0 +1,27 @@
+package roomescape.reservation.infrastructure.persistence
+
+import jakarta.persistence.Entity
+import jakarta.persistence.EnumType
+import jakarta.persistence.Enumerated
+import jakarta.persistence.Table
+import roomescape.common.entity.BaseEntityV2
+import java.time.LocalDateTime
+
+@Entity
+@Table(name = "canceled_reservation")
+class CanceledReservationEntity(
+    id: Long,
+
+    val reservationId: Long,
+    val canceledBy: Long,
+    val cancelReason: String,
+    val canceledAt: LocalDateTime,
+
+    @Enumerated(value = EnumType.STRING)
+    val status: CanceledReservationStatus,
+
+    ) : BaseEntityV2(id)
+
+enum class CanceledReservationStatus {
+    PROCESSING, FAILED, COMPLETED
+}
diff --git a/src/main/kotlin/roomescape/reservation/infrastructure/persistence/CanceledReservationRepository.kt b/src/main/kotlin/roomescape/reservation/infrastructure/persistence/CanceledReservationRepository.kt
new file mode 100644
index 00000000..5508bc11
--- /dev/null
+++ b/src/main/kotlin/roomescape/reservation/infrastructure/persistence/CanceledReservationRepository.kt
@@ -0,0 +1,5 @@
+package roomescape.reservation.infrastructure.persistence
+
+import org.springframework.data.jpa.repository.JpaRepository
+
+interface CanceledReservationRepository : JpaRepository<CanceledReservationEntity, Long>
\ No newline at end of file
diff --git a/src/main/kotlin/roomescape/reservation/infrastructure/persistence/ReservationEntity.kt b/src/main/kotlin/roomescape/reservation/infrastructure/persistence/ReservationEntity.kt
index 3ad2949c..48e68558 100644
--- a/src/main/kotlin/roomescape/reservation/infrastructure/persistence/ReservationEntity.kt
+++ b/src/main/kotlin/roomescape/reservation/infrastructure/persistence/ReservationEntity.kt
@@ -1,68 +1,35 @@
 package roomescape.reservation.infrastructure.persistence
 
-import com.fasterxml.jackson.annotation.JsonIgnore
-import jakarta.persistence.*
-import roomescape.common.entity.BaseEntity
-import roomescape.member.infrastructure.persistence.MemberEntity
-import roomescape.theme.infrastructure.persistence.ThemeEntity
-import roomescape.time.infrastructure.persistence.TimeEntity
-import java.time.LocalDate
+import jakarta.persistence.Entity
+import jakarta.persistence.EnumType
+import jakarta.persistence.Enumerated
+import jakarta.persistence.Table
+import roomescape.common.entity.AuditingBaseEntity
 
 @Entity
-@Table(name = "reservations")
+@Table(name = "reservation")
 class ReservationEntity(
-    @Id
-    @Column(name = "reservation_id")
-    private var _id: Long?,
+    id: Long,
 
-    @Column(name = "date", nullable = false)
-    var date: LocalDate,
-
-    @ManyToOne(fetch = FetchType.LAZY)
-    @JoinColumn(name = "time_id", nullable = false)
-    var time: TimeEntity,
-
-    @ManyToOne(fetch = FetchType.LAZY)
-    @JoinColumn(name = "theme_id", nullable = false)
-    var theme: ThemeEntity,
-
-    @ManyToOne(fetch = FetchType.LAZY)
-    @JoinColumn(name = "member_id", nullable = false)
-    var member: MemberEntity,
+    val memberId: Long,
+    val scheduleId: Long,
+    val reserverName: String,
+    val reserverContact: String,
+    val participantCount: Short,
+    val requirement: String,
 
     @Enumerated(value = EnumType.STRING)
-    @Column(name = "status", nullable = false, length = 30)
     var status: ReservationStatus,
-): BaseEntity() {
-    override fun getId(): Long? = _id
-
-    @JsonIgnore
-    fun isWaiting(): Boolean = status == ReservationStatus.WAITING
-
-    @JsonIgnore
-    fun isReservedBy(memberId: Long): Boolean {
-        return this.member.id == memberId
-    }
-
-    fun cancelByUser() {
-        this.status = ReservationStatus.CANCELED_BY_USER
-    }
-
+) : AuditingBaseEntity(id) {
     fun confirm() {
         this.status = ReservationStatus.CONFIRMED
     }
+
+    fun cancel() {
+        this.status = ReservationStatus.CANCELED
+    }
 }
 
 enum class ReservationStatus {
-    CONFIRMED,
-    CONFIRMED_PAYMENT_REQUIRED,
-    PENDING,
-    WAITING,
-    CANCELED_BY_USER,
-    AUTOMATICALLY_CANCELED,
-    ;
-
-    companion object {
-        fun confirmedStatus(): Array<ReservationStatus> = arrayOf(CONFIRMED, CONFIRMED_PAYMENT_REQUIRED)
-    }
+    PENDING, CONFIRMED, CANCELED, FAILED, EXPIRED
 }
diff --git a/src/main/kotlin/roomescape/reservation/infrastructure/persistence/ReservationRepository.kt b/src/main/kotlin/roomescape/reservation/infrastructure/persistence/ReservationRepository.kt
index e8e20b6b..a36616a6 100644
--- a/src/main/kotlin/roomescape/reservation/infrastructure/persistence/ReservationRepository.kt
+++ b/src/main/kotlin/roomescape/reservation/infrastructure/persistence/ReservationRepository.kt
@@ -1,75 +1,8 @@
 package roomescape.reservation.infrastructure.persistence
 
-import org.springframework.data.jpa.domain.Specification
 import org.springframework.data.jpa.repository.JpaRepository
-import org.springframework.data.jpa.repository.JpaSpecificationExecutor
-import org.springframework.data.jpa.repository.Modifying
-import org.springframework.data.jpa.repository.Query
-import org.springframework.data.repository.query.Param
-import roomescape.reservation.web.MyReservationRetrieveResponse
-import roomescape.theme.infrastructure.persistence.ThemeEntity
-import roomescape.time.infrastructure.persistence.TimeEntity
-import java.time.LocalDate
 
-interface ReservationRepository
-    : JpaRepository<ReservationEntity, Long>, JpaSpecificationExecutor<ReservationEntity> {
-    fun findAllByTime(time: TimeEntity): List<ReservationEntity>
-    fun existsByTime(time: TimeEntity): Boolean
+interface ReservationRepository : JpaRepository<ReservationEntity, Long> {
 
-    fun findByDateAndThemeId(date: LocalDate, themeId: Long): List<ReservationEntity>
-
-    @Modifying
-    @Query(
-        """
-		UPDATE ReservationEntity r
-		SET r.status = :status
-		WHERE r._id = :_id
-		"""
-    )
-    fun updateStatusByReservationId(
-        @Param(value = "_id") reservationId: Long,
-        @Param(value = "status") statusForChange: ReservationStatus
-    ): Int
-
-    @Query(
-        """
-		SELECT EXISTS (
-            SELECT 1
-            FROM ReservationEntity r2
-            WHERE r2._id = :_id 
-              AND EXISTS (   
-                  SELECT 1 FROM ReservationEntity r
-                  WHERE r.theme._id = r2.theme._id
-                    AND r.time._id = r2.time._id
-                    AND r.date = r2.date
-                    AND r.status != 'WAITING'
-            ) 
-        )
-	"""
-    )
-    fun isExistConfirmedReservation(@Param("_id") reservationId: Long): Boolean
-
-    @Query(
-        """
-		SELECT new roomescape.reservation.web.MyReservationRetrieveResponse(
-		    r._id,
-		    t.name,
-		    r.date,
-		    r.time.startAt,
-		    r.status,
-		    (SELECT COUNT (r2) * 1L FROM ReservationEntity r2 WHERE r2.theme = r.theme AND r2.date = r.date AND r2.time = r.time AND r2._id < r._id),
-		    p.paymentKey,
-		    p.totalAmount
-		)
-		FROM ReservationEntity r
-		JOIN r.theme t
-		LEFT JOIN PaymentEntity p
-		ON p.reservation = r
-		WHERE r.member._id = :memberId
-		"""
-    )
-    fun findAllByMemberId(memberId: Long): List<MyReservationRetrieveResponse>
-    fun findAllByDateAndTheme(date: LocalDate, theme: ThemeEntity): List<ReservationEntity>
-
-    fun findAllByMember_Id(memberId: Long): List<ReservationEntity>
+    fun findAllByMemberId(memberId: Long): List<ReservationEntity>
 }
diff --git a/src/main/kotlin/roomescape/reservation/infrastructure/persistence/ReservationSearchSpecification.kt b/src/main/kotlin/roomescape/reservation/infrastructure/persistence/ReservationSearchSpecification.kt
deleted file mode 100644
index f760a897..00000000
--- a/src/main/kotlin/roomescape/reservation/infrastructure/persistence/ReservationSearchSpecification.kt
+++ /dev/null
@@ -1,80 +0,0 @@
-package roomescape.reservation.infrastructure.persistence
-
-import org.springframework.data.jpa.domain.Specification
-import roomescape.member.infrastructure.persistence.MemberEntity
-import roomescape.theme.infrastructure.persistence.ThemeEntity
-import roomescape.time.infrastructure.persistence.TimeEntity
-import java.time.LocalDate
-
-class ReservationSearchSpecification(
-    private var spec: Specification<ReservationEntity> = Specification { _, _, _ -> null }
-) {
-    fun sameThemeId(themeId: Long?): ReservationSearchSpecification = andIfNotNull(themeId?.let {
-        Specification { root, _, cb ->
-            cb.equal(root.get<ThemeEntity>("theme").get<Long>("id"), themeId)
-        }
-    })
-
-    fun sameMemberId(memberId: Long?): ReservationSearchSpecification = andIfNotNull(memberId?.let {
-        Specification { root, _, cb ->
-            cb.equal(root.get<MemberEntity>("member").get<Long>("id"), memberId)
-        }
-    })
-
-    fun sameTimeId(timeId: Long?): ReservationSearchSpecification = andIfNotNull(timeId?.let {
-        Specification { root, _, cb ->
-            cb.equal(root.get<TimeEntity>("time").get<Long>("id"), timeId)
-        }
-    })
-
-    fun sameDate(date: LocalDate?): ReservationSearchSpecification = andIfNotNull(date?.let {
-        Specification { root, _, cb ->
-            cb.equal(root.get<LocalDate>("date"), date)
-        }
-    })
-
-    fun status(vararg statuses: ReservationStatus) = andIfNotNull { root, _, cb ->
-        root.get<ReservationStatus>("status").`in`(statuses.toList())
-    }
-
-    fun confirmed(): ReservationSearchSpecification = andIfNotNull { root, _, cb ->
-        cb.or(
-            cb.equal(
-                root.get<ReservationStatus>("status"),
-                ReservationStatus.CONFIRMED
-            ),
-            cb.equal(
-                root.get<ReservationStatus>("status"),
-                ReservationStatus.CONFIRMED_PAYMENT_REQUIRED
-            )
-        )
-    }
-
-    fun waiting(): ReservationSearchSpecification = andIfNotNull { root, _, cb ->
-        cb.equal(
-            root.get<ReservationStatus>("status"),
-            ReservationStatus.WAITING
-        )
-    }
-
-    fun dateStartFrom(dateFrom: LocalDate?): ReservationSearchSpecification = andIfNotNull(dateFrom?.let {
-        Specification { root, _, cb ->
-            cb.greaterThanOrEqualTo(root.get("date"), dateFrom)
-        }
-    })
-
-    fun dateEndAt(dateTo: LocalDate?): ReservationSearchSpecification = andIfNotNull(dateTo?.let {
-        Specification { root, _, cb ->
-            cb.lessThanOrEqualTo(root.get("date"), dateTo)
-        }
-    })
-
-    fun build(): Specification<ReservationEntity> {
-        return this.spec
-    }
-
-    private fun andIfNotNull(condition: Specification<ReservationEntity>?): ReservationSearchSpecification {
-        condition?.let { this.spec = this.spec.and(condition) }
-        return this
-    }
-}
diff --git a/src/main/kotlin/roomescape/reservation/web/MyReservationController.kt b/src/main/kotlin/roomescape/reservation/web/MyReservationController.kt
deleted file mode 100644
index b0feffd7..00000000
--- a/src/main/kotlin/roomescape/reservation/web/MyReservationController.kt
+++ /dev/null
@@ -1,35 +0,0 @@
-package roomescape.reservation.web
-
-import io.swagger.v3.oas.annotations.Parameter
-import org.springframework.http.ResponseEntity
-import org.springframework.web.bind.annotation.GetMapping
-import org.springframework.web.bind.annotation.PathVariable
-import org.springframework.web.bind.annotation.RestController
-import roomescape.auth.web.support.MemberId
-import roomescape.common.dto.response.CommonApiResponse
-import roomescape.reservation.business.MyReservationFindService
-import roomescape.reservation.docs.MyReservationAPI
-
-@RestController
-class MyReservationController(
-    private val reservationFindService: MyReservationFindService
-) : MyReservationAPI {
-
-    @GetMapping("/v2/reservations")
-    override fun findAllMyReservations(
-        @MemberId @Parameter(hidden=true) memberId: Long
-    ): ResponseEntity<CommonApiResponse<ReservationSummaryRetrieveListResponse>> {
-        val response = reservationFindService.findReservationsByMemberId(memberId)
-
-        return ResponseEntity.ok(CommonApiResponse(response))
-    }
-
-    @GetMapping("/v2/reservations/{id}/details")
-    override fun showReservationDetails(
-        @PathVariable("id") reservationId: Long
-    ): ResponseEntity<CommonApiResponse<ReservationDetailRetrieveResponse>> {
-        val response = reservationFindService.showReservationDetails(reservationId)
-
-        return ResponseEntity.ok(CommonApiResponse(response))
-    }
-}
diff --git a/src/main/kotlin/roomescape/reservation/web/MyReservationResponse.kt b/src/main/kotlin/roomescape/reservation/web/MyReservationResponse.kt
deleted file mode 100644
index 27668c15..00000000
--- a/src/main/kotlin/roomescape/reservation/web/MyReservationResponse.kt
+++ /dev/null
@@ -1,196 +0,0 @@
-package roomescape.reservation.web
-
-import roomescape.member.infrastructure.persistence.MemberEntity
-import roomescape.payment.exception.PaymentErrorCode
-import roomescape.payment.exception.PaymentException
-import roomescape.payment.infrastructure.common.PaymentStatus
-import roomescape.payment.infrastructure.persistence.v2.CanceledPaymentEntityV2
-import roomescape.payment.infrastructure.persistence.v2.PaymentBankTransferDetailEntity
-import roomescape.payment.infrastructure.persistence.v2.PaymentCardDetailEntity
-import roomescape.payment.infrastructure.persistence.v2.PaymentDetailEntity
-import roomescape.payment.infrastructure.persistence.v2.PaymentEasypayPrepaidDetailEntity
-import roomescape.payment.infrastructure.persistence.v2.PaymentEntityV2
-import roomescape.reservation.infrastructure.persistence.ReservationEntity
-import roomescape.reservation.infrastructure.persistence.ReservationStatus
-import roomescape.reservation.web.PaymentDetailResponse.BankTransferDetailResponse
-import roomescape.reservation.web.PaymentDetailResponse.CardDetailResponse
-import roomescape.reservation.web.PaymentDetailResponse.EasyPayPrepaidDetailResponse
-import java.time.LocalDate
-import java.time.LocalDateTime
-import java.time.LocalTime
-import java.time.OffsetDateTime
-import kotlin.Int
-
-data class ReservationSummaryRetrieveResponse(
-    val id: Long,
-    val themeName: String,
-    val date: LocalDate,
-    val startAt: LocalTime,
-    val status: ReservationStatus
-)
-
-fun ReservationEntity.toReservationSummaryRetrieveResponse(): ReservationSummaryRetrieveResponse {
-    return ReservationSummaryRetrieveResponse(
-        id = this.id!!,
-        themeName = this.theme.name,
-        date = this.date,
-        startAt = this.time.startAt,
-        status = this.status
-    )
-}
-
-data class ReservationSummaryRetrieveListResponse(
-    val reservations: List<ReservationSummaryRetrieveResponse>
-)
-
-fun List<ReservationEntity>.toSummaryListResponse(): ReservationSummaryRetrieveListResponse {
-    return ReservationSummaryRetrieveListResponse(
-        reservations = this.map { it.toReservationSummaryRetrieveResponse() }
-    )
-}
-
-data class ReservationDetailRetrieveResponse(
-    val id: Long,
-    val user: UserDetailRetrieveResponse,
-    val themeName: String,
-    val date: LocalDate,
-    val startAt: LocalTime,
-    val applicationDateTime: LocalDateTime,
-    val payment: PaymentRetrieveResponse,
-    val cancellation: PaymentCancelDetailResponse? = null
-)
-
-data class UserDetailRetrieveResponse(
-    val id: Long,
-    val name: String,
-    val email: String
-)
-
-fun MemberEntity.toUserDetailRetrieveResponse(): UserDetailRetrieveResponse {
-    return UserDetailRetrieveResponse(
-        id = this.id!!,
-        name = this.name,
-        email = this.email
-    )
-}
-
-fun ReservationEntity.toReservationDetailRetrieveResponse(
-    payment: PaymentRetrieveResponse,
-    cancellation: PaymentCancelDetailResponse? = null
-): ReservationDetailRetrieveResponse {
-    return ReservationDetailRetrieveResponse(
-        id = this.id!!,
-        user = this.member.toUserDetailRetrieveResponse(),
-        themeName = this.theme.name,
-        date = this.date,
-        startAt = this.time.startAt,
-        applicationDateTime = this.createdAt!!,
-        payment = payment,
-        cancellation = cancellation,
-    )
-}
-
-data class PaymentRetrieveResponse(
-    val orderId: String,
-    val totalAmount: Int,
-    val method: String,
-    val status: PaymentStatus,
-    val requestedAt: OffsetDateTime,
-    val approvedAt: OffsetDateTime,
-    val detail: PaymentDetailResponse,
-)
-
-fun PaymentEntityV2.toRetrieveResponse(detail: PaymentDetailResponse): PaymentRetrieveResponse {
-    return PaymentRetrieveResponse(
-        orderId = this.orderId,
-        totalAmount = this.totalAmount,
-        method = this.method.koreanName,
-        status = this.status,
-        requestedAt = this.requestedAt,
-        approvedAt = this.approvedAt,
-        detail = detail
-    )
-}
-
-sealed class PaymentDetailResponse {
-
-    data class CardDetailResponse(
-        val type: String = "CARD",
-        val issuerCode: String,
-        val cardType: String,
-        val ownerType: String,
-        val cardNumber: String,
-        val amount: Int,
-        val approvalNumber: String,
-        val installmentPlanMonths: Int,
-        val easypayProviderName: String?,
-        val easypayDiscountAmount: Int?,
-    ) : PaymentDetailResponse()
-
-
-    data class BankTransferDetailResponse(
-        val type: String = "BANK_TRANSFER",
-        val bankName: String,
-    ) : PaymentDetailResponse()
-
-
-    data class EasyPayPrepaidDetailResponse(
-        val type: String = "EASYPAY_PREPAID",
-        val providerName: String,
-        val amount: Int,
-        val discountAmount: Int,
-    ) : PaymentDetailResponse()
-}
-
-fun PaymentDetailEntity.toPaymentDetailResponse(): PaymentDetailResponse {
-    return when (this) {
-        is PaymentCardDetailEntity -> this.toCardDetailResponse()
-        is PaymentBankTransferDetailEntity -> this.toBankTransferDetailResponse()
-        is PaymentEasypayPrepaidDetailEntity -> this.toEasyPayPrepaidDetailResponse()
-        else -> throw PaymentException(PaymentErrorCode.NOT_SUPPORTED_PAYMENT_TYPE)
-    }
-}
-
-fun PaymentCardDetailEntity.toCardDetailResponse(): CardDetailResponse {
-    return CardDetailResponse(
-        issuerCode = this.issuerCode.koreanName,
-        cardType = this.cardType.koreanName,
-        ownerType = this.ownerType.koreanName,
-        cardNumber = this.cardNumber,
-        amount = this.amount,
-        approvalNumber = this.approvalNumber,
-        installmentPlanMonths = this.installmentPlanMonths,
-        easypayProviderName = this.easypayProviderCode?.koreanName,
-        easypayDiscountAmount = this.easypayDiscountAmount
-    )
-}
-
-fun PaymentBankTransferDetailEntity.toBankTransferDetailResponse(): BankTransferDetailResponse {
-    return BankTransferDetailResponse(
-        bankName = this.bankCode.koreanName
-    )
-}
-
-fun PaymentEasypayPrepaidDetailEntity.toEasyPayPrepaidDetailResponse(): EasyPayPrepaidDetailResponse {
-    return EasyPayPrepaidDetailResponse(
-        providerName = this.easypayProviderCode.koreanName,
-        amount = this.amount,
-        discountAmount = this.discountAmount
-    )
-}
-
-data class PaymentCancelDetailResponse(
-    val cancellationRequestedAt: LocalDateTime,
-    val cancellationApprovedAt: OffsetDateTime?,
-    val cancelReason: String,
-    val canceledBy: Long,
-)
-
-fun CanceledPaymentEntityV2.toCancelDetailResponse(): PaymentCancelDetailResponse {
-    return PaymentCancelDetailResponse(
-        cancellationRequestedAt = this.requestedAt,
-        cancellationApprovedAt = this.canceledAt,
-        cancelReason = this.cancelReason,
-        canceledBy = this.canceledBy
-    )
-}
diff --git a/src/main/kotlin/roomescape/reservation/web/ReservationController.kt b/src/main/kotlin/roomescape/reservation/web/ReservationController.kt
index 431a57be..b5e60372 100644
--- a/src/main/kotlin/roomescape/reservation/web/ReservationController.kt
+++ b/src/main/kotlin/roomescape/reservation/web/ReservationController.kt
@@ -6,170 +6,59 @@ import org.springframework.http.ResponseEntity
 import org.springframework.web.bind.annotation.*
 import roomescape.auth.web.support.MemberId
 import roomescape.common.dto.response.CommonApiResponse
-import roomescape.payment.infrastructure.client.PaymentApproveRequest
-import roomescape.payment.infrastructure.client.PaymentApproveResponse
-import roomescape.payment.infrastructure.client.TossPaymentClient
-import roomescape.payment.web.PaymentCancelRequest
-import roomescape.reservation.business.ReservationWriteService
-import roomescape.reservation.business.ReservationFindService
-import roomescape.reservation.business.ReservationWithPaymentService
+import roomescape.reservation.business.ReservationService
 import roomescape.reservation.docs.ReservationAPI
-import java.net.URI
-import java.time.LocalDate
 
 @RestController
 class ReservationController(
-    private val reservationWithPaymentService: ReservationWithPaymentService,
-    private val reservationFindService: ReservationFindService,
-    private val reservationWriteService: ReservationWriteService,
-    private val paymentClient: TossPaymentClient
+    private val reservationService: ReservationService
 ) : ReservationAPI {
-    @GetMapping("/reservations")
-    override fun findReservations(): ResponseEntity<CommonApiResponse<ReservationRetrieveListResponse>> {
-        val response: ReservationRetrieveListResponse = reservationFindService.findReservations()
+
+    @PostMapping("/reservations/pending")
+    override fun createPendingReservation(
+        @MemberId @Parameter(hidden = true) memberId: Long,
+        @Valid @RequestBody request: PendingReservationCreateRequest
+    ): ResponseEntity<CommonApiResponse<PendingReservationCreateResponse>> {
+        val response = reservationService.createPendingReservation(memberId, request)
 
         return ResponseEntity.ok(CommonApiResponse(response))
     }
 
-    @GetMapping("/reservations-mine")
-    override fun findReservationsByMemberId(
+    @PostMapping("/reservations/{id}/confirm")
+    override fun confirmReservation(
+        @PathVariable("id") id: Long
+    ): ResponseEntity<CommonApiResponse<Unit>> {
+        reservationService.confirmReservation(id)
+
+        return ResponseEntity.ok().body(CommonApiResponse())
+    }
+
+    @PostMapping("/reservations/{reservationId}/cancel")
+    override fun cancelReservation(
+        @MemberId @Parameter(hidden = true) memberId: Long,
+        @PathVariable reservationId: Long,
+        @Valid @RequestBody request: ReservationCancelRequest
+    ): ResponseEntity<CommonApiResponse<Unit>> {
+        reservationService.cancelReservation(memberId, reservationId, request)
+
+        return ResponseEntity.ok().body(CommonApiResponse())
+    }
+
+    @GetMapping("/reservations/summary")
+    override fun findSummaryByMemberId(
         @MemberId @Parameter(hidden = true) memberId: Long
-    ): ResponseEntity<CommonApiResponse<MyReservationRetrieveListResponse>> {
-        val response: MyReservationRetrieveListResponse = reservationFindService.findReservationsByMemberId(memberId)
+    ): ResponseEntity<CommonApiResponse<ReservationSummaryRetrieveListResponse>> {
+        val response = reservationService.findSummaryByMemberId(memberId)
 
         return ResponseEntity.ok(CommonApiResponse(response))
     }
 
-    @GetMapping("/reservations/search")
-    override fun searchReservations(
-        @RequestParam(required = false) themeId: Long?,
-        @RequestParam(required = false) memberId: Long?,
-        @RequestParam(required = false) dateFrom: LocalDate?,
-        @RequestParam(required = false) dateTo: LocalDate?
-    ): ResponseEntity<CommonApiResponse<ReservationRetrieveListResponse>> {
-        val response: ReservationRetrieveListResponse = reservationFindService.searchReservations(
-            themeId,
-            memberId,
-            dateFrom,
-            dateTo
-        )
+    @GetMapping("/reservations/{id}/detail")
+    override fun findDetailById(
+        @PathVariable("id") id: Long
+    ): ResponseEntity<CommonApiResponse<ReservationDetailRetrieveResponse>> {
+        val response = reservationService.findDetailById(id)
 
         return ResponseEntity.ok(CommonApiResponse(response))
     }
-
-    @DeleteMapping("/reservations/{id}")
-    override fun cancelReservationByAdmin(
-        @MemberId @Parameter(hidden = true) memberId: Long,
-        @PathVariable("id") reservationId: Long
-    ): ResponseEntity<CommonApiResponse<Unit>> {
-        if (reservationWithPaymentService.isNotPaidReservation(reservationId)) {
-            reservationWriteService.deleteReservation(reservationId, memberId)
-            return ResponseEntity.noContent().build()
-        }
-
-        val paymentCancelRequest = reservationWithPaymentService.deleteReservationAndPayment(reservationId, memberId)
-        val paymentCancelResponse = paymentClient.cancel(paymentCancelRequest)
-        reservationWithPaymentService.updateCanceledTime(
-            paymentCancelRequest.paymentKey,
-            paymentCancelResponse.canceledAt
-        )
-
-        return ResponseEntity.noContent().build()
-    }
-
-    @PostMapping("/reservations")
-    override fun createReservationWithPayment(
-        @Valid @RequestBody reservationCreateWithPaymentRequest: ReservationCreateWithPaymentRequest,
-        @MemberId @Parameter(hidden = true) memberId: Long
-    ): ResponseEntity<CommonApiResponse<ReservationCreateResponse>> {
-        val paymentRequest: PaymentApproveRequest = reservationCreateWithPaymentRequest.toPaymentApproveRequest()
-        val paymentResponse: PaymentApproveResponse = paymentClient.confirm(paymentRequest)
-
-        try {
-            val response: ReservationCreateResponse =
-                reservationWithPaymentService.createReservationAndPayment(
-                    reservationCreateWithPaymentRequest,
-                    paymentResponse,
-                    memberId
-                )
-            return ResponseEntity.created(URI.create("/reservations/${response.id}"))
-                .body(CommonApiResponse(response))
-        } catch (e: Exception) {
-            val cancelRequest = PaymentCancelRequest(
-                paymentRequest.paymentKey,
-                paymentRequest.amount,
-                e.message!!
-            )
-            val paymentCancelResponse = paymentClient.cancel(cancelRequest)
-            reservationWithPaymentService.createCanceledPayment(
-                paymentCancelResponse,
-                paymentResponse.approvedAt,
-                paymentRequest.paymentKey
-            )
-            throw e
-        }
-    }
-
-    @PostMapping("/reservations/admin")
-    override fun createReservationByAdmin(
-        @Valid @RequestBody adminReservationRequest: AdminReservationCreateRequest,
-        @MemberId @Parameter(hidden = true) memberId: Long,
-    ): ResponseEntity<CommonApiResponse<ReservationCreateResponse>> {
-        val response: ReservationCreateResponse =
-            reservationWriteService.createReservationByAdmin(adminReservationRequest, memberId)
-
-        return ResponseEntity.created(URI.create("/reservations/${response.id}"))
-            .body(CommonApiResponse(response))
-    }
-
-    @GetMapping("/reservations/waiting")
-    override fun findAllWaiting(): ResponseEntity<CommonApiResponse<ReservationRetrieveListResponse>> {
-        val response: ReservationRetrieveListResponse = reservationFindService.findAllWaiting()
-
-        return ResponseEntity.ok(CommonApiResponse(response))
-    }
-
-    @PostMapping("/reservations/waiting")
-    override fun createWaiting(
-        @Valid @RequestBody waitingCreateRequest: WaitingCreateRequest,
-        @MemberId @Parameter(hidden = true) memberId: Long,
-    ): ResponseEntity<CommonApiResponse<ReservationCreateResponse>> {
-        val response: ReservationCreateResponse = reservationWriteService.createWaiting(
-            waitingCreateRequest,
-            memberId
-        )
-
-        return ResponseEntity.created(URI.create("/reservations/${response.id}"))
-            .body(CommonApiResponse(response))
-    }
-
-    @DeleteMapping("/reservations/waiting/{id}")
-    override fun cancelWaitingByMember(
-        @MemberId @Parameter(hidden = true) memberId: Long,
-        @PathVariable("id") reservationId: Long
-    ): ResponseEntity<CommonApiResponse<Unit>> {
-        reservationWriteService.deleteWaiting(reservationId, memberId)
-
-        return ResponseEntity.noContent().build()
-    }
-
-    @PostMapping("/reservations/waiting/{id}/confirm")
-    override fun confirmWaiting(
-        @MemberId @Parameter(hidden = true) memberId: Long,
-        @PathVariable("id") reservationId: Long
-    ): ResponseEntity<CommonApiResponse<Unit>> {
-        reservationWriteService.confirmWaiting(reservationId, memberId)
-
-        return ResponseEntity.ok().build()
-    }
-
-    @PostMapping("/reservations/waiting/{id}/reject")
-    override fun rejectWaiting(
-        @MemberId @Parameter(hidden = true) memberId: Long,
-        @PathVariable("id") reservationId: Long
-    ): ResponseEntity<CommonApiResponse<Unit>> {
-        reservationWriteService.deleteWaiting(reservationId, memberId)
-
-        return ResponseEntity.noContent().build()
-    }
 }
diff --git a/src/main/kotlin/roomescape/reservation/web/ReservationDto.kt b/src/main/kotlin/roomescape/reservation/web/ReservationDto.kt
new file mode 100644
index 00000000..43352f3e
--- /dev/null
+++ b/src/main/kotlin/roomescape/reservation/web/ReservationDto.kt
@@ -0,0 +1,70 @@
+package roomescape.reservation.web
+
+import jakarta.validation.constraints.NotEmpty
+import roomescape.member.web.MemberSummaryRetrieveResponse
+import roomescape.payment.web.PaymentRetrieveResponse
+import roomescape.reservation.infrastructure.persistence.ReservationEntity
+import roomescape.reservation.infrastructure.persistence.ReservationStatus
+import java.time.LocalDate
+import java.time.LocalDateTime
+import java.time.LocalTime
+
+data class PendingReservationCreateRequest(
+    val scheduleId: Long,
+    @NotEmpty
+    val reserverName: String,
+    @NotEmpty
+    val reserverContact: String,
+    val participantCount: Short,
+    val requirement: String
+)
+
+fun PendingReservationCreateRequest.toEntity(id: Long, memberId: Long) = ReservationEntity(
+    id = id,
+    memberId = memberId,
+    scheduleId = this.scheduleId,
+    reserverName = this.reserverName,
+    reserverContact = this.reserverContact,
+    participantCount = this.participantCount,
+    requirement = this.requirement,
+    status = ReservationStatus.PENDING
+)
+
+data class PendingReservationCreateResponse(
+    val id: Long
+)
+
+data class ReservationSummaryRetrieveResponse(
+    val id: Long,
+    val themeName: String,
+    val date: LocalDate,
+    val startAt: LocalTime,
+    val status: ReservationStatus
+)
+
+data class ReservationSummaryRetrieveListResponse(
+    val reservations: List<ReservationSummaryRetrieveResponse>
+)
+
+data class ReservationDetailRetrieveResponse(
+    val id: Long,
+    val member: MemberSummaryRetrieveResponse,
+    val applicationDateTime: LocalDateTime,
+    val payment: PaymentRetrieveResponse,
+)
+
+fun ReservationEntity.toReservationDetailRetrieveResponse(
+    member: MemberSummaryRetrieveResponse,
+    payment: PaymentRetrieveResponse,
+): ReservationDetailRetrieveResponse {
+    return ReservationDetailRetrieveResponse(
+        id = this.id,
+        member = member,
+        applicationDateTime = this.createdAt,
+        payment = payment,
+    )
+}
+
+data class ReservationCancelRequest(
+    val cancelReason: String
+)
\ No newline at end of file
diff --git a/src/main/kotlin/roomescape/reservation/web/ReservationRequest.kt b/src/main/kotlin/roomescape/reservation/web/ReservationRequest.kt
deleted file mode 100644
index c7bad04d..00000000
--- a/src/main/kotlin/roomescape/reservation/web/ReservationRequest.kt
+++ /dev/null
@@ -1,40 +0,0 @@
-package roomescape.reservation.web
-
-import io.swagger.v3.oas.annotations.media.Schema
-import roomescape.payment.infrastructure.client.PaymentApproveRequest
-import java.time.LocalDate
-
-data class AdminReservationCreateRequest(
-    val date: LocalDate,
-    val timeId: Long,
-    val themeId: Long,
-    val memberId: Long
-)
-
-data class ReservationCreateWithPaymentRequest(
-    val date: LocalDate,
-    val timeId: Long,
-    val themeId: Long,
-
-    @Schema(description = "결제 위젯을 통해 받은 결제 키")
-    val paymentKey: String,
-
-    @Schema(description = "결제 위젯을 통해 받은 주문번호.")
-    val orderId: String,
-
-    @Schema(description = "결제 위젯을 통해 받은 결제 금액")
-    val amount: Long,
-
-    @Schema(description = "결제 타입", example = "NORMAL")
-    val paymentType: String
-)
-
-fun ReservationCreateWithPaymentRequest.toPaymentApproveRequest(): PaymentApproveRequest = PaymentApproveRequest(
-    paymentKey, orderId, amount, paymentType
-)
-
-data class WaitingCreateRequest(
-    val date: LocalDate,
-    val timeId: Long,
-    val themeId: Long
-)
diff --git a/src/main/kotlin/roomescape/reservation/web/ReservationResponse.kt b/src/main/kotlin/roomescape/reservation/web/ReservationResponse.kt
deleted file mode 100644
index 2318c9c6..00000000
--- a/src/main/kotlin/roomescape/reservation/web/ReservationResponse.kt
+++ /dev/null
@@ -1,93 +0,0 @@
-package roomescape.reservation.web
-
-import com.fasterxml.jackson.annotation.JsonProperty
-import io.swagger.v3.oas.annotations.media.Schema
-import roomescape.member.web.MemberRetrieveResponse
-import roomescape.member.web.toRetrieveResponse
-import roomescape.reservation.infrastructure.persistence.ReservationEntity
-import roomescape.reservation.infrastructure.persistence.ReservationStatus
-import roomescape.theme.web.ThemeRetrieveResponse
-import roomescape.theme.web.toRetrieveResponse
-import roomescape.time.web.TimeCreateResponse
-import roomescape.time.web.toCreateResponse
-import java.time.LocalDate
-import java.time.LocalTime
-
-data class ReservationCreateResponse(
-    val id: Long,
-    val date: LocalDate,
-
-    @JsonProperty("member")
-    val member: MemberRetrieveResponse,
-
-    @JsonProperty("time")
-    val time: TimeCreateResponse,
-
-    @JsonProperty("theme")
-    val theme: ThemeRetrieveResponse,
-
-    val status: ReservationStatus
-)
-
-fun ReservationEntity.toCreateResponse() = ReservationCreateResponse(
-    id = this.id!!,
-    date = this.date,
-    member = this.member.toRetrieveResponse(),
-    time = this.time.toCreateResponse(),
-    theme = this.theme.toRetrieveResponse(),
-    status = this.status
-)
-
-data class MyReservationRetrieveResponse(
-    val id: Long,
-    val themeName: String,
-    val date: LocalDate,
-    val time: LocalTime,
-    val status: ReservationStatus,
-    @Schema(description = "대기 순번. 확정된 예약은 0의 값을 가집니다.")
-    val rank: Long,
-    @Schema(description = "결제 키. 결제가 완료된 예약에만 값이 존재합니다.")
-    val paymentKey: String?,
-    @Schema(description = "결제 금액. 결제가 완료된 예약에만 값이 존재합니다.")
-    val amount: Long?
-)
-
-data class MyReservationRetrieveListResponse(
-    @Schema(description = "현재 로그인한 회원의 예약 및 대기 목록")
-    val reservations: List<MyReservationRetrieveResponse>
-)
-
-fun List<MyReservationRetrieveResponse>.toRetrieveListResponse() = MyReservationRetrieveListResponse(this)
-
-data class ReservationRetrieveResponse(
-    val id: Long,
-    val date: LocalDate,
-
-    @JsonProperty("member")
-    val member: MemberRetrieveResponse,
-
-    @JsonProperty("time")
-    val time: TimeCreateResponse,
-
-    @JsonProperty("theme")
-    val theme: ThemeRetrieveResponse,
-
-    val status: ReservationStatus
-)
-
-fun ReservationEntity.toRetrieveResponse(): ReservationRetrieveResponse = ReservationRetrieveResponse(
-    id = this.id!!,
-    date = this.date,
-    member = this.member.toRetrieveResponse(),
-    time = this.time.toCreateResponse(),
-    theme = this.theme.toRetrieveResponse(),
-    status = this.status
-)
-
-data class ReservationRetrieveListResponse(
-    val reservations: List<ReservationRetrieveResponse>
-)
-
-fun List<ReservationEntity>.toRetrieveListResponse()= ReservationRetrieveListResponse(
-    this.map { it.toRetrieveResponse() }
-)
diff --git a/src/main/kotlin/roomescape/reservation/web/ReservationWithPaymentController.kt b/src/main/kotlin/roomescape/reservation/web/ReservationWithPaymentController.kt
deleted file mode 100644
index 590e71e7..00000000
--- a/src/main/kotlin/roomescape/reservation/web/ReservationWithPaymentController.kt
+++ /dev/null
@@ -1,60 +0,0 @@
-package roomescape.reservation.web
-
-import io.swagger.v3.oas.annotations.Parameter
-import jakarta.validation.Valid
-import org.springframework.http.ResponseEntity
-import org.springframework.web.bind.annotation.PatchMapping
-import org.springframework.web.bind.annotation.PathVariable
-import org.springframework.web.bind.annotation.PostMapping
-import org.springframework.web.bind.annotation.RequestBody
-import org.springframework.web.bind.annotation.RestController
-import roomescape.auth.web.support.MemberId
-import roomescape.common.dto.response.CommonApiResponse
-import roomescape.reservation.business.ReservationWithPaymentService
-import roomescape.reservation.business.ReservationWithPaymentServiceV2
-import roomescape.reservation.docs.ReservationWithPaymentAPI
-
-@RestController
-class ReservationWithPaymentController(
-    private val reservationWithPaymentService: ReservationWithPaymentServiceV2
-) : ReservationWithPaymentAPI {
-
-    @PostMapping("/v2/reservations")
-    override fun createPendingReservation(
-        @MemberId @Parameter(hidden = true) memberId: Long,
-        @Valid @RequestBody reservationCreateWithPaymentRequest: ReservationCreateRequest
-    ): ResponseEntity<CommonApiResponse<ReservationCreateResponseV2>> {
-        val response = reservationWithPaymentService.createPendingReservation(
-            memberId = memberId,
-            request = reservationCreateWithPaymentRequest
-        )
-
-        return ResponseEntity.ok(CommonApiResponse(response))
-    }
-
-    @PostMapping("/v2/reservations/{id}/pay")
-    override fun createPaymentAndConfirmReservation(
-        @MemberId @Parameter(hidden = true) memberId: Long,
-        @PathVariable("id") reservationId: Long,
-        @Valid @RequestBody request: ReservationPaymentRequest, 
-    ): ResponseEntity<CommonApiResponse<ReservationPaymentResponse>> {
-        val response = reservationWithPaymentService.payReservation(
-            memberId = memberId,
-            reservationId = reservationId,
-            request = request
-        )
-
-        return ResponseEntity.ok(CommonApiResponse(response))
-    }
-
-    @PostMapping("/v2/reservations/{id}/cancel")
-    override fun cancelReservation(
-        @MemberId @Parameter(hidden = true) memberId: Long,
-        @PathVariable("id") reservationId: Long,
-        @Valid @RequestBody cancelRequest: ReservationCancelRequest
-    ): ResponseEntity<CommonApiResponse<Unit>> {
-        reservationWithPaymentService.cancelReservation(memberId, reservationId, cancelRequest)
-
-        return ResponseEntity.noContent().build()
-    }
-}
diff --git a/src/main/kotlin/roomescape/reservation/web/ReservationWithPaymentDTO.kt b/src/main/kotlin/roomescape/reservation/web/ReservationWithPaymentDTO.kt
deleted file mode 100644
index 07b2a444..00000000
--- a/src/main/kotlin/roomescape/reservation/web/ReservationWithPaymentDTO.kt
+++ /dev/null
@@ -1,57 +0,0 @@
-package roomescape.reservation.web
-
-import roomescape.payment.infrastructure.client.v2.PaymentConfirmRequest
-import roomescape.payment.infrastructure.common.PaymentStatus
-import roomescape.payment.infrastructure.common.PaymentType
-import roomescape.reservation.infrastructure.persistence.ReservationEntity
-import roomescape.reservation.infrastructure.persistence.ReservationStatus
-import java.time.LocalDate
-import java.time.LocalDateTime
-import java.time.LocalTime
-
-data class ReservationCreateRequest(
-    val date: LocalDate,
-    val timeId: Long,
-    val themeId: Long,
-)
-
-data class ReservationCreateResponseV2(
-    val reservationId: Long,
-    val memberEmail: String,
-    val date: LocalDate,
-    val startAt: LocalTime,
-    val themeName: String
-)
-
-fun ReservationEntity.toCreateResponseV2() = ReservationCreateResponseV2(
-    reservationId = this.id!!,
-    memberEmail = this.member.email,
-    date = this.date,
-    startAt = this.time.startAt,
-    themeName = this.theme.name
-)
-
-data class ReservationPaymentRequest(
-    val paymentKey: String,
-    val orderId: String,
-    val amount: Int,
-    val paymentType: PaymentType
-)
-
-fun ReservationPaymentRequest.toPaymentConfirmRequest() = PaymentConfirmRequest(
-    paymentKey = this.paymentKey,
-    amount = this.amount,
-    orderId = this.orderId,
-)
-
-data class ReservationPaymentResponse(
-    val reservationId: Long,
-    val reservationStatus: ReservationStatus,
-    val paymentId: Long,
-    val paymentStatus: PaymentStatus,
-)
-
-data class ReservationCancelRequest(
-    val cancelReason: String,
-    val requestedAt: LocalDateTime = LocalDateTime.now()
-)
diff --git a/src/main/kotlin/roomescape/schedule/business/ScheduleService.kt b/src/main/kotlin/roomescape/schedule/business/ScheduleService.kt
index dd989d70..2d8ce9e3 100644
--- a/src/main/kotlin/roomescape/schedule/business/ScheduleService.kt
+++ b/src/main/kotlin/roomescape/schedule/business/ScheduleService.kt
@@ -30,8 +30,7 @@ class ScheduleService(
     fun findThemesByDate(date: LocalDate): AvailableThemeIdListResponse {
         log.info { "[ScheduleService.findThemesByDate] 동일한 날짜의 모든 테마 조회: date=$date" }
 
-        return scheduleRepository.findAllByDate(date)
-            .toThemeIdListResponse()
+        return AvailableThemeIdListResponse(scheduleRepository.findAllUniqueThemeIdByDate(date))
             .also {
                 log.info { "[ScheduleService.findThemesByDate] date=${date} 인 ${it.themeIds.size}개 테마 조회 완료" }
             }
@@ -54,8 +53,8 @@ class ScheduleService(
 
         val schedule: ScheduleEntity = findOrThrow(id)
 
-        val createdBy = memberService.findById(schedule.createdBy).name
-        val updatedBy = memberService.findById(schedule.updatedBy).name
+        val createdBy = memberService.findSummaryById(schedule.createdBy).name
+        val updatedBy = memberService.findSummaryById(schedule.updatedBy).name
 
         return schedule.toDetailRetrieveResponse(createdBy, updatedBy)
             .also {
@@ -63,6 +62,16 @@ class ScheduleService(
             }
     }
 
+    @Transactional(readOnly = true)
+    fun findSummaryById(id: Long): ScheduleSummaryResponse {
+        log.info { "[ScheduleService.findDateTimeById] 일정 개요 조회 시작 : id=$id" }
+
+        return findOrThrow(id).toSummaryResponse()
+            .also {
+                log.info { "[ScheduleService.findDateTimeById] 일정 개요 조회 완료: id=$id" }
+            }
+    }
+
     @Transactional
     fun createSchedule(request: ScheduleCreateRequest): ScheduleCreateResponse {
         log.info { "[ScheduleService.createSchedule] 일정 생성 시작: date=${request.date}, time=${request.time}, themeId=${request.themeId}" }
@@ -83,6 +92,18 @@ class ScheduleService(
             }
     }
 
+    @Transactional
+    fun holdSchedule(id: Long) {
+        val schedule: ScheduleEntity = findOrThrow(id)
+
+        if (schedule.status == ScheduleStatus.AVAILABLE) {
+            schedule.hold()
+            return
+        }
+
+        throw ScheduleException(ScheduleErrorCode.SCHEDULE_NOT_AVAILABLE)
+    }
+
     @Transactional
     fun updateSchedule(id: Long, request: ScheduleUpdateRequest) {
         log.info { "[ScheduleService.updateSchedule] 일정 수정 시작: id=$id, request=${request}" }
diff --git a/src/main/kotlin/roomescape/schedule/business/ScheduleValidator.kt b/src/main/kotlin/roomescape/schedule/business/ScheduleValidator.kt
index 34c427ad..4baf7790 100644
--- a/src/main/kotlin/roomescape/schedule/business/ScheduleValidator.kt
+++ b/src/main/kotlin/roomescape/schedule/business/ScheduleValidator.kt
@@ -23,7 +23,7 @@ class ScheduleValidator(
     fun validateCanDelete(schedule: ScheduleEntity) {
         val status: ScheduleStatus = schedule.status
 
-        if (status !in listOf(ScheduleStatus.AVAILABLE,ScheduleStatus.BLOCKED)) {
+        if (status !in listOf(ScheduleStatus.AVAILABLE, ScheduleStatus.BLOCKED)) {
             log.info { "[ScheduleValidator.validateCanDelete] 삭제 실패: id=${schedule.id} / status=${status}" }
             throw ScheduleException(ScheduleErrorCode.SCHEDULE_IN_USE)
         }
diff --git a/src/main/kotlin/roomescape/schedule/docs/ScheduleAPI.kt b/src/main/kotlin/roomescape/schedule/docs/ScheduleAPI.kt
index 579c02a5..95e2cc2d 100644
--- a/src/main/kotlin/roomescape/schedule/docs/ScheduleAPI.kt
+++ b/src/main/kotlin/roomescape/schedule/docs/ScheduleAPI.kt
@@ -38,6 +38,19 @@ interface ScheduleAPI {
         @RequestParam("themeId") themeId: Long
     ): ResponseEntity<CommonApiResponse<ScheduleRetrieveListResponse>>
 
+    @LoginRequired
+    @Operation(summary = "일정을 Hold 상태로 변경", tags = ["로그인이 필요한 API"])
+    @ApiResponses(
+        ApiResponse(
+            responseCode = "200",
+            description = "일정을 Hold 상태로 변경하여 중복 예약 방지",
+            useReturnTypeSchema = true
+        )
+    )
+    fun holdSchedule(
+        @PathVariable("id") id: Long
+    ): ResponseEntity<CommonApiResponse<Unit>>
+
     @Admin
     @Operation(summary = "일정 상세 조회", tags = ["관리자 로그인이 필요한 API"])
     @ApiResponses(ApiResponse(responseCode = "200", description = "감사 정보를 포함하여 일정 상세 조회", useReturnTypeSchema = true))
diff --git a/src/main/kotlin/roomescape/schedule/exception/ScheduleErrorCode.kt b/src/main/kotlin/roomescape/schedule/exception/ScheduleErrorCode.kt
index 4436ac96..096fce94 100644
--- a/src/main/kotlin/roomescape/schedule/exception/ScheduleErrorCode.kt
+++ b/src/main/kotlin/roomescape/schedule/exception/ScheduleErrorCode.kt
@@ -12,4 +12,5 @@ enum class ScheduleErrorCode(
     SCHEDULE_ALREADY_EXISTS(HttpStatus.CONFLICT, "S002", "이미 동일한 일정이 있어요."),
     PAST_DATE_TIME(HttpStatus.BAD_REQUEST, "S003", "과거 날짜와 시간은 선택할 수 없어요."),
     SCHEDULE_IN_USE(HttpStatus.CONFLICT, "S004", "예약이 진행중이거나 완료된 일정은 삭제할 수 없어요."),
+    SCHEDULE_NOT_AVAILABLE(HttpStatus.CONFLICT, "S005", "예약이 완료되었거나 예약할 수 없는 일정이에요.")
 }
diff --git a/src/main/kotlin/roomescape/schedule/infrastructure/persistence/ScheduleEntity.kt b/src/main/kotlin/roomescape/schedule/infrastructure/persistence/ScheduleEntity.kt
index 7da08a63..e0198b84 100644
--- a/src/main/kotlin/roomescape/schedule/infrastructure/persistence/ScheduleEntity.kt
+++ b/src/main/kotlin/roomescape/schedule/infrastructure/persistence/ScheduleEntity.kt
@@ -1,10 +1,6 @@
 package roomescape.schedule.infrastructure.persistence
 
-import jakarta.persistence.Entity
-import jakarta.persistence.EnumType
-import jakarta.persistence.Enumerated
-import jakarta.persistence.Table
-import jakarta.persistence.UniqueConstraint
+import jakarta.persistence.*
 import roomescape.common.entity.AuditingBaseEntity
 import java.time.LocalDate
 import java.time.LocalTime
@@ -29,8 +25,12 @@ class ScheduleEntity(
         time?.let { this.time = it }
         status?.let { this.status = it }
     }
+
+    fun hold() {
+        this.status = ScheduleStatus.HOLD
+    }
 }
 
 enum class ScheduleStatus {
-    AVAILABLE, PENDING, RESERVED, BLOCKED
+    AVAILABLE, HOLD, RESERVED, BLOCKED
 }
diff --git a/src/main/kotlin/roomescape/schedule/infrastructure/persistence/ScheduleRepository.kt b/src/main/kotlin/roomescape/schedule/infrastructure/persistence/ScheduleRepository.kt
index 8bae9654..98c3d960 100644
--- a/src/main/kotlin/roomescape/schedule/infrastructure/persistence/ScheduleRepository.kt
+++ b/src/main/kotlin/roomescape/schedule/infrastructure/persistence/ScheduleRepository.kt
@@ -1,6 +1,7 @@
 package roomescape.schedule.infrastructure.persistence
 
 import org.springframework.data.jpa.repository.JpaRepository
+import org.springframework.data.jpa.repository.Query
 import java.time.LocalDate
 import java.time.LocalTime
 
@@ -11,4 +12,13 @@ interface ScheduleRepository : JpaRepository<ScheduleEntity, Long> {
     fun findAllByDateAndThemeId(date: LocalDate, themeId: Long): List<ScheduleEntity>
 
     fun existsByDateAndThemeIdAndTime(date: LocalDate, themeId: Long, time: LocalTime): Boolean
+
+    @Query(
+        """
+        SELECT DISTINCT s.themeId
+        FROM ScheduleEntity s
+        WHERE s.date = :date 
+    """
+    )
+    fun findAllUniqueThemeIdByDate(date: LocalDate): List<Long>
 }
diff --git a/src/main/kotlin/roomescape/schedule/web/ScheduleController.kt b/src/main/kotlin/roomescape/schedule/web/ScheduleController.kt
index 6396fe40..e496c7db 100644
--- a/src/main/kotlin/roomescape/schedule/web/ScheduleController.kt
+++ b/src/main/kotlin/roomescape/schedule/web/ScheduleController.kt
@@ -50,6 +50,15 @@ class ScheduleController(
         return ResponseEntity.ok(CommonApiResponse(response))
     }
 
+    @PatchMapping("/schedules/{id}/hold")
+    override fun holdSchedule(
+        @PathVariable("id") id: Long
+    ): ResponseEntity<CommonApiResponse<Unit>> {
+        scheduleService.holdSchedule(id)
+
+        return ResponseEntity.ok(CommonApiResponse())
+    }
+
     @PatchMapping("/schedules/{id}")
     override fun updateSchedule(
         @PathVariable("id") id: Long,
diff --git a/src/main/kotlin/roomescape/schedule/web/ScheduleDto.kt b/src/main/kotlin/roomescape/schedule/web/ScheduleDto.kt
index c666dbe6..2812bfaf 100644
--- a/src/main/kotlin/roomescape/schedule/web/ScheduleDto.kt
+++ b/src/main/kotlin/roomescape/schedule/web/ScheduleDto.kt
@@ -10,8 +10,6 @@ data class AvailableThemeIdListResponse(
     val themeIds: List<Long>
 )
 
-fun List<ScheduleEntity>.toThemeIdListResponse() = AvailableThemeIdListResponse(this.map { it.themeId })
-
 data class ScheduleRetrieveResponse(
     val id: Long,
     val time: LocalTime,
@@ -66,3 +64,17 @@ fun ScheduleEntity.toDetailRetrieveResponse(createdBy: String, updatedBy: String
     updatedAt = this.updatedAt,
     updatedBy = updatedBy
 )
+
+data class ScheduleSummaryResponse(
+    val date: LocalDate,
+    val time: LocalTime,
+    val themeId: Long,
+    val status: ScheduleStatus
+)
+
+fun ScheduleEntity.toSummaryResponse() = ScheduleSummaryResponse(
+    date = this.date,
+    time = this.time,
+    themeId = this.themeId,
+    status = this.status
+)
diff --git a/src/main/kotlin/roomescape/theme/business/ThemeService.kt b/src/main/kotlin/roomescape/theme/business/ThemeService.kt
index 741195c3..a24be7cb 100644
--- a/src/main/kotlin/roomescape/theme/business/ThemeService.kt
+++ b/src/main/kotlin/roomescape/theme/business/ThemeService.kt
@@ -1,67 +1,150 @@
 package roomescape.theme.business
 
+import com.github.f4b6a3.tsid.TsidFactory
+import io.github.oshai.kotlinlogging.KLogger
 import io.github.oshai.kotlinlogging.KotlinLogging
+import org.springframework.data.repository.findByIdOrNull
 import org.springframework.stereotype.Service
 import org.springframework.transaction.annotation.Transactional
-import roomescape.theme.implement.ThemeFinder
-import roomescape.theme.implement.ThemeWriter
+import roomescape.common.config.next
+import roomescape.member.business.MemberService
+import roomescape.theme.exception.ThemeErrorCode
+import roomescape.theme.exception.ThemeException
 import roomescape.theme.infrastructure.persistence.ThemeEntity
+import roomescape.theme.infrastructure.persistence.ThemeRepository
 import roomescape.theme.web.*
-import java.time.LocalDate
 
-private val log = KotlinLogging.logger {}
+private val log: KLogger = KotlinLogging.logger {}
 
 @Service
 class ThemeService(
-    private val themeFinder: ThemeFinder,
-    private val themeWriter: ThemeWriter,
+    private val themeRepository: ThemeRepository,
+    private val tsidFactory: TsidFactory,
+    private val memberService: MemberService,
+    private val themeValidator: ThemeValidator
 ) {
     @Transactional(readOnly = true)
-    fun findById(id: Long): ThemeEntity {
-        log.debug { "[ThemeService.findById] 시작: themeId=$id" }
+    fun findThemesByIds(request: ThemeListRetrieveRequest): ThemeSummaryListResponse {
+        log.info { "[ThemeService.findThemesByIds] 예약 페이지에서의 테마 목록 조회 시작: themeIds=${request.themeIds}" }
+        val result: MutableList<ThemeEntity> = mutableListOf()
 
-        return themeFinder.findById(id)
-            .also { log.info { "[ThemeService.findById] 완료: themeId=$id, name=${it.name}" } }
+        for (id in request.themeIds) {
+            val theme: ThemeEntity? = themeRepository.findByIdOrNull(id)
+            if (theme == null) {
+                log.warn { "[ThemeService.findThemesByIds] id=${id} 인 테마 조회 실패" }
+                continue
+            }
+            result.add(theme)
+        }
+
+        return result.toRetrieveListResponse().also {
+            log.info { "[ThemeService.findThemesByIds] ${it.themes.size} / ${request.themeIds.size} 개 테마 조회 완료" }
+        }
     }
 
     @Transactional(readOnly = true)
-    fun findThemes(): ThemeRetrieveListResponse {
-        log.debug { "[ThemeService.findThemes] 시작" }
+    fun findThemesForReservation(): ThemeSummaryListResponse {
+        log.info { "[ThemeService.findThemesForReservation] 예약 페이지에서의 테마 목록 조회 시작" }
 
-        return themeFinder.findAll()
+        return themeRepository.findOpenedThemes()
             .toRetrieveListResponse()
-            .also { log.info { "[ThemeService.findThemes] 완료. ${it.themes.size}개 반환" } }
+            .also { log.info { "[ThemeService.findThemesForReservation] ${it.themes.size}개 테마 조회 완료" } }
     }
 
     @Transactional(readOnly = true)
-    fun findMostReservedThemes(count: Int): ThemeRetrieveListResponse {
-        log.debug { "[ThemeService.findMostReservedThemes] 시작: count=$count" }
+    fun findAdminThemes(): AdminThemeSummaryRetrieveListResponse {
+        log.info { "[ThemeService.findAdminThemes] 관리자 페이지에서의 테마 목록 조회 시작" }
 
-        val today = LocalDate.now()
-        val startFrom = today.minusDays(7)
-        val endAt = today.minusDays(1)
+        return themeRepository.findAll()
+            .toAdminThemeSummaryListResponse()
+            .also { log.info { "[ThemeService.findAdminThemes] ${it.themes.size}개 테마 조회 완료" } }
+    }
 
-        return themeFinder.findMostReservedThemes(count, startFrom, endAt)
-            .toRetrieveListResponse()
-            .also { log.info { "[ThemeService.findMostReservedThemes] ${it.themes.size}개 반환" } }
+    @Transactional(readOnly = true)
+    fun findAdminThemeDetail(id: Long): AdminThemeDetailRetrieveResponse {
+        log.info { "[ThemeService.findAdminThemeDetail] 관리자 페이지에서의 테마 상세 정보 조회 시작: id=${id}" }
+
+        val theme: ThemeEntity = findOrThrow(id)
+
+        val createdBy = memberService.findSummaryById(theme.createdBy).name
+        val updatedBy = memberService.findSummaryById(theme.updatedBy).name
+
+        return theme.toAdminThemeDetailResponse(createdBy, updatedBy)
+            .also { log.info { "[ThemeService.findAdminThemeDetail] 테마 상세 조회 완료: id=$id, name=${theme.name}" } }
+    }
+
+    @Transactional(readOnly = true)
+    fun findSummaryById(id: Long): ThemeSummaryResponse {
+        log.info { "[ThemeService.findById] 테마 조회 시작: id=$id" }
+
+        return findOrThrow(id).toSummaryResponse()
+            .also { log.info { "[ThemeService.findById] 테마 조회 완료: id=$id" } }
     }
 
     @Transactional
-    fun createTheme(request: ThemeCreateRequest): ThemeCreateResponse {
-        log.debug { "[ThemeService.createTheme] 시작: name=${request.name}" }
+    fun createTheme(request: ThemeCreateRequest): ThemeCreateResponseV2 {
+        log.info { "[ThemeService.createTheme] 테마 생성 시작: name=${request.name}" }
 
-        return themeWriter.create(request.name, request.description, request.thumbnail)
-            .toCreateResponse()
-            .also { log.info { "[ThemeService.createTheme] 테마 생성 완료: name=${it.name} themeId=${it.id}" } }
+        themeValidator.validateCanCreate(request)
+
+        val theme: ThemeEntity = themeRepository.save(
+            request.toEntity(tsidFactory.next())
+        )
+
+        return ThemeCreateResponseV2(theme.id).also {
+            log.info { "[ThemeService.createTheme] 테마 생성 완료: id=${theme.id}, name=${theme.name}" }
+        }
     }
 
     @Transactional
     fun deleteTheme(id: Long) {
-        log.debug { "[ThemeService.deleteTheme] 시작: themeId=$id" }
+        log.info { "[ThemeService.deleteTheme] 테마 삭제 시작: id=${id}" }
 
-        val theme: ThemeEntity = themeFinder.findById(id)
+        val theme: ThemeEntity = findOrThrow(id)
 
-        themeWriter.delete(theme)
-            .also { log.info { "[ThemeService.deleteTheme] 완료: themeId=$id, name=${theme.name}" } }
+        themeRepository.delete(theme).also {
+            log.info { "[ThemeService.deleteTheme] 테마 삭제 완료: id=$id, name=${theme.name}" }
+        }
+    }
+
+    @Transactional
+    fun updateTheme(id: Long, request: ThemeUpdateRequest) {
+        log.info { "[ThemeService.updateTheme] 테마 수정 시작: id=${id}, request=${request}" }
+
+        if (request.isAllParamsNull()) {
+            log.info { "[ThemeService.updateTheme] 테마 변경 사항 없음: id=${id}" }
+            return
+        }
+
+        themeValidator.validateCanUpdate(request)
+
+        val theme: ThemeEntity = findOrThrow(id)
+
+        theme.modifyIfNotNull(
+            request.name,
+            request.description,
+            request.thumbnailUrl,
+            request.difficulty,
+            request.price,
+            request.minParticipants,
+            request.maxParticipants,
+            request.availableMinutes,
+            request.expectedMinutesFrom,
+            request.expectedMinutesTo,
+            request.isOpen,
+        ).also {
+            log.info { "[ThemeService.updateTheme] 테마 수정 완료: id=$id, request=${request}" }
+        }
+    }
+
+    private fun findOrThrow(id: Long): ThemeEntity {
+        log.info { "[ThemeService.findOrThrow] 테마 조회 시작: id=$id" }
+
+        return themeRepository.findByIdOrNull(id)
+            ?.also { log.info { "[ThemeService.findOrThrow] 테마 조회 완료: id=$id" } }
+            ?: run {
+                log.warn { "[ThemeService.updateTheme] 테마 조회 실패: id=$id" }
+                throw ThemeException(ThemeErrorCode.THEME_NOT_FOUND)
+            }
     }
 }
diff --git a/src/main/kotlin/roomescape/theme/business/ThemeServiceV2.kt b/src/main/kotlin/roomescape/theme/business/ThemeServiceV2.kt
deleted file mode 100644
index bd3e9a2e..00000000
--- a/src/main/kotlin/roomescape/theme/business/ThemeServiceV2.kt
+++ /dev/null
@@ -1,133 +0,0 @@
-package roomescape.theme.business
-
-import com.github.f4b6a3.tsid.TsidFactory
-import io.github.oshai.kotlinlogging.KLogger
-import io.github.oshai.kotlinlogging.KotlinLogging
-import org.springframework.data.repository.findByIdOrNull
-import org.springframework.stereotype.Service
-import org.springframework.transaction.annotation.Transactional
-import roomescape.common.config.next
-import roomescape.member.business.MemberService
-import roomescape.theme.exception.ThemeErrorCode
-import roomescape.theme.exception.ThemeException
-import roomescape.theme.infrastructure.persistence.v2.ThemeEntityV2
-import roomescape.theme.infrastructure.persistence.v2.ThemeRepositoryV2
-import roomescape.theme.web.*
-
-private val log: KLogger = KotlinLogging.logger {}
-
-@Service
-class ThemeServiceV2(
-    private val themeRepository: ThemeRepositoryV2,
-    private val tsidFactory: TsidFactory,
-    private val memberService: MemberService,
-    private val themeValidator: ThemeValidatorV2
-) {
-    @Transactional(readOnly = true)
-    fun findThemesByIds(request: ThemeListRetrieveRequest): ThemeRetrieveListResponseV2 {
-        log.info { "[ThemeService.findThemesByIds] 예약 페이지에서의 테마 목록 조회 시작: themeIds=${request.themeIds}" }
-
-        return request.themeIds
-            .map { findOrThrow(it) }
-            .toRetrieveListResponse()
-            .also { log.info { "[ThemeService.findThemesByIds] ${it.themes.size}개 테마 조회 완료" } }
-    }
-
-    @Transactional(readOnly = true)
-    fun findThemesForReservation(): ThemeRetrieveListResponseV2 {
-        log.info { "[ThemeService.findThemesForReservation] 예약 페이지에서의 테마 목록 조회 시작" }
-
-        return themeRepository.findOpenedThemes()
-            .toRetrieveListResponse()
-            .also { log.info { "[ThemeService.findThemesForReservation] ${it.themes.size}개 테마 조회 완료" } }
-    }
-
-    @Transactional(readOnly = true)
-    fun findAdminThemes(): AdminThemeSummaryRetrieveListResponse {
-        log.info { "[ThemeService.findAdminThemes] 관리자 페이지에서의 테마 목록 조회 시작" }
-
-        return themeRepository.findAll()
-            .toAdminThemeSummaryListResponse()
-            .also { log.info { "[ThemeService.findAdminThemes] ${it.themes.size}개 테마 조회 완료" } }
-    }
-
-    @Transactional(readOnly = true)
-    fun findAdminThemeDetail(id: Long): AdminThemeDetailRetrieveResponse {
-        log.info { "[ThemeService.findAdminThemeDetail] 관리자 페이지에서의 테마 상세 정보 조회 시작: id=${id}" }
-
-        val theme: ThemeEntityV2 = findOrThrow(id)
-
-        val createdBy = memberService.findById(theme.createdBy).name
-        val updatedBy = memberService.findById(theme.updatedBy).name
-
-        return theme.toAdminThemeDetailResponse(createdBy, updatedBy)
-            .also { log.info { "[ThemeService.findAdminThemeDetail] 테마 상세 조회 완료: id=$id, name=${theme.name}" } }
-    }
-
-    @Transactional
-    fun createTheme(request: ThemeCreateRequestV2): ThemeCreateResponseV2 {
-        log.info { "[ThemeService.createTheme] 테마 생성 시작: name=${request.name}" }
-
-        themeValidator.validateCanCreate(request)
-
-        val theme: ThemeEntityV2 = themeRepository.save(
-            request.toEntity(tsidFactory.next())
-        )
-
-        return ThemeCreateResponseV2(theme.id).also {
-            log.info { "[ThemeService.createTheme] 테마 생성 완료: id=${theme.id}, name=${theme.name}" }
-        }
-    }
-
-    @Transactional
-    fun deleteTheme(id: Long) {
-        log.info { "[ThemeService.deleteTheme] 테마 삭제 시작: id=${id}" }
-
-        val theme: ThemeEntityV2 = findOrThrow(id)
-
-        themeRepository.delete(theme).also {
-            log.info { "[ThemeService.deleteTheme] 테마 삭제 완료: id=$id, name=${theme.name}" }
-        }
-    }
-
-    @Transactional
-    fun updateTheme(id: Long, request: ThemeUpdateRequest) {
-        log.info { "[ThemeService.updateTheme] 테마 수정 시작: id=${id}, request=${request}" }
-
-        if (request.isAllParamsNull()) {
-            log.info { "[ThemeService.updateTheme] 테마 변경 사항 없음: id=${id}" }
-            return
-        }
-
-        themeValidator.validateCanUpdate(request)
-
-        val theme: ThemeEntityV2 = findOrThrow(id)
-
-        theme.modifyIfNotNull(
-            request.name,
-            request.description,
-            request.thumbnailUrl,
-            request.difficulty,
-            request.price,
-            request.minParticipants,
-            request.maxParticipants,
-            request.availableMinutes,
-            request.expectedMinutesFrom,
-            request.expectedMinutesTo,
-            request.isOpen,
-        ).also {
-            log.info { "[ThemeService.updateTheme] 테마 수정 완료: id=$id, request=${request}" }
-        }
-    }
-
-    private fun findOrThrow(id: Long): ThemeEntityV2 {
-        log.info { "[ThemeService.findOrThrow] 테마 조회 시작: id=$id" }
-
-        return themeRepository.findByIdOrNull(id)
-            ?.also { log.info { "[ThemeService.findOrThrow] 테마 조회 완료: id=$id" } }
-            ?: run {
-                log.warn { "[ThemeService.updateTheme] 테마 조회 실패: id=$id" }
-                throw ThemeException(ThemeErrorCode.THEME_NOT_FOUND)
-            }
-    }
-}
diff --git a/src/main/kotlin/roomescape/theme/business/ThemeValidatorV2.kt b/src/main/kotlin/roomescape/theme/business/ThemeValidator.kt
similarity index 94%
rename from src/main/kotlin/roomescape/theme/business/ThemeValidatorV2.kt
rename to src/main/kotlin/roomescape/theme/business/ThemeValidator.kt
index 522b7187..6de7e205 100644
--- a/src/main/kotlin/roomescape/theme/business/ThemeValidatorV2.kt
+++ b/src/main/kotlin/roomescape/theme/business/ThemeValidator.kt
@@ -5,8 +5,8 @@ import io.github.oshai.kotlinlogging.KotlinLogging
 import org.springframework.stereotype.Component
 import roomescape.theme.exception.ThemeErrorCode
 import roomescape.theme.exception.ThemeException
-import roomescape.theme.infrastructure.persistence.v2.ThemeRepositoryV2
-import roomescape.theme.web.ThemeCreateRequestV2
+import roomescape.theme.infrastructure.persistence.ThemeRepository
+import roomescape.theme.web.ThemeCreateRequest
 import roomescape.theme.web.ThemeUpdateRequest
 
 private val log: KLogger = KotlinLogging.logger {}
@@ -16,8 +16,8 @@ const val MIN_PARTICIPANTS = 1
 const val MIN_DURATION = 1
 
 @Component
-class ThemeValidatorV2(
-    private val themeRepository: ThemeRepositoryV2,
+class ThemeValidator(
+    private val themeRepository: ThemeRepository,
 ) {
     fun validateCanUpdate(request: ThemeUpdateRequest) {
         validateProperties(
@@ -30,7 +30,7 @@ class ThemeValidatorV2(
         )
     }
 
-    fun validateCanCreate(request: ThemeCreateRequestV2) {
+    fun validateCanCreate(request: ThemeCreateRequest) {
         if (themeRepository.existsByName(request.name)) {
             log.info { "[ThemeValidator.validateCanCreate] 이름 중복으로 인한 실패: name=${request.name}" }
             throw ThemeException(ThemeErrorCode.THEME_NAME_DUPLICATED)
diff --git a/src/main/kotlin/roomescape/theme/docs/ThemeAPI.kt b/src/main/kotlin/roomescape/theme/docs/ThemeAPI.kt
deleted file mode 100644
index 0a9db7dc..00000000
--- a/src/main/kotlin/roomescape/theme/docs/ThemeAPI.kt
+++ /dev/null
@@ -1,52 +0,0 @@
-package roomescape.theme.docs
-
-import io.swagger.v3.oas.annotations.Operation
-import io.swagger.v3.oas.annotations.Parameter
-import io.swagger.v3.oas.annotations.responses.ApiResponse
-import io.swagger.v3.oas.annotations.responses.ApiResponses
-import io.swagger.v3.oas.annotations.tags.Tag
-import jakarta.validation.Valid
-import org.springframework.http.ResponseEntity
-import org.springframework.web.bind.annotation.PathVariable
-import org.springframework.web.bind.annotation.RequestBody
-import org.springframework.web.bind.annotation.RequestParam
-import roomescape.auth.web.support.Admin
-import roomescape.auth.web.support.LoginRequired
-import roomescape.common.dto.response.CommonApiResponse
-import roomescape.theme.web.ThemeCreateRequest
-import roomescape.theme.web.ThemeCreateResponse
-import roomescape.theme.web.ThemeRetrieveListResponse
-import roomescape.theme.web.ThemeRetrieveResponse
-
-@Tag(name = "5. 테마 API", description = "테마를 조회 / 추가 / 삭제할 때 사용합니다.")
-interface ThemeAPI {
-
-    @LoginRequired
-    @Operation(summary = "모든 테마 조회", description = "모든 테마를 조회합니다.", tags = ["로그인이 필요한 API"])
-    @ApiResponses(ApiResponse(responseCode = "200", description = "성공", useReturnTypeSchema = true))
-    fun findThemes(): ResponseEntity<CommonApiResponse<ThemeRetrieveListResponse>>
-
-    @Operation(summary = "가장 많이 예약된 테마 조회")
-    @ApiResponses(ApiResponse(responseCode = "200", description = "성공", useReturnTypeSchema = true))
-    fun findMostReservedThemes(
-        @RequestParam(defaultValue = "10") @Parameter(description = "최대로 조회할 테마 갯수") count: Int
-    ): ResponseEntity<CommonApiResponse<ThemeRetrieveListResponse>>
-
-    @Admin
-    @Operation(summary = "테마 추가", tags = ["관리자 로그인이 필요한 API"])
-    @ApiResponses(
-        ApiResponse(responseCode = "201", description = "성공", useReturnTypeSchema = true),
-    )
-    fun createTheme(
-        @Valid @RequestBody request: ThemeCreateRequest,
-    ): ResponseEntity<CommonApiResponse<ThemeCreateResponse>>
-
-    @Admin
-    @Operation(summary = "테마 삭제", tags = ["관리자 로그인이 필요한 API"])
-    @ApiResponses(
-        ApiResponse(responseCode = "204", description = "성공", useReturnTypeSchema = true),
-    )
-    fun deleteTheme(
-        @PathVariable id: Long
-    ): ResponseEntity<CommonApiResponse<Unit>>
-}
diff --git a/src/main/kotlin/roomescape/theme/docs/ThemeApiV2.kt b/src/main/kotlin/roomescape/theme/docs/ThemeApi.kt
similarity index 83%
rename from src/main/kotlin/roomescape/theme/docs/ThemeApiV2.kt
rename to src/main/kotlin/roomescape/theme/docs/ThemeApi.kt
index 61e94dd1..284d7684 100644
--- a/src/main/kotlin/roomescape/theme/docs/ThemeApiV2.kt
+++ b/src/main/kotlin/roomescape/theme/docs/ThemeApi.kt
@@ -11,13 +11,7 @@ import org.springframework.web.bind.annotation.RequestBody
 import roomescape.auth.web.support.Admin
 import roomescape.auth.web.support.LoginRequired
 import roomescape.common.dto.response.CommonApiResponse
-import roomescape.theme.web.AdminThemeDetailRetrieveResponse
-import roomescape.theme.web.AdminThemeSummaryRetrieveListResponse
-import roomescape.theme.web.ThemeCreateRequestV2
-import roomescape.theme.web.ThemeCreateResponseV2
-import roomescape.theme.web.ThemeListRetrieveRequest
-import roomescape.theme.web.ThemeUpdateRequest
-import roomescape.theme.web.ThemeRetrieveListResponseV2
+import roomescape.theme.web.*
 
 @Tag(name = "5. 관리자 테마 API", description = "관리자 페이지에서 테마를 조회 / 추가 / 삭제할 때 사용합니다.")
 interface ThemeAPIV2 {
@@ -35,7 +29,7 @@ interface ThemeAPIV2 {
     @Admin
     @Operation(summary = "테마 추가", tags = ["관리자 로그인이 필요한 API"])
     @ApiResponses(ApiResponse(responseCode = "200", description = "성공", useReturnTypeSchema = true))
-    fun createTheme(@Valid @RequestBody themeCreateRequestV2: ThemeCreateRequestV2): ResponseEntity<CommonApiResponse<ThemeCreateResponseV2>>
+    fun createTheme(@Valid @RequestBody themeCreateRequest: ThemeCreateRequest): ResponseEntity<CommonApiResponse<ThemeCreateResponseV2>>
 
     @Admin
     @Operation(summary = "테마 삭제", tags = ["관리자 로그인이 필요한 API"])
@@ -53,10 +47,10 @@ interface ThemeAPIV2 {
     @LoginRequired
     @Operation(summary = "예약 페이지에서 모든 테마 조회", description = "모든 테마를 조회합니다.", tags = ["로그인이 필요한 API"])
     @ApiResponses(ApiResponse(responseCode = "200", description = "성공", useReturnTypeSchema = true))
-    fun findUserThemes(): ResponseEntity<CommonApiResponse<ThemeRetrieveListResponseV2>>
+    fun findUserThemes(): ResponseEntity<CommonApiResponse<ThemeSummaryListResponse>>
 
     @LoginRequired
     @Operation(summary = "예약 페이지에서 입력한 날짜에 가능한 테마 조회", description = "입력한 날짜에 가능한 테마를 조회합니다.", tags = ["로그인이 필요한 API"])
     @ApiResponses(ApiResponse(responseCode = "200", description = "성공", useReturnTypeSchema = true))
-    fun findThemesByIds(request: ThemeListRetrieveRequest): ResponseEntity<CommonApiResponse<ThemeRetrieveListResponseV2>>
+    fun findThemesByIds(request: ThemeListRetrieveRequest): ResponseEntity<CommonApiResponse<ThemeSummaryListResponse>>
 }
diff --git a/src/main/kotlin/roomescape/theme/implement/ThemeFinder.kt b/src/main/kotlin/roomescape/theme/implement/ThemeFinder.kt
deleted file mode 100644
index 42a86062..00000000
--- a/src/main/kotlin/roomescape/theme/implement/ThemeFinder.kt
+++ /dev/null
@@ -1,47 +0,0 @@
-package roomescape.theme.implement
-
-import io.github.oshai.kotlinlogging.KLogger
-import io.github.oshai.kotlinlogging.KotlinLogging
-import org.springframework.data.repository.findByIdOrNull
-import org.springframework.stereotype.Component
-import roomescape.theme.exception.ThemeErrorCode
-import roomescape.theme.exception.ThemeException
-import roomescape.theme.infrastructure.persistence.ThemeEntity
-import roomescape.theme.infrastructure.persistence.ThemeRepository
-import java.time.LocalDate
-
-private val log: KLogger = KotlinLogging.logger {}
-
-@Component
-class ThemeFinder(
-    private val themeRepository: ThemeRepository
-) {
-    fun findAll(): List<ThemeEntity> {
-        log.debug { "[ThemeFinder.findAll] 시작" }
-
-        return themeRepository.findAll()
-            .also { log.debug { "[TimeFinder.findAll] ${it.size}개 테마 조회 완료" } }
-    }
-
-    fun findById(id: Long): ThemeEntity {
-        log.debug { "[ThemeFinder.findById] 조회 시작: memberId=$id" }
-
-        return themeRepository.findByIdOrNull(id)
-            ?.also { log.debug { "[ThemeFinder.findById] 조회 완료: id=$id, name=${it.name}" } }
-            ?: run {
-                log.warn { "[ThemeFinder.findById] 조회 실패: id=$id" }
-                throw ThemeException(ThemeErrorCode.THEME_NOT_FOUND)
-            }
-    }
-
-    fun findMostReservedThemes(
-        count: Int,
-        startFrom: LocalDate,
-        endAt: LocalDate
-    ): List<ThemeEntity> {
-        log.debug { "[ThemeFinder.findMostReservedThemes] 시작. count=$count, startFrom=$startFrom, endAt=$endAt" }
-
-        return themeRepository.findPopularThemes(startFrom, endAt, count)
-            .also { log.debug { "[ThemeFinder.findMostReservedThemes] ${it.size} / ${count}개 테마 조회 완료" } }
-    }
-}
diff --git a/src/main/kotlin/roomescape/theme/implement/ThemeValidator.kt b/src/main/kotlin/roomescape/theme/implement/ThemeValidator.kt
deleted file mode 100644
index 6887d894..00000000
--- a/src/main/kotlin/roomescape/theme/implement/ThemeValidator.kt
+++ /dev/null
@@ -1,43 +0,0 @@
-package roomescape.theme.implement
-
-import io.github.oshai.kotlinlogging.KLogger
-import io.github.oshai.kotlinlogging.KotlinLogging
-import org.springframework.stereotype.Component
-import roomescape.theme.exception.ThemeErrorCode
-import roomescape.theme.exception.ThemeException
-import roomescape.theme.infrastructure.persistence.ThemeEntity
-import roomescape.theme.infrastructure.persistence.ThemeRepository
-
-private val log: KLogger = KotlinLogging.logger {}
-
-@Component
-class ThemeValidator(
-    private val themeRepository: ThemeRepository
-) {
-    fun validateNameAlreadyExists(name: String) {
-        log.debug { "[ThemeValidator.validateNameAlreadyExists] 시작: name=$name" }
-
-        if (themeRepository.existsByName(name)) {
-            log.info { "[ThemeService.createTheme] 이름 중복: name=${name}" }
-            throw ThemeException(ThemeErrorCode.THEME_NAME_DUPLICATED)
-        }
-
-        log.debug { "[ThemeValidator.validateNameAlreadyExists] 완료: name=$name" }
-    }
-
-    fun validateIsReserved(theme: ThemeEntity) {
-        val themeId: Long = theme.id ?: run {
-            log.warn { "[ThemeValidator.validateIsReserved] ID를 찾을 수 없음: name:${theme.name}" }
-            throw ThemeException(ThemeErrorCode.INVALID_REQUEST_VALUE)
-        }
-
-        log.debug { "[ThemeValidator.validateIsReserved] 시작: themeId=${themeId}" }
-
-        if (themeRepository.isReservedTheme(themeId)) {
-            log.info { "[ThemeService.deleteTheme] 예약이 있는 테마: themeId=$themeId" }
-            throw ThemeException(ThemeErrorCode.THEME_ALREADY_RESERVED)
-        }
-
-        log.debug { "[ThemeValidator.validateIsReserved] 완료: themeId=$themeId" }
-    }
-}
diff --git a/src/main/kotlin/roomescape/theme/implement/ThemeWriter.kt b/src/main/kotlin/roomescape/theme/implement/ThemeWriter.kt
deleted file mode 100644
index 3f07b335..00000000
--- a/src/main/kotlin/roomescape/theme/implement/ThemeWriter.kt
+++ /dev/null
@@ -1,41 +0,0 @@
-package roomescape.theme.implement
-
-import com.github.f4b6a3.tsid.TsidFactory
-import io.github.oshai.kotlinlogging.KLogger
-import io.github.oshai.kotlinlogging.KotlinLogging
-import org.springframework.stereotype.Component
-import roomescape.common.config.next
-import roomescape.theme.infrastructure.persistence.ThemeEntity
-import roomescape.theme.infrastructure.persistence.ThemeRepository
-
-private val log: KLogger = KotlinLogging.logger {}
-
-@Component
-class ThemeWriter(
-    private val themeValidator: ThemeValidator,
-    private val themeRepository: ThemeRepository,
-    private val tsidFactory: TsidFactory
-) {
-    fun create(name: String, description: String, thumbnail: String): ThemeEntity {
-        log.debug { "[ThemeWriter.create] 시작: name=$name" }
-        themeValidator.validateNameAlreadyExists(name)
-
-        val theme = ThemeEntity(
-            _id = tsidFactory.next(),
-            name = name,
-            description = description,
-            thumbnail = thumbnail
-        )
-
-        return themeRepository.save(theme)
-            .also { log.debug { "[ThemeWriter.create] 완료: name=$name, id=${it.id}" } }
-    }
-
-    fun delete(theme: ThemeEntity) {
-        log.debug { "[ThemeWriter.delete] 시작: id=${theme.id}" }
-        themeValidator.validateIsReserved(theme)
-
-        themeRepository.delete(theme)
-            .also { log.debug { "[ThemeWriter.delete] 완료: id=${theme.id}, name=${theme.name}" } }
-    }
-}
diff --git a/src/main/kotlin/roomescape/theme/infrastructure/persistence/ThemeEntity.kt b/src/main/kotlin/roomescape/theme/infrastructure/persistence/ThemeEntity.kt
index 4abd4383..df67be94 100644
--- a/src/main/kotlin/roomescape/theme/infrastructure/persistence/ThemeEntity.kt
+++ b/src/main/kotlin/roomescape/theme/infrastructure/persistence/ThemeEntity.kt
@@ -1,26 +1,62 @@
 package roomescape.theme.infrastructure.persistence
 
-import jakarta.persistence.Column
-import jakarta.persistence.Entity
-import jakarta.persistence.Id
-import jakarta.persistence.Table
-import roomescape.common.entity.BaseEntity
+import jakarta.persistence.*
+import roomescape.common.entity.AuditingBaseEntity
 
 @Entity
-@Table(name = "themes")
+@Table(name = "theme")
 class ThemeEntity(
-    @Id
-    @Column(name = "theme_id")
-    private var _id: Long?,
+    id: Long,
 
-    @Column(name = "name", nullable = false)
     var name: String,
-
-    @Column(name = "description", nullable = false)
     var description: String,
+    var thumbnailUrl: String,
 
-    @Column(name = "thumbnail", nullable = false)
-    var thumbnail: String,
-): BaseEntity() {
-    override fun getId(): Long? = _id
+    @Enumerated(value = EnumType.STRING)
+    var difficulty: Difficulty,
+
+    var price: Int,
+    var minParticipants: Short,
+    var maxParticipants: Short,
+    var availableMinutes: Short,
+    var expectedMinutesFrom: Short,
+    var expectedMinutesTo: Short,
+
+    @Column(columnDefinition = "TINYINT", length = 1)
+    var isOpen: Boolean
+) : AuditingBaseEntity(id) {
+
+    fun modifyIfNotNull(
+        name: String?,
+        description: String?,
+        thumbnailUrl: String?,
+        difficulty: Difficulty?,
+        price: Int?,
+        minParticipants: Short?,
+        maxParticipants: Short?,
+        availableMinutes: Short?,
+        expectedMinutesFrom: Short?,
+        expectedMinutesTo: Short?,
+        isOpen: Boolean?
+    ) {
+        name?.let { this.name = it }
+        description?.let { this.description = it }
+        thumbnailUrl?.let { this.thumbnailUrl = it }
+        difficulty?.let { this.difficulty = it }
+        price?.let { this.price = it }
+        minParticipants?.let { this.minParticipants = it }
+        maxParticipants?.let { this.maxParticipants = it }
+        availableMinutes?.let { this.availableMinutes = it }
+        expectedMinutesFrom?.let { this.expectedMinutesFrom = it }
+        expectedMinutesTo?.let { this.expectedMinutesTo = it }
+        isOpen?.let { this.isOpen = it }
+    }
+}
+
+enum class Difficulty {
+    VERY_EASY,
+    EASY,
+    NORMAL,
+    HARD,
+    VERY_HARD
 }
diff --git a/src/main/kotlin/roomescape/theme/infrastructure/persistence/ThemeRepository.kt b/src/main/kotlin/roomescape/theme/infrastructure/persistence/ThemeRepository.kt
index c7129a93..1773826b 100644
--- a/src/main/kotlin/roomescape/theme/infrastructure/persistence/ThemeRepository.kt
+++ b/src/main/kotlin/roomescape/theme/infrastructure/persistence/ThemeRepository.kt
@@ -2,31 +2,11 @@ package roomescape.theme.infrastructure.persistence
 
 import org.springframework.data.jpa.repository.JpaRepository
 import org.springframework.data.jpa.repository.Query
-import java.time.LocalDate
 
 interface ThemeRepository : JpaRepository<ThemeEntity, Long> {
 
-    @Query(value = """
-		SELECT t
-		    FROM ThemeEntity t
-		    RIGHT JOIN ReservationEntity r ON t._id = r.theme._id
-		    WHERE r.date BETWEEN :startFrom AND :endAt
-		    GROUP BY r.theme._id
-		    ORDER BY COUNT(r.theme._id) DESC, t._id ASC
-		    LIMIT :count
-		"""
-    )
-    fun findPopularThemes(startFrom: LocalDate, endAt: LocalDate, count: Int): List<ThemeEntity>
+    @Query("SELECT t FROM ThemeEntity t WHERE t.isOpen = true")
+    fun findOpenedThemes(): List<ThemeEntity>
 
     fun existsByName(name: String): Boolean
-
-    @Query(value = """
-		SELECT EXISTS(
-		    SELECT 1
-		    FROM ReservationEntity r
-		    WHERE r.theme._id = :id
-		)
-		"""
-    )
-    fun isReservedTheme(id: Long): Boolean
-}
+}
\ No newline at end of file
diff --git a/src/main/kotlin/roomescape/theme/infrastructure/persistence/v2/ThemeEntityV2.kt b/src/main/kotlin/roomescape/theme/infrastructure/persistence/v2/ThemeEntityV2.kt
deleted file mode 100644
index fd462878..00000000
--- a/src/main/kotlin/roomescape/theme/infrastructure/persistence/v2/ThemeEntityV2.kt
+++ /dev/null
@@ -1,66 +0,0 @@
-package roomescape.theme.infrastructure.persistence.v2
-
-import jakarta.persistence.Column
-import jakarta.persistence.Entity
-import jakarta.persistence.EnumType
-import jakarta.persistence.Enumerated
-import jakarta.persistence.Table
-import roomescape.common.entity.AuditingBaseEntity
-
-@Entity
-@Table(name = "theme")
-class ThemeEntityV2(
-    id: Long,
-
-    var name: String,
-    var description: String,
-    var thumbnailUrl: String,
-
-    @Enumerated(value = EnumType.STRING)
-    var difficulty: Difficulty,
-
-    var price: Int,
-    var minParticipants: Short,
-    var maxParticipants: Short,
-    var availableMinutes: Short,
-    var expectedMinutesFrom: Short,
-    var expectedMinutesTo: Short,
-
-    @Column(columnDefinition = "TINYINT", length = 1)
-    var isOpen: Boolean
-) : AuditingBaseEntity(id) {
-
-    fun modifyIfNotNull(
-        name: String?,
-        description: String?,
-        thumbnailUrl: String?,
-        difficulty: Difficulty?,
-        price: Int?,
-        minParticipants: Short?,
-        maxParticipants: Short?,
-        availableMinutes: Short?,
-        expectedMinutesFrom: Short?,
-        expectedMinutesTo: Short?,
-        isOpen: Boolean?
-    ) {
-        name?.let { this.name = it }
-        description?.let { this.description = it }
-        thumbnailUrl?.let { this.thumbnailUrl = it }
-        difficulty?.let { this.difficulty = it }
-        price?.let { this.price = it }
-        minParticipants?.let { this.minParticipants = it }
-        maxParticipants?.let { this.maxParticipants = it }
-        availableMinutes?.let { this.availableMinutes = it }
-        expectedMinutesFrom?.let { this.expectedMinutesFrom = it }
-        expectedMinutesTo?.let { this.expectedMinutesTo = it }
-        isOpen?.let { this.isOpen = it }
-    }
-}
-
-enum class Difficulty {
-    VERY_EASY,
-    EASY,
-    NORMAL,
-    HARD,
-    VERY_HARD
-}
diff --git a/src/main/kotlin/roomescape/theme/infrastructure/persistence/v2/ThemeRepositoryV2.kt b/src/main/kotlin/roomescape/theme/infrastructure/persistence/v2/ThemeRepositoryV2.kt
deleted file mode 100644
index 64f12e7a..00000000
--- a/src/main/kotlin/roomescape/theme/infrastructure/persistence/v2/ThemeRepositoryV2.kt
+++ /dev/null
@@ -1,12 +0,0 @@
-package roomescape.theme.infrastructure.persistence.v2
-
-import org.springframework.data.jpa.repository.JpaRepository
-import org.springframework.data.jpa.repository.Query
-
-interface ThemeRepositoryV2: JpaRepository<ThemeEntityV2, Long> {
-
-    @Query("SELECT t FROM ThemeEntityV2 t WHERE t.isOpen = true")
-    fun findOpenedThemes(): List<ThemeEntityV2>
-
-    fun existsByName(name: String): Boolean
-}
\ No newline at end of file
diff --git a/src/main/kotlin/roomescape/theme/web/ThemeController.kt b/src/main/kotlin/roomescape/theme/web/ThemeController.kt
index 3b12fb3c..bc7321da 100644
--- a/src/main/kotlin/roomescape/theme/web/ThemeController.kt
+++ b/src/main/kotlin/roomescape/theme/web/ThemeController.kt
@@ -1,51 +1,69 @@
 package roomescape.theme.web
 
-import io.swagger.v3.oas.annotations.Parameter
-import jakarta.validation.Valid
 import org.springframework.http.ResponseEntity
 import org.springframework.web.bind.annotation.*
 import roomescape.common.dto.response.CommonApiResponse
 import roomescape.theme.business.ThemeService
-import roomescape.theme.docs.ThemeAPI
+import roomescape.theme.docs.ThemeAPIV2
 import java.net.URI
 
 @RestController
 class ThemeController(
-    private val themeService: ThemeService
-) : ThemeAPI {
+    private val themeService: ThemeService,
+) : ThemeAPIV2 {
 
-    @GetMapping("/themes")
-    override fun findThemes(): ResponseEntity<CommonApiResponse<ThemeRetrieveListResponse>> {
-        val response: ThemeRetrieveListResponse = themeService.findThemes()
+    @PostMapping("/themes/retrieve")
+    override fun findThemesByIds(
+        @RequestBody request: ThemeListRetrieveRequest
+    ): ResponseEntity<CommonApiResponse<ThemeSummaryListResponse>> {
+        val response = themeService.findThemesByIds(request)
 
         return ResponseEntity.ok(CommonApiResponse(response))
     }
 
-    @GetMapping("/themes/most-reserved-last-week")
-    override fun findMostReservedThemes(
-        @RequestParam(defaultValue = "10") @Parameter(description = "최대로 조회할 테마 갯수") count: Int
-    ): ResponseEntity<CommonApiResponse<ThemeRetrieveListResponse>> {
-        val response: ThemeRetrieveListResponse = themeService.findMostReservedThemes(count)
+    @GetMapping("/v2/themes")
+    override fun findUserThemes(): ResponseEntity<CommonApiResponse<ThemeSummaryListResponse>> {
+        val response = themeService.findThemesForReservation()
 
         return ResponseEntity.ok(CommonApiResponse(response))
     }
 
-    @PostMapping("/themes")
-    override fun createTheme(
-        @RequestBody @Valid request: ThemeCreateRequest
-    ): ResponseEntity<CommonApiResponse<ThemeCreateResponse>> {
-        val themeResponse: ThemeCreateResponse = themeService.createTheme(request)
+    @GetMapping("/admin/themes")
+    override fun findAdminThemes(): ResponseEntity<CommonApiResponse<AdminThemeSummaryRetrieveListResponse>> {
+        val response = themeService.findAdminThemes()
 
-        return ResponseEntity.created(URI.create("/themes/${themeResponse.id}"))
-            .body(CommonApiResponse(themeResponse))
+        return ResponseEntity.ok(CommonApiResponse(response))
     }
 
-    @DeleteMapping("/themes/{id}")
-    override fun deleteTheme(
-        @PathVariable id: Long
-    ): ResponseEntity<CommonApiResponse<Unit>> {
+    @GetMapping("/admin/themes/{id}")
+    override fun findAdminThemeDetail(@PathVariable id: Long): ResponseEntity<CommonApiResponse<AdminThemeDetailRetrieveResponse>> {
+        val response = themeService.findAdminThemeDetail(id)
+
+        return ResponseEntity.ok(CommonApiResponse(response))
+    }
+
+    @PostMapping("/admin/themes")
+    override fun createTheme(themeCreateRequest: ThemeCreateRequest): ResponseEntity<CommonApiResponse<ThemeCreateResponseV2>> {
+        val response = themeService.createTheme(themeCreateRequest)
+
+        return ResponseEntity.created(URI.create("/admin/themes/${response.id}"))
+            .body(CommonApiResponse(response))
+    }
+
+    @DeleteMapping("/admin/themes/{id}")
+    override fun deleteTheme(@PathVariable id: Long): ResponseEntity<CommonApiResponse<Unit>> {
         themeService.deleteTheme(id)
 
         return ResponseEntity.noContent().build()
     }
+
+    @PatchMapping("/admin/themes/{id}")
+    override fun updateTheme(
+        @PathVariable id: Long,
+        themeUpdateRequest: ThemeUpdateRequest
+    ): ResponseEntity<CommonApiResponse<Unit>> {
+        themeService.updateTheme(id, themeUpdateRequest)
+
+        return ResponseEntity.ok().build()
+    }
 }
diff --git a/src/main/kotlin/roomescape/theme/web/ThemeControllerV2.kt b/src/main/kotlin/roomescape/theme/web/ThemeControllerV2.kt
deleted file mode 100644
index bdf454a0..00000000
--- a/src/main/kotlin/roomescape/theme/web/ThemeControllerV2.kt
+++ /dev/null
@@ -1,69 +0,0 @@
-package roomescape.theme.web
-
-import org.springframework.http.ResponseEntity
-import org.springframework.web.bind.annotation.*
-import roomescape.common.dto.response.CommonApiResponse
-import roomescape.theme.business.ThemeServiceV2
-import roomescape.theme.docs.ThemeAPIV2
-import java.net.URI
-
-@RestController
-class ThemeControllerV2(
-    private val themeService: ThemeServiceV2,
-) : ThemeAPIV2 {
-
-    @PostMapping("/themes/retrieve")
-    override fun findThemesByIds(
-        @RequestBody request: ThemeListRetrieveRequest
-    ): ResponseEntity<CommonApiResponse<ThemeRetrieveListResponseV2>> {
-        val response = themeService.findThemesByIds(request)
-
-        return ResponseEntity.ok(CommonApiResponse(response))
-    }
-
-    @GetMapping("/v2/themes")
-    override fun findUserThemes(): ResponseEntity<CommonApiResponse<ThemeRetrieveListResponseV2>> {
-        val response = themeService.findThemesForReservation()
-
-        return ResponseEntity.ok(CommonApiResponse(response))
-    }
-
-    @GetMapping("/admin/themes")
-    override fun findAdminThemes(): ResponseEntity<CommonApiResponse<AdminThemeSummaryRetrieveListResponse>> {
-        val response = themeService.findAdminThemes()
-
-        return ResponseEntity.ok(CommonApiResponse(response))
-    }
-
-    @GetMapping("/admin/themes/{id}")
-    override fun findAdminThemeDetail(@PathVariable id: Long): ResponseEntity<CommonApiResponse<AdminThemeDetailRetrieveResponse>> {
-        val response = themeService.findAdminThemeDetail(id)
-
-        return ResponseEntity.ok(CommonApiResponse(response))
-    }
-
-    @PostMapping("/admin/themes")
-    override fun createTheme(themeCreateRequestV2: ThemeCreateRequestV2): ResponseEntity<CommonApiResponse<ThemeCreateResponseV2>> {
-        val response = themeService.createTheme(themeCreateRequestV2)
-
-        return ResponseEntity.created(URI.create("/admin/themes/${response.id}"))
-            .body(CommonApiResponse(response))
-    }
-
-    @DeleteMapping("/admin/themes/{id}")
-    override fun deleteTheme(@PathVariable id: Long): ResponseEntity<CommonApiResponse<Unit>> {
-        themeService.deleteTheme(id)
-
-        return ResponseEntity.noContent().build()
-    }
-
-    @PatchMapping("/admin/themes/{id}")
-    override fun updateTheme(
-        @PathVariable id: Long,
-        themeUpdateRequest: ThemeUpdateRequest
-    ): ResponseEntity<CommonApiResponse<Unit>> {
-        themeService.updateTheme(id, themeUpdateRequest)
-
-        return ResponseEntity.ok().build()
-    }
-}
diff --git a/src/main/kotlin/roomescape/theme/web/ThemeDTO.kt b/src/main/kotlin/roomescape/theme/web/ThemeDTO.kt
deleted file mode 100644
index 32b14485..00000000
--- a/src/main/kotlin/roomescape/theme/web/ThemeDTO.kt
+++ /dev/null
@@ -1,60 +0,0 @@
-package roomescape.theme.web
-
-import io.swagger.v3.oas.annotations.media.Schema
-import jakarta.validation.constraints.NotBlank
-import jakarta.validation.constraints.Size
-import org.hibernate.validator.constraints.URL
-import roomescape.theme.infrastructure.persistence.ThemeEntity
-
-data class ThemeCreateRequest(
-    @NotBlank
-    @Size(max = 20)
-    val name: String,
-
-    @NotBlank
-    @Size(max = 100)
-    val description: String,
-
-    @URL
-    @NotBlank
-    @Schema(description = "썸네일 이미지 주소(URL).")
-    val thumbnail: String
-)
-
-data class ThemeCreateResponse(
-    val id: Long,
-    val name: String,
-    val description: String,
-    @Schema(description = "썸네일 이미지 주소(URL).")
-    val thumbnail: String
-)
-
-fun ThemeEntity.toCreateResponse(): ThemeCreateResponse = ThemeCreateResponse(
-    id = this.id!!,
-    name = this.name,
-    description = this.description,
-    thumbnail = this.thumbnail
-)
-
-data class ThemeRetrieveResponse(
-    val id: Long,
-    val name: String,
-    val description: String,
-    @Schema(description = "썸네일 이미지 주소(URL).")
-    val thumbnail: String
-)
-
-fun ThemeEntity.toRetrieveResponse(): ThemeRetrieveResponse = ThemeRetrieveResponse(
-    id = this.id!!,
-    name = this.name,
-    description = this.description,
-    thumbnail = this.thumbnail
-)
-
-data class ThemeRetrieveListResponse(
-    val themes: List<ThemeRetrieveResponse>
-)
-
-fun List<ThemeEntity>.toRetrieveListResponse(): ThemeRetrieveListResponse = ThemeRetrieveListResponse(
-    themes = this.map { it.toRetrieveResponse() }
-)
diff --git a/src/main/kotlin/roomescape/theme/web/ThemeDtoV2.kt b/src/main/kotlin/roomescape/theme/web/ThemeDto.kt
similarity index 83%
rename from src/main/kotlin/roomescape/theme/web/ThemeDtoV2.kt
rename to src/main/kotlin/roomescape/theme/web/ThemeDto.kt
index d5b6461a..8f5fb270 100644
--- a/src/main/kotlin/roomescape/theme/web/ThemeDtoV2.kt
+++ b/src/main/kotlin/roomescape/theme/web/ThemeDto.kt
@@ -1,10 +1,10 @@
 package roomescape.theme.web
 
-import roomescape.theme.infrastructure.persistence.v2.Difficulty
-import roomescape.theme.infrastructure.persistence.v2.ThemeEntityV2
+import roomescape.theme.infrastructure.persistence.Difficulty
+import roomescape.theme.infrastructure.persistence.ThemeEntity
 import java.time.LocalDateTime
 
-data class ThemeCreateRequestV2(
+data class ThemeCreateRequest(
     val name: String,
     val description: String,
     val thumbnailUrl: String,
@@ -22,7 +22,7 @@ data class ThemeCreateResponseV2(
     val id: Long
 )
 
-fun ThemeCreateRequestV2.toEntity(id: Long) = ThemeEntityV2(
+fun ThemeCreateRequest.toEntity(id: Long) = ThemeEntity(
     id = id,
     name = this.name,
     description = this.description,
@@ -73,7 +73,7 @@ data class AdminThemeSummaryRetrieveResponse(
     val isOpen: Boolean
 )
 
-fun ThemeEntityV2.toAdminThemeSummaryResponse() = AdminThemeSummaryRetrieveResponse(
+fun ThemeEntity.toAdminThemeSummaryResponse() = AdminThemeSummaryRetrieveResponse(
     id = this.id,
     name = this.name,
     difficulty = this.difficulty,
@@ -85,7 +85,7 @@ data class AdminThemeSummaryRetrieveListResponse(
     val themes: List<AdminThemeSummaryRetrieveResponse>
 )
 
-fun List<ThemeEntityV2>.toAdminThemeSummaryListResponse() = AdminThemeSummaryRetrieveListResponse(
+fun List<ThemeEntity>.toAdminThemeSummaryListResponse() = AdminThemeSummaryRetrieveListResponse(
     themes = this.map { it.toAdminThemeSummaryResponse() }
 )
 
@@ -108,7 +108,7 @@ data class AdminThemeDetailRetrieveResponse(
     val updatedBy: String,
 )
 
-fun ThemeEntityV2.toAdminThemeDetailResponse(createUserName: String, updateUserName: String) =
+fun ThemeEntity.toAdminThemeDetailResponse(createUserName: String, updateUserName: String) =
     AdminThemeDetailRetrieveResponse(
         id = this.id,
         name = this.name,
@@ -132,7 +132,7 @@ data class ThemeListRetrieveRequest(
     val themeIds: List<Long>
 )
 
-data class ThemeRetrieveResponseV2(
+data class ThemeSummaryResponse(
     val id: Long,
     val name: String,
     val thumbnailUrl: String,
@@ -146,7 +146,7 @@ data class ThemeRetrieveResponseV2(
     val expectedMinutesTo: Short
 )
 
-fun ThemeEntityV2.toRetrieveResponse() = ThemeRetrieveResponseV2(
+fun ThemeEntity.toSummaryResponse() = ThemeSummaryResponse(
     id = this.id,
     name = this.name,
     thumbnailUrl = this.thumbnailUrl,
@@ -160,10 +160,10 @@ fun ThemeEntityV2.toRetrieveResponse() = ThemeRetrieveResponseV2(
     expectedMinutesTo = this.expectedMinutesTo
 )
 
-data class ThemeRetrieveListResponseV2(
-    val themes: List<ThemeRetrieveResponseV2>
+data class ThemeSummaryListResponse(
+    val themes: List<ThemeSummaryResponse>
 )
 
-fun List<ThemeEntityV2>.toRetrieveListResponse() = ThemeRetrieveListResponseV2(
-    themes = this.map { it.toRetrieveResponse() }
-)
\ No newline at end of file
+fun List<ThemeEntity>.toRetrieveListResponse() = ThemeSummaryListResponse(
+    themes = this.map { it.toSummaryResponse() }
+)
diff --git a/src/main/kotlin/roomescape/time/business/TimeService.kt b/src/main/kotlin/roomescape/time/business/TimeService.kt
deleted file mode 100644
index 42af422d..00000000
--- a/src/main/kotlin/roomescape/time/business/TimeService.kt
+++ /dev/null
@@ -1,74 +0,0 @@
-package roomescape.time.business
-
-import io.github.oshai.kotlinlogging.KotlinLogging
-import org.springframework.stereotype.Service
-import org.springframework.transaction.annotation.Transactional
-import roomescape.time.implement.TimeFinder
-import roomescape.time.implement.TimeWriter
-import roomescape.time.infrastructure.persistence.TimeEntity
-import roomescape.time.web.*
-import java.time.LocalDate
-import java.time.LocalTime
-
-private val log = KotlinLogging.logger {}
-
-@Service
-class TimeService(
-    private val timeFinder: TimeFinder,
-    private val timeWriter: TimeWriter,
-) {
-    @Transactional(readOnly = true)
-    fun findById(id: Long): TimeEntity {
-        log.debug { "[TimeService.findById] 시작: timeId=$id" }
-
-        return timeFinder.findById(id)
-            .also { log.info { "[TimeService.findById] 완료: timeId=$id, startAt=${it.startAt}" } }
-    }
-
-    @Transactional(readOnly = true)
-    fun findTimes(): TimeRetrieveListResponse {
-        log.debug { "[TimeService.findTimes] 시작" }
-
-        return timeFinder.findAll()
-            .toResponse()
-            .also { log.info { "[TimeService.findTimes] 완료. ${it.times.size}개 반환" } }
-    }
-
-    @Transactional(readOnly = true)
-    fun findTimesWithAvailability(date: LocalDate, themeId: Long): TimeWithAvailabilityListResponse {
-        log.debug { "[TimeService.findTimesWithAvailability] 시작: date=$date, themeId=$themeId" }
-
-        val times: List<TimeWithAvailabilityResponse> =
-            timeFinder.findAllWithAvailabilityByDateAndThemeId(date, themeId)
-                .map {
-                    TimeWithAvailabilityResponse(
-                        id = it.timeId,
-                        startAt = it.startAt,
-                        isAvailable = it.isReservable
-                    )
-                }
-
-        return TimeWithAvailabilityListResponse(times)
-            .also { log.info { "[TimeService.findTimesWithAvailability] ${it.times.size}개 반환: date=$date, themeId=$themeId" } }
-    }
-
-    @Transactional
-    fun createTime(request: TimeCreateRequest): TimeCreateResponse {
-        val startAt: LocalTime = request.startAt
-        log.debug { "[TimeService.createTime] 시작: startAt=${startAt}" }
-
-        return timeWriter.create(startAt)
-            .toCreateResponse()
-            .also { log.info { "[TimeService.createTime] 완료: startAt=${startAt}, timeId=${it.id}" } }
-    }
-
-    @Transactional
-    fun deleteTime(id: Long) {
-        log.debug { "[TimeService.deleteTime] 시작: timeId=$id" }
-
-        val time: TimeEntity = timeFinder.findById(id)
-
-        timeWriter.delete(time)
-            .also { log.info { "[TimeService.deleteTime] 완료: timeId=$id, startAt=${time.startAt}" } }
-    }
-}
diff --git a/src/main/kotlin/roomescape/time/business/domain/TimeWithAvailability.kt b/src/main/kotlin/roomescape/time/business/domain/TimeWithAvailability.kt
deleted file mode 100644
index c53000d5..00000000
--- a/src/main/kotlin/roomescape/time/business/domain/TimeWithAvailability.kt
+++ /dev/null
@@ -1,12 +0,0 @@
-package roomescape.time.business.domain
-
-import java.time.LocalDate
-import java.time.LocalTime
-
-class TimeWithAvailability(
-    val timeId: Long,
-    val startAt: LocalTime,
-    val date: LocalDate,
-    val themeId: Long,
-    val isReservable: Boolean
-)
diff --git a/src/main/kotlin/roomescape/time/docs/TimeAPI.kt b/src/main/kotlin/roomescape/time/docs/TimeAPI.kt
deleted file mode 100644
index 0d0da336..00000000
--- a/src/main/kotlin/roomescape/time/docs/TimeAPI.kt
+++ /dev/null
@@ -1,50 +0,0 @@
-package roomescape.time.docs
-
-import io.swagger.v3.oas.annotations.Operation
-import io.swagger.v3.oas.annotations.responses.ApiResponse
-import io.swagger.v3.oas.annotations.responses.ApiResponses
-import io.swagger.v3.oas.annotations.tags.Tag
-import jakarta.validation.Valid
-import org.springframework.http.ResponseEntity
-import org.springframework.web.bind.annotation.PathVariable
-import org.springframework.web.bind.annotation.RequestBody
-import org.springframework.web.bind.annotation.RequestParam
-import roomescape.auth.web.support.Admin
-import roomescape.auth.web.support.LoginRequired
-import roomescape.common.dto.response.CommonApiResponse
-import roomescape.time.web.TimeCreateRequest
-import roomescape.time.web.TimeCreateResponse
-import roomescape.time.web.TimeRetrieveListResponse
-import roomescape.time.web.TimeWithAvailabilityListResponse
-import java.time.LocalDate
-
-@Tag(name = "4. 예약 시간 API", description = "예약 시간을 조회 / 추가 / 삭제할 때 사용합니다.")
-interface TimeAPI {
-
-    @Admin
-    @Operation(summary = "모든 시간 조회", tags = ["관리자 로그인이 필요한 API"])
-    @ApiResponses(ApiResponse(responseCode = "200", description = "성공", useReturnTypeSchema = true))
-    fun findTimes(): ResponseEntity<CommonApiResponse<TimeRetrieveListResponse>>
-
-    @Admin
-    @Operation(summary = "시간 추가", tags = ["관리자 로그인이 필요한 API"])
-    @ApiResponses(ApiResponse(responseCode = "201", description = "성공", useReturnTypeSchema = true))
-    fun createTime(
-        @Valid @RequestBody timeCreateRequest: TimeCreateRequest,
-    ): ResponseEntity<CommonApiResponse<TimeCreateResponse>>
-
-    @Admin
-    @Operation(summary = "시간 삭제", tags = ["관리자 로그인이 필요한 API"])
-    @ApiResponses(ApiResponse(responseCode = "204", description = "성공", useReturnTypeSchema = true))
-    fun deleteTime(
-        @PathVariable id: Long
-    ): ResponseEntity<CommonApiResponse<Unit>>
-
-    @LoginRequired
-    @Operation(summary = "예약 가능 여부를 포함한 모든 시간 조회", tags = ["로그인이 필요한 API"])
-    @ApiResponses(ApiResponse(responseCode = "200", description = "성공", useReturnTypeSchema = true))
-    fun findTimesWithAvailability(
-        @RequestParam date: LocalDate,
-        @RequestParam themeId: Long
-    ): ResponseEntity<CommonApiResponse<TimeWithAvailabilityListResponse>>
-}
\ No newline at end of file
diff --git a/src/main/kotlin/roomescape/time/exception/TimeErrorCode.kt b/src/main/kotlin/roomescape/time/exception/TimeErrorCode.kt
deleted file mode 100644
index d115c326..00000000
--- a/src/main/kotlin/roomescape/time/exception/TimeErrorCode.kt
+++ /dev/null
@@ -1,14 +0,0 @@
-package roomescape.time.exception
-
-import org.springframework.http.HttpStatus
-import roomescape.common.exception.ErrorCode
-
-enum class TimeErrorCode(
-    override val httpStatus: HttpStatus,
-    override val errorCode: String,
-    override val message: String
-) : ErrorCode {
-    TIME_NOT_FOUND(HttpStatus.NOT_FOUND, "TM001", "시간을 찾을 수 없어요."),
-    TIME_DUPLICATED(HttpStatus.BAD_REQUEST, "TM002", "이미 같은 시간이 있어요."),
-    TIME_ALREADY_RESERVED(HttpStatus.CONFLICT, "TM003", "예약된 시간이라 삭제할 수 없어요.")
-}
diff --git a/src/main/kotlin/roomescape/time/exception/TimeException.kt b/src/main/kotlin/roomescape/time/exception/TimeException.kt
deleted file mode 100644
index 75b4a698..00000000
--- a/src/main/kotlin/roomescape/time/exception/TimeException.kt
+++ /dev/null
@@ -1,9 +0,0 @@
-package roomescape.time.exception
-
-import roomescape.common.exception.ErrorCode
-import roomescape.common.exception.RoomescapeException
-
-class TimeException(
-    override val errorCode: ErrorCode,
-    override val message: String = errorCode.message
-) : RoomescapeException(errorCode, message)
diff --git a/src/main/kotlin/roomescape/time/implement/TimeFinder.kt b/src/main/kotlin/roomescape/time/implement/TimeFinder.kt
deleted file mode 100644
index 60911a89..00000000
--- a/src/main/kotlin/roomescape/time/implement/TimeFinder.kt
+++ /dev/null
@@ -1,60 +0,0 @@
-package roomescape.time.implement
-
-import io.github.oshai.kotlinlogging.KLogger
-import io.github.oshai.kotlinlogging.KotlinLogging
-import org.springframework.data.repository.findByIdOrNull
-import org.springframework.stereotype.Component
-import roomescape.reservation.implement.ReservationFinder
-import roomescape.reservation.infrastructure.persistence.ReservationEntity
-import roomescape.time.business.domain.TimeWithAvailability
-import roomescape.theme.implement.ThemeFinder
-import roomescape.time.exception.TimeErrorCode
-import roomescape.time.exception.TimeException
-import roomescape.time.infrastructure.persistence.TimeEntity
-import roomescape.time.infrastructure.persistence.TimeRepository
-import java.time.LocalDate
-
-private val log: KLogger = KotlinLogging.logger {}
-
-@Component
-class TimeFinder(
-    private val timeRepository: TimeRepository,
-    private val reservationFinder: ReservationFinder,
-    private val themeFinder: ThemeFinder
-) {
-
-    fun findAll(): List<TimeEntity> {
-        log.debug { "[TimeFinder.findAll] 시작" }
-
-        return timeRepository.findAll()
-            .also { log.debug { "[TimeFinder.findAll] ${it.size}개 시간 조회 완료" } }
-    }
-
-    fun findById(id: Long): TimeEntity {
-        log.debug { "[TimeFinder.findById] 조회 시작: timeId=$id" }
-
-        return timeRepository.findByIdOrNull(id)
-            ?.also { log.debug { "[TimeFinder.findById] 조회 완료: timeId=$id, startAt=${it.startAt}" } }
-            ?: run {
-                log.warn { "[TimeFinder.findById] 조회 실패: timeId=$id" }
-                throw TimeException(TimeErrorCode.TIME_NOT_FOUND)
-            }
-    }
-
-    fun findAllWithAvailabilityByDateAndThemeId(
-        date: LocalDate, themeId: Long
-    ): List<TimeWithAvailability> {
-        log.debug { "[TimeFinder.findAllWithAvailabilityByDateAndThemeId] 조회 시작: date:$date, themeId=$themeId" }
-
-        val theme = themeFinder.findById(themeId)
-        val reservations: List<ReservationEntity> = reservationFinder.findAllByDateAndTheme(date, theme)
-        val allTimes: List<TimeEntity> = findAll()
-
-        return allTimes.map { time ->
-            val isReservable: Boolean = reservations.none { reservation -> time.id == reservation.time.id }
-            TimeWithAvailability(time.id!!, time.startAt, date, themeId, isReservable)
-        }.also {
-            log.debug { "[TimeFinder.findAllWithAvailabilityByDateAndThemeId] ${it.size}개 조회 완료: date:$date, themeId=$themeId" }
-        }
-    }
-}
diff --git a/src/main/kotlin/roomescape/time/implement/TimeValidator.kt b/src/main/kotlin/roomescape/time/implement/TimeValidator.kt
deleted file mode 100644
index ef0cee93..00000000
--- a/src/main/kotlin/roomescape/time/implement/TimeValidator.kt
+++ /dev/null
@@ -1,41 +0,0 @@
-package roomescape.time.implement
-
-import io.github.oshai.kotlinlogging.KLogger
-import io.github.oshai.kotlinlogging.KotlinLogging
-import org.springframework.stereotype.Component
-import roomescape.reservation.implement.ReservationFinder
-import roomescape.time.exception.TimeErrorCode
-import roomescape.time.exception.TimeException
-import roomescape.time.infrastructure.persistence.TimeEntity
-import roomescape.time.infrastructure.persistence.TimeRepository
-import java.time.LocalTime
-
-private val log: KLogger = KotlinLogging.logger {}
-
-@Component
-class TimeValidator(
-    private val timeRepository: TimeRepository,
-    private val reservationFinder: ReservationFinder
-) {
-    fun validateIsAlreadyExists(startAt: LocalTime) {
-        log.debug { "[TimeValidator.validateIsAlreadyExists] 시작: startAt=${startAt}" }
-
-        if (timeRepository.existsByStartAt(startAt)) {
-            log.info { "[TimeValidator.validateIsAlreadyExists] 중복 시간: startAt=$startAt" }
-            throw TimeException(TimeErrorCode.TIME_DUPLICATED)
-        }
-
-        log.debug { "[TimeValidator.validateIsAlreadyExists] 완료: startAt=${startAt}" }
-    }
-
-    fun validateIsReserved(time: TimeEntity) {
-        log.debug { "[TimeValidator.validateIsReserved] 시작: id=${time.id}, startAt=${time.startAt}" }
-
-        if (reservationFinder.isTimeReserved(time)) {
-            log.info { "[TimeValidator.validateIsReserved] 예약이 있는 시간: timeId=${time.id}, startAt=${time.startAt}" }
-            throw TimeException(TimeErrorCode.TIME_ALREADY_RESERVED)
-        }
-
-        log.debug { "[TimeValidator.validateIsReserved] 시작: id=${time.id}, startAt=${time.startAt}" }
-    }
-}
diff --git a/src/main/kotlin/roomescape/time/implement/TimeWriter.kt b/src/main/kotlin/roomescape/time/implement/TimeWriter.kt
deleted file mode 100644
index f1013697..00000000
--- a/src/main/kotlin/roomescape/time/implement/TimeWriter.kt
+++ /dev/null
@@ -1,37 +0,0 @@
-package roomescape.time.implement
-
-import com.github.f4b6a3.tsid.TsidFactory
-import io.github.oshai.kotlinlogging.KLogger
-import io.github.oshai.kotlinlogging.KotlinLogging
-import org.springframework.stereotype.Component
-import roomescape.common.config.next
-import roomescape.time.infrastructure.persistence.TimeEntity
-import roomescape.time.infrastructure.persistence.TimeRepository
-import java.time.LocalTime
-
-private val log: KLogger = KotlinLogging.logger {}
-
-@Component
-class TimeWriter(
-    private val timeValidator: TimeValidator,
-    private val timeRepository: TimeRepository,
-    private val tsidFactory: TsidFactory
-) {
-    fun create(startAt: LocalTime): TimeEntity {
-        log.debug { "[TimeWriter.create] 시작: startAt=$startAt" }
-        timeValidator.validateIsAlreadyExists(startAt)
-
-        val time = TimeEntity(_id = tsidFactory.next(), startAt = startAt)
-
-        return timeRepository.save(time)
-            .also { log.debug { "[TimeWriter.create] 완료: startAt=$startAt, id=${it.id}" } }
-    }
-
-    fun delete(time: TimeEntity) {
-        log.debug { "[TimeWriter.delete] 시작: id=${time.id}" }
-        timeValidator.validateIsReserved(time)
-
-        timeRepository.delete(time)
-            .also { log.debug { "[TimeWriter.delete] 완료: id=${time.id}, startAt=${time.startAt}" } }
-    }
-}
diff --git a/src/main/kotlin/roomescape/time/infrastructure/persistence/TimeEntity.kt b/src/main/kotlin/roomescape/time/infrastructure/persistence/TimeEntity.kt
deleted file mode 100644
index 3e31dd80..00000000
--- a/src/main/kotlin/roomescape/time/infrastructure/persistence/TimeEntity.kt
+++ /dev/null
@@ -1,21 +0,0 @@
-package roomescape.time.infrastructure.persistence
-
-import jakarta.persistence.Column
-import jakarta.persistence.Entity
-import jakarta.persistence.Id
-import jakarta.persistence.Table
-import roomescape.common.entity.BaseEntity
-import java.time.LocalTime
-
-@Entity
-@Table(name = "times")
-class TimeEntity(
-    @Id
-    @Column(name = "time_id")
-    private var _id: Long?,
-
-    @Column(name = "start_at", nullable = false)
-    var startAt: LocalTime,
-): BaseEntity() {
-    override fun getId(): Long? = _id
-}
diff --git a/src/main/kotlin/roomescape/time/infrastructure/persistence/TimeRepository.kt b/src/main/kotlin/roomescape/time/infrastructure/persistence/TimeRepository.kt
deleted file mode 100644
index 5e726669..00000000
--- a/src/main/kotlin/roomescape/time/infrastructure/persistence/TimeRepository.kt
+++ /dev/null
@@ -1,8 +0,0 @@
-package roomescape.time.infrastructure.persistence
-
-import org.springframework.data.jpa.repository.JpaRepository
-import java.time.LocalTime
-
-interface TimeRepository : JpaRepository<TimeEntity, Long> {
-    fun existsByStartAt(startAt: LocalTime): Boolean
-}
diff --git a/src/main/kotlin/roomescape/time/web/TimeController.kt b/src/main/kotlin/roomescape/time/web/TimeController.kt
deleted file mode 100644
index ad079568..00000000
--- a/src/main/kotlin/roomescape/time/web/TimeController.kt
+++ /dev/null
@@ -1,51 +0,0 @@
-package roomescape.time.web
-
-import jakarta.validation.Valid
-import org.springframework.http.ResponseEntity
-import org.springframework.web.bind.annotation.*
-import roomescape.common.dto.response.CommonApiResponse
-import roomescape.time.business.TimeService
-import roomescape.time.docs.TimeAPI
-import java.net.URI
-import java.time.LocalDate
-
-@RestController
-class TimeController(
-    private val timeService: TimeService
-) : TimeAPI {
-
-    @GetMapping("/times")
-    override fun findTimes(): ResponseEntity<CommonApiResponse<TimeRetrieveListResponse>> {
-        val response: TimeRetrieveListResponse = timeService.findTimes()
-
-        return ResponseEntity.ok(CommonApiResponse(response))
-    }
-
-    @PostMapping("/times")
-    override fun createTime(
-        @Valid @RequestBody timeCreateRequest: TimeCreateRequest,
-    ): ResponseEntity<CommonApiResponse<TimeCreateResponse>> {
-        val response: TimeCreateResponse = timeService.createTime(timeCreateRequest)
-
-        return ResponseEntity
-            .created(URI.create("/times/${response.id}"))
-            .body(CommonApiResponse(response))
-    }
-
-    @DeleteMapping("/times/{id}")
-    override fun deleteTime(@PathVariable id: Long): ResponseEntity<CommonApiResponse<Unit>> {
-        timeService.deleteTime(id)
-
-        return ResponseEntity.noContent().build()
-    }
-
-    @GetMapping("/times/search")
-    override fun findTimesWithAvailability(
-        @RequestParam date: LocalDate,
-        @RequestParam themeId: Long
-    ): ResponseEntity<CommonApiResponse<TimeWithAvailabilityListResponse>> {
-        val response: TimeWithAvailabilityListResponse = timeService.findTimesWithAvailability(date, themeId)
-
-        return ResponseEntity.ok(CommonApiResponse(response))
-    }
-}
diff --git a/src/main/kotlin/roomescape/time/web/TimeDTO.kt b/src/main/kotlin/roomescape/time/web/TimeDTO.kt
deleted file mode 100644
index 62ee965f..00000000
--- a/src/main/kotlin/roomescape/time/web/TimeDTO.kt
+++ /dev/null
@@ -1,55 +0,0 @@
-package roomescape.time.web
-
-import io.swagger.v3.oas.annotations.media.Schema
-import roomescape.time.infrastructure.persistence.TimeEntity
-import java.time.LocalTime
-
-@Schema(name = "예약 시간 저장 요청", description = "예약 시간 저장 요청시 사용됩니다.")
-data class TimeCreateRequest(
-    @Schema(description = "시간", type = "string", example = "09:00")
-    val startAt: LocalTime
-)
-
-@Schema(name = "예약 시간 정보", description = "예약 시간 추가 및 조회 응답시 사용됩니다.")
-data class TimeCreateResponse(
-    @Schema(description = "시간 식별자")
-    val id: Long,
-
-    @Schema(description = "시간")
-    val startAt: LocalTime
-)
-
-fun TimeEntity.toCreateResponse(): TimeCreateResponse = TimeCreateResponse(this.id!!, this.startAt)
-
-data class TimeRetrieveResponse(
-    @Schema(description = "시간 식별자.")
-    val id: Long,
-
-    @Schema(description = "시간")
-    val startAt: LocalTime
-)
-
-fun TimeEntity.toResponse(): TimeRetrieveResponse = TimeRetrieveResponse(this.id!!, this.startAt)
-
-data class TimeRetrieveListResponse(
-    val times: List<TimeRetrieveResponse>
-)
-
-fun List<TimeEntity>.toResponse(): TimeRetrieveListResponse = TimeRetrieveListResponse(
-    this.map { it.toResponse() }
-)
-
-data class TimeWithAvailabilityResponse(
-    @Schema(description = "시간 식별자")
-    val id: Long,
-
-    @Schema(description = "시간")
-    val startAt: LocalTime,
-
-    @Schema(description = "예약 가능 여부")
-    val isAvailable: Boolean
-)
-
-data class TimeWithAvailabilityListResponse(
-    val times: List<TimeWithAvailabilityResponse>
-)
diff --git a/src/main/resources/schema/schema-h2.sql b/src/main/resources/schema/schema-h2.sql
index e24c5f78..64c1439d 100644
--- a/src/main/resources/schema/schema-h2.sql
+++ b/src/main/resources/schema/schema-h2.sql
@@ -18,15 +18,6 @@ create table if not exists members (
     last_modified_at timestamp
 );
 
-create table if not exists themes (
-    theme_id         bigint       primary key,
-    description      varchar(255) not null,
-    name             varchar(255) not null,
-    thumbnail        varchar(255) not null,
-    created_at       timestamp,
-    last_modified_at timestamp
-);
-
 create table if not exists theme (
     id                     bigint       primary key ,
     name                   varchar(30)  not null,
@@ -66,55 +57,38 @@ create table if not exists schedule (
     constraint fk_schedule__theme_id foreign key (theme_id) references theme (id)
 );
 
-create table if not exists times (
-    time_id          bigint    primary key,
-    start_at         time      not null,
-    created_at       timestamp null,
-    last_modified_at timestamp null
+create table if not exists reservation (
+    id                  bigint        primary key,
+    member_id           bigint        not null,
+    schedule_id         bigint        not null,
+    reserver_name       varchar(30)   not null,
+    reserver_contact    varchar(30)   not null,
+    participant_count   smallint      not null,
+    requirement         varchar(255)  not null,
+    status              varchar(30)   not null,
+    created_at          timestamp     not null,
+    created_by          bigint        not null,
+    updated_at          timestamp     not null,
+    updated_by          bigint        not null,
+
+    constraint fk_reservation__member_id foreign key (member_id) references members (member_id),
+    constraint fk_reservation__schedule_id foreign key (schedule_id) references schedule (id)
 );
 
-create table if not exists reservations (
-    reservation_id     bigint      primary key,
-    date               date        not null,
-    member_id          bigint      not null,
-    theme_id           bigint      not null,
-    time_id            bigint      not null,
-    status             varchar(30) not null,
-    created_at         timestamp,
-    last_modified_at   timestamp,
+create table if not exists canceled_reservation (
+     id              bigint       primary key,
+     reservation_id  bigint       not null,
+     canceled_by     bigint       not null,
+     cancel_reason   varchar(50)  not null,
+     canceled_at     timestamp    not null,
+     status          varchar(30)  not null,
 
-    constraint fk_reservations__themeId foreign key (theme_id) references themes (theme_id),
-    constraint fk_reservations__memberId foreign key (member_id) references members (member_id),
-    constraint fk_reservations__timeId foreign key (time_id) references times (time_id)
+     constraint uk_canceled_reservations__reservation_id unique (reservation_id),
+     constraint fk_canceled_reservations__reservation_id foreign key (reservation_id) references reservation (id),
+     constraint fk_canceled_reservations__canceled_by    foreign key (canceled_by)    references members (member_id)
 );
 
-create table if not exists payments (
-    payment_id       bigint       primary key,
-    approved_at      timestamp    not null,
-    reservation_id   bigint       not null,
-    total_amount     bigint       not null,
-    order_id         varchar(255) not null,
-    payment_key      varchar(255) not null,
-    created_at       timestamp,
-    last_modified_at timestamp,
-
-    constraint uk_payments__reservationId unique (reservation_id),
-    constraint fk_payments__reservationId foreign key (reservation_id) references reservations (reservation_id)
-);
-
-create table if not exists canceled_payments (
-    canceled_payment_id bigint       primary key,
-    payment_key         varchar(255) not null,
-    cancel_reason       varchar(255) not null,
-    cancel_amount       bigint       not null,
-    approved_at         timestamp    not null,
-    canceled_at         timestamp    not null,
-
-    created_at          timestamp,
-    last_modified_at    timestamp
-);
-
-create table if not exists payment1 (
+create table if not exists payment (
     id              bigint       primary key,
     reservation_id  bigint       not null,
     type            varchar(20)  not null,
@@ -127,7 +101,7 @@ create table if not exists payment1 (
     approved_at     timestamp    not null,
 
     constraint uk_payment__reservationId unique (reservation_id),
-    constraint fk_payment__reservationId foreign key (reservation_id) references reservations (reservation_id)
+    constraint fk_payment__reservationId foreign key (reservation_id) references reservation (id)
 );
 
 create table if not exists payment_detail(
@@ -136,7 +110,7 @@ create table if not exists payment_detail(
     supplied_amount  integer    not null,
     vat              integer    not null,
 
-    constraint fk_payment_detail__paymentId foreign key (payment_id) references payment1 (id)
+    constraint fk_payment_detail__paymentId foreign key (payment_id) references payment (id)
 );
 
 create table if not exists payment_bank_transfer_detail (
@@ -172,7 +146,7 @@ create table if not exists payment_easypay_prepaid_detail(
     constraint fk_payment_easypay_prepaid_detail__id foreign key (id) references payment_detail (id)
 );
 
-create table if not exists canceled_payment1(
+create table if not exists canceled_payment(
     id                        bigint        primary key,
     payment_id                bigint        not null,
     requested_at              timestamp     not null,
@@ -184,7 +158,7 @@ create table if not exists canceled_payment1(
     transfer_discount_amount  integer       not null,
     easypay_discount_amount   integer       not null,
 
-    constraint uk_canceled_payment1__paymentId unique (payment_id),
-    constraint fk_canceled_payment__paymentId  foreign key (payment_id)  references payment1(id),
+    constraint uk_canceled_payment__paymentId unique (payment_id),
+    constraint fk_canceled_payment__paymentId  foreign key (payment_id)  references payment(id),
     constraint fk_canceled_payment__canceledBy foreign key (canceled_by) references members(member_id)
 );
diff --git a/src/main/resources/schema/schema-mysql.sql b/src/main/resources/schema/schema-mysql.sql
index 6e78453e..cae84864 100644
--- a/src/main/resources/schema/schema-mysql.sql
+++ b/src/main/resources/schema/schema-mysql.sql
@@ -19,16 +19,6 @@ create table if not exists members
     last_modified_at datetime(6)   null
 );
 
-create table if not exists themes
-(
-    theme_id         bigint       primary key,
-    description      varchar(255) not null,
-    name             varchar(255) not null,
-    thumbnail        varchar(255) not null,
-    created_at       datetime(6)  null,
-    last_modified_at datetime(6)  null
-);
-
 create table if not exists theme (
     id                     bigint       primary key ,
     name                   varchar(30)  not null,
@@ -68,57 +58,37 @@ create table if not exists schedule (
     constraint fk_schedule__theme_id foreign key (theme_id) references theme (id)
 );
 
-create table if not exists times
-(
-    time_id          bigint      primary key,
-    start_at         time(6)     not null,
-    created_at       datetime(6) null,
-    last_modified_at datetime(6) null
+create table if not exists reservation (
+    id                  bigint        primary key,
+    member_id           bigint        not null,
+    schedule_id         bigint        not null,
+    reserver_name       varchar(30)   not null,
+    reserver_contact    varchar(30)   not null,
+    participant_count   smallint      not null,
+    requirement         varchar(255)  not null,
+    status              varchar(30)   not null,
+    created_at          datetime(6)   not null,
+    created_by          bigint        not null,
+    updated_at          datetime(6)   not null,
+    updated_by          bigint        not null,
+
+    constraint fk_reservation__member_id foreign key (member_id) references members (member_id),
+    constraint fk_reservation__schedule_id foreign key (schedule_id) references schedule (id)
 );
 
-create table if not exists reservations
-(
-    reservation_id     bigint      primary key,
-    date               date        not null,
-    member_id          bigint      not null,
-    theme_id           bigint      not null,
-    time_id            bigint      not null,
-    status             varchar(30) not null,
-    created_at         datetime(6) null,
-    last_modified_at   datetime(6) null,
-    constraint fk_reservations__themeId foreign key (theme_id) references themes (theme_id),
-    constraint fk_reservations__memberId foreign key (member_id) references members (member_id),
-    constraint fk_reservations__timeId foreign key (time_id) references times (time_id)
+create table if not exists canceled_reservation (
+    id              bigint       primary key,
+    reservation_id  bigint       not null,
+    canceled_by     bigint       not null,
+    cancel_reason   varchar(50)  not null,
+    canceled_at     datetime(6)  not null,
+    status          varchar(30)  not null,
+    constraint uk_canceled_reservations__reservation_id unique (reservation_id),
+    constraint fk_canceled_reservations__reservation_id foreign key (reservation_id) references reservation (id),
+    constraint fk_canceled_reservations__canceled_by    foreign key (canceled_by)    references members (member_id)
 );
 
-create table if not exists payments
-(
-    payment_id       bigint       primary key,
-    approved_at      datetime(6)  not null,
-    reservation_id   bigint       not null,
-    total_amount     bigint       not null,
-    order_id         varchar(255) not null,
-    payment_key      varchar(255) not null,
-    created_at       datetime(6)  null,
-    last_modified_at datetime(6)  null,
-    constraint uk_payments__reservationId unique (reservation_id),
-    constraint fk_payments__reservationId foreign key (reservation_id) references reservations (reservation_id)
-);
-
-create table if not exists canceled_payments
-(
-    canceled_payment_id bigint       primary key,
-    payment_key         varchar(255) not null,
-    cancel_reason       varchar(255) not null,
-    cancel_amount       bigint       not null,
-    approved_at         datetime(6)  not null,
-    canceled_at         datetime(6)  not null,
-    created_at          datetime(6)  null,
-    last_modified_at    datetime(6)  null
-);
-
-
-create table if not exists payment1
+create table if not exists payment
 (
     id              bigint       primary key,
     reservation_id  bigint       not null,
@@ -142,7 +112,7 @@ create table if not exists payment_detail
     supplied_amount  integer    not null,
     vat              integer    not null,
 
-    constraint fk_payment_detail__paymentId foreign key (payment_id) references payment1 (id)
+    constraint fk_payment_detail__paymentId foreign key (payment_id) references payment (id)
 );
 
 create table if not exists payment_bank_transfer_detail
@@ -181,7 +151,7 @@ create table if not exists payment_easypay_prepaid_detail
     constraint fk_payment_easypay_prepaid_detail__id foreign key (id) references payment_detail (id)
 );
 
-create table if not exists canceled_payment1
+create table if not exists canceled_payment
 (
     id                        bigint        primary key,
     payment_id                bigint        not null,
@@ -194,7 +164,7 @@ create table if not exists canceled_payment1
     transfer_discount_amount  integer       not null,
     easypay_discount_amount   integer       not null,
 
-    constraint uk_canceled_payment1__paymentId unique (payment_id),
-    constraint fk_canceled_payment__paymentId  foreign key (payment_id)  references payment1(id),
+    constraint uk_canceled_payment__paymentId unique (payment_id),
+    constraint fk_canceled_payment__paymentId  foreign key (payment_id)  references payment(id),
     constraint fk_canceled_payment__canceledBy foreign key (canceled_by) references members(member_id)
 );
diff --git a/src/test/kotlin/roomescape/auth/business/AuthServiceTest.kt b/src/test/kotlin/roomescape/auth/business/AuthServiceTest.kt
deleted file mode 100644
index 8609ba3e..00000000
--- a/src/test/kotlin/roomescape/auth/business/AuthServiceTest.kt
+++ /dev/null
@@ -1,82 +0,0 @@
-package roomescape.auth.business
-
-import io.kotest.assertions.assertSoftly
-import io.kotest.assertions.throwables.shouldThrow
-import io.kotest.core.spec.style.BehaviorSpec
-import io.kotest.matchers.shouldBe
-import io.mockk.every
-import io.mockk.mockk
-import roomescape.auth.exception.AuthErrorCode
-import roomescape.auth.exception.AuthException
-import roomescape.auth.infrastructure.jwt.JwtHandler
-import roomescape.member.exception.MemberErrorCode
-import roomescape.member.exception.MemberException
-import roomescape.member.implement.MemberFinder
-import roomescape.member.infrastructure.persistence.MemberEntity
-import roomescape.util.JwtFixture
-import roomescape.util.MemberFixture
-
-class AuthServiceTest : BehaviorSpec({
-    val memberFinder: MemberFinder = mockk()
-    val jwtHandler: JwtHandler = JwtFixture.create()
-
-    val authService = AuthService(memberFinder, jwtHandler)
-    val user: MemberEntity = MemberFixture.user()
-
-    Given("로그인 요청을 받으면") {
-        When("이메일과 비밀번호로 회원을 찾고") {
-            val request = MemberFixture.userLoginRequest()
-
-            Then("회원이 있다면 JWT 토큰을 생성한 뒤 반환한다.") {
-                every {
-                    memberFinder.findByEmailAndPassword(request.email, request.password)
-                } returns user
-
-                val accessToken: String = authService.login(request).accessToken
-
-                accessToken.isNotBlank() shouldBe true
-                jwtHandler.getMemberIdFromToken(accessToken) shouldBe user.id
-            }
-
-            Then("회원이 없다면 예외를 던진다.") {
-                every {
-                    memberFinder.findByEmailAndPassword(request.email, request.password)
-                } throws MemberException(MemberErrorCode.MEMBER_NOT_FOUND)
-
-                val exception = shouldThrow<AuthException> {
-                    authService.login(request)
-                }
-
-                exception.errorCode shouldBe AuthErrorCode.LOGIN_FAILED
-            }
-        }
-    }
-
-    Given("로그인 확인 요청을 받으면") {
-        When("회원 ID로 회원을 찾고") {
-            val userId: Long = user.id!!
-
-            Then("회원이 있다면 회원의 이름을 반환한다.") {
-                every { memberFinder.findById(userId) } returns user
-
-                val response = authService.checkLogin(userId)
-
-                assertSoftly(response) {
-                    this.name shouldBe user.name
-                }
-            }
-
-            Then("회원이 없다면 예외를 던진다.") {
-                every {
-                    memberFinder.findById(userId)
-                } throws MemberException(MemberErrorCode.MEMBER_NOT_FOUND)
-
-                val exception = shouldThrow<AuthException> {
-                    authService.checkLogin(userId)
-                }
-
-                exception.errorCode shouldBe AuthErrorCode.MEMBER_NOT_FOUND
-            }
-        }
-    }
-})
diff --git a/src/test/kotlin/roomescape/auth/infrastructure/jwt/JwtHandlerTest.kt b/src/test/kotlin/roomescape/auth/infrastructure/jwt/JwtHandlerTest.kt
deleted file mode 100644
index 9d9c91bc..00000000
--- a/src/test/kotlin/roomescape/auth/infrastructure/jwt/JwtHandlerTest.kt
+++ /dev/null
@@ -1,59 +0,0 @@
-package roomescape.auth.infrastructure.jwt
-
-import io.jsonwebtoken.Jwts
-import io.jsonwebtoken.security.Keys
-import io.kotest.assertions.throwables.shouldThrow
-import io.kotest.core.spec.style.FunSpec
-import io.kotest.matchers.shouldBe
-import roomescape.auth.exception.AuthErrorCode
-import roomescape.auth.exception.AuthException
-import roomescape.util.JwtFixture
-import java.util.*
-import kotlin.random.Random
-
-class JwtHandlerTest : FunSpec({
-
-    context("JWT 토큰 조회") {
-        val memberId = Random.nextLong()
-        val jwtHandler: JwtHandler = JwtFixture.create()
-
-        test("토큰에서 멤버 ID를 올바르게 추출한다.") {
-            val token = jwtHandler.createToken(memberId)
-            val extractedMemberId = jwtHandler.getMemberIdFromToken(token)
-
-            extractedMemberId shouldBe memberId
-        }
-
-        test("만료된 토큰이면 예외를 던진다.") {
-            val expirationTime = 0L
-            val shortExpirationTimeJwtHandler: JwtHandler = JwtFixture.create(expirationTime = expirationTime)
-            val token = shortExpirationTimeJwtHandler.createToken(memberId)
-
-            Thread.sleep(expirationTime) // 만료 시간 이후로 대기
-
-            shouldThrow<AuthException> {
-                shortExpirationTimeJwtHandler.getMemberIdFromToken(token)
-            }.errorCode shouldBe AuthErrorCode.EXPIRED_TOKEN
-        }
-
-        test("토큰이 빈 값이면 예외를 던진다.") {
-            shouldThrow<AuthException> {
-                jwtHandler.getMemberIdFromToken("")
-            }.errorCode shouldBe AuthErrorCode.TOKEN_NOT_FOUND
-        }
-
-        test("시크릿 키가 잘못된 경우 예외를 던진다.") {
-            val now = Date()
-            val invalidSignatureToken: String = Jwts.builder()
-                .claim("memberId", memberId)
-                .issuedAt(now)
-                .expiration(Date(now.time + JwtFixture.EXPIRATION_TIME))
-                .signWith(Keys.hmacShaKeyFor(JwtFixture.SECRET_KEY_STRING.substring(1).toByteArray()))
-                .compact()
-
-            shouldThrow<AuthException> {
-                jwtHandler.getMemberIdFromToken(invalidSignatureToken)
-            }.errorCode shouldBe AuthErrorCode.INVALID_TOKEN
-        }
-    }
-})
diff --git a/src/test/kotlin/roomescape/auth/web/AuthControllerTest.kt b/src/test/kotlin/roomescape/auth/web/AuthControllerTest.kt
deleted file mode 100644
index aed2ee55..00000000
--- a/src/test/kotlin/roomescape/auth/web/AuthControllerTest.kt
+++ /dev/null
@@ -1,151 +0,0 @@
-package roomescape.auth.web
-
-import com.ninjasquad.springmockk.MockkBean
-import io.mockk.Runs
-import io.mockk.every
-import io.mockk.just
-import org.hamcrest.Matchers.equalTo
-import org.springframework.boot.test.autoconfigure.web.servlet.WebMvcTest
-import org.springframework.test.web.servlet.MockMvc
-import roomescape.auth.business.AuthService
-import roomescape.auth.exception.AuthErrorCode
-import roomescape.auth.exception.AuthException
-import roomescape.common.exception.CommonErrorCode
-import roomescape.common.exception.ErrorCode
-import roomescape.util.MemberFixture
-import roomescape.util.RoomescapeApiTest
-
-@WebMvcTest(controllers = [AuthController::class])
-class AuthControllerTest(val mockMvc: MockMvc) : RoomescapeApiTest() {
-
-    @MockkBean
-    private lateinit var authService: AuthService
-
-    val userRequest: LoginRequest = MemberFixture.userLoginRequest()
-
-    init {
-        Given("로그인 요청을 보낼 때") {
-            val endpoint = "/login"
-
-            When("로그인에 성공하면") {
-                val expectedToken = "expectedToken"
-
-                every {
-                    authService.login(userRequest)
-                } returns LoginResponse(expectedToken)
-
-                Then("토큰을 반환한다.") {
-                    runPostTest(
-                        mockMvc = mockMvc,
-                        endpoint = endpoint,
-                        body = userRequest,
-                    ) {
-                        status { isOk() }
-                        jsonPath("$.data.accessToken", equalTo(expectedToken))
-                    }
-                }
-            }
-
-            When("회원을 찾지 못하면") {
-                val expectedError = AuthErrorCode.LOGIN_FAILED
-
-                every {
-                    authService.login(userRequest)
-                } throws AuthException(expectedError)
-
-                Then("에러 응답을 받는다.") {
-                    runPostTest(
-                        mockMvc = mockMvc,
-                        endpoint = endpoint,
-                        body = userRequest,
-                    ) {
-                        status { isEqualTo(expectedError.httpStatus.value()) }
-                        jsonPath("$.code", equalTo(expectedError.errorCode))
-                    }
-                }
-            }
-
-            When("입력 값이 잘못되면") {
-                val expectedErrorCode: ErrorCode = CommonErrorCode.INVALID_INPUT_VALUE
-
-                Then("400 에러를 응답한다") {
-                    listOf(
-                        userRequest.copy(email = "invalid"),
-                        userRequest.copy(password = " "),
-                        "{\"email\": \"null\", \"password\": \"null\"}"
-                    ).forEach {
-                        runPostTest(
-                            mockMvc = mockMvc,
-                            endpoint = endpoint,
-                            body = it,
-                        ) {
-                            status { isEqualTo(expectedErrorCode.httpStatus.value()) }
-                            jsonPath("$.code", equalTo(expectedErrorCode.errorCode))
-                        }
-                    }
-                }
-            }
-        }
-
-        Given("로그인 상태를 확인할 때") {
-            val endpoint = "/login/check"
-
-            When("로그인된 회원의 ID로 요청하면") {
-                loginAsUser()
-
-                Then("회원의 이름과 권한을 응답한다") {
-                    every {
-                        authService.checkLogin(user.id!!)
-                    } returns LoginCheckResponse(user.name, user.role.name)
-
-                    runGetTest(
-                        mockMvc = mockMvc,
-                        endpoint = endpoint,
-                    ) {
-                        status { isOk() }
-                        jsonPath("$.data.name", equalTo(user.name))
-                        jsonPath("$.data.role", equalTo(user.role.name))
-                    }
-                }
-            }
-
-            When("토큰은 있지만 회원을 찾을 수 없으면") {
-                val invalidMemberId: Long = -1L
-                val expectedError = AuthErrorCode.MEMBER_NOT_FOUND
-
-                every { jwtHandler.getMemberIdFromToken(any()) } returns invalidMemberId
-                every { authService.checkLogin(invalidMemberId) } throws AuthException(expectedError)
-
-                Then("에러 응답을 받는다.") {
-                    runGetTest(
-                        mockMvc = mockMvc,
-                        endpoint = endpoint,
-                    ) {
-                        status { isEqualTo(expectedError.httpStatus.value()) }
-                        jsonPath("$.code", equalTo(expectedError.errorCode))
-                    }
-                }
-            }
-        }
-        Given("로그아웃 요청을 보낼 때") {
-            val endpoint = "/logout"
-
-            When("토큰으로 memberId 조회가 가능하면") {
-                loginAsUser()
-
-                every {
-                    authService.logout(user.id!!)
-                } just Runs
-
-                Then("정상 응답한다.") {
-                    runPostTest(
-                        mockMvc = mockMvc,
-                        endpoint = endpoint,
-                    ) {
-                        status { isNoContent() }
-                    }
-                }
-            }
-        }
-    }
-}
diff --git a/src/test/kotlin/roomescape/auth/web/support/CookieUtilsTest.kt b/src/test/kotlin/roomescape/auth/web/support/CookieUtilsTest.kt
deleted file mode 100644
index 2ec94157..00000000
--- a/src/test/kotlin/roomescape/auth/web/support/CookieUtilsTest.kt
+++ /dev/null
@@ -1,26 +0,0 @@
-package roomescape.auth.web.support
-
-import io.kotest.core.spec.style.FunSpec
-import io.kotest.matchers.shouldBe
-import io.mockk.every
-import io.mockk.mockk
-import jakarta.servlet.http.HttpServletRequest
-
-class CookieUtilsTest : FunSpec({
-    context("accessToken 쿠키를 가져온다.") {
-        val httpServletRequest: HttpServletRequest = mockk()
-
-        test("accessToken이 있으면 해당 쿠키를 반환한다.") {
-            val token = "test-token"
-            every { httpServletRequest.getHeader("Authorization") } returns "Bearer $token"
-
-            httpServletRequest.accessToken() shouldBe token
-        }
-
-        test("accessToken이 없으면 null을 반환한다.") {
-            every { httpServletRequest.getHeader("Authorization") } returns null
-
-            httpServletRequest.accessToken() shouldBe null
-        }
-    }
-})
diff --git a/src/test/kotlin/roomescape/common/config/JacksonConfigTest.kt b/src/test/kotlin/roomescape/common/config/JacksonConfigTest.kt
index 1f6e5305..c4129dc2 100644
--- a/src/test/kotlin/roomescape/common/config/JacksonConfigTest.kt
+++ b/src/test/kotlin/roomescape/common/config/JacksonConfigTest.kt
@@ -6,11 +6,7 @@ import io.kotest.assertions.throwables.shouldThrow
 import io.kotest.core.spec.style.FunSpec
 import io.kotest.matchers.shouldBe
 import io.kotest.matchers.string.shouldContain
-import java.time.LocalDate
-import java.time.LocalDateTime
-import java.time.LocalTime
-import java.time.OffsetDateTime
-import java.time.ZoneOffset
+import java.time.*
 
 class JacksonConfigTest(
     private val objectMapper: ObjectMapper = JacksonConfig().objectMapper()
diff --git a/src/test/kotlin/roomescape/common/log/ApiLogMessageConverterTest.kt b/src/test/kotlin/roomescape/common/log/ApiLogMessageConverterTest.kt
index 62eea129..451c1598 100644
--- a/src/test/kotlin/roomescape/common/log/ApiLogMessageConverterTest.kt
+++ b/src/test/kotlin/roomescape/common/log/ApiLogMessageConverterTest.kt
@@ -1,7 +1,6 @@
 package roomescape.common.log
 
 import com.fasterxml.jackson.module.kotlin.jacksonObjectMapper
-import io.kotest.core.spec.style.FunSpec
 import io.kotest.core.spec.style.StringSpec
 import io.kotest.matchers.shouldBe
 import io.mockk.every
@@ -45,19 +44,25 @@ class ApiLogMessageConverterTest : StringSpec({
         val requestURI = "/test/sangdol".also { every { request.requestURI } returns it }
 
         converter.convertToControllerInvokedMessage(request, controllerPayload) shouldBe """
-            {"type":"CONTROLLER_INVOKED","method":"$method","uri":"$requestURI","member_id":1,"controller_method":"${controllerPayload.get("controller_method")}","request_body":{"key1":"value1"}}
+            {"type":"CONTROLLER_INVOKED","method":"$method","uri":"$requestURI","member_id":1,"controller_method":"${
+            controllerPayload.get(
+                "controller_method"
+            )
+        }","request_body":{"key1":"value1"}}
         """.trimIndent()
     }
 
     "Controller 응답 메시지를 반환한다." {
+        val endpoint = "POST /test/sangdol"
         val request = ConvertResponseMessageRequest(
             type = LogType.CONTROLLER_SUCCESS,
+            endpoint = endpoint,
             httpStatus = 200,
             exception = AuthException(AuthErrorCode.MEMBER_NOT_FOUND, "테스트 메시지!")
         )
 
         converter.convertToResponseMessage(request) shouldBe """
-            {"type":"CONTROLLER_SUCCESS","status_code":200,"member_id":1,"exception":{"class":"AuthException","message":"테스트 메시지!"}}
+            {"type":"CONTROLLER_SUCCESS","endpoint":"$endpoint","status_code":200,"member_id":1,"exception":{"class":"AuthException","message":"테스트 메시지!"}}
         """.trimIndent()
     }
 })
diff --git a/src/test/kotlin/roomescape/member/business/MemberServiceTest.kt b/src/test/kotlin/roomescape/member/business/MemberServiceTest.kt
deleted file mode 100644
index db82fc0b..00000000
--- a/src/test/kotlin/roomescape/member/business/MemberServiceTest.kt
+++ /dev/null
@@ -1,100 +0,0 @@
-package roomescape.member.business
-
-import io.kotest.assertions.assertSoftly
-import io.kotest.assertions.throwables.shouldThrow
-import io.kotest.core.spec.style.FunSpec
-import io.kotest.matchers.collections.shouldContainExactly
-import io.kotest.matchers.collections.shouldHaveSize
-import io.kotest.matchers.shouldBe
-import io.mockk.every
-import io.mockk.mockk
-import roomescape.member.exception.MemberErrorCode
-import roomescape.member.exception.MemberException
-import roomescape.member.implement.MemberFinder
-import roomescape.member.implement.MemberWriter
-import roomescape.member.infrastructure.persistence.MemberEntity
-import roomescape.member.infrastructure.persistence.Role
-import roomescape.member.web.SignupRequest
-import roomescape.util.MemberFixture
-
-class MemberServiceTest : FunSpec({
-    val memberWriter: MemberWriter = mockk()
-    val memberFinder: MemberFinder = mockk()
-
-    val memberService = MemberService(memberWriter, memberFinder)
-
-    context("findMembers") {
-        test("정상 응답") {
-            val members: List<MemberEntity> = listOf(
-                MemberFixture.create(name = "user1"),
-                MemberFixture.create(name = "user2"),
-            )
-
-            every { memberFinder.findAll() } returns members
-
-            val response = memberService.findMembers()
-
-            // then
-            assertSoftly(response.members) {
-                it shouldHaveSize 2
-                it.map { member -> member.name } shouldContainExactly listOf("user1", "user2")
-            }
-        }
-    }
-
-    context("findById") {
-        val id = 1L
-
-        test("정상 응답") {
-            every {
-                memberFinder.findById(id)
-            } returns MemberFixture.create(id = id)
-
-            memberService.findById(id).id shouldBe id
-        }
-
-        test("회원을 찾을 수 없으면 예외 응답") {
-            every {
-                memberFinder.findById(id)
-            } throws MemberException(MemberErrorCode.MEMBER_NOT_FOUND)
-
-            shouldThrow<MemberException> {
-                memberService.findById(id)
-            }.also {
-                it.errorCode shouldBe MemberErrorCode.MEMBER_NOT_FOUND
-            }
-        }
-    }
-
-    context("createMember") {
-        val request = SignupRequest(name = "new-user", email = "new@test.com", password = "password")
-
-        test("정상 저장") {
-            val member = MemberFixture.create(
-                name = request.name,
-                account = request.email,
-                password = request.password
-            )
-
-            every {
-                memberWriter.create(request.name, request.email, request.password, Role.MEMBER)
-            } returns member
-
-            val response = memberService.createMember(request)
-
-            response.id shouldBe member.id
-        }
-
-        test("중복된 이메일이 있으면 예외 응답") {
-            every {
-                memberWriter.create(request.name, request.email, request.password, Role.MEMBER)
-            } throws MemberException(MemberErrorCode.DUPLICATE_EMAIL)
-
-            shouldThrow<MemberException> {
-                memberService.createMember(request)
-            }.also {
-                it.errorCode shouldBe MemberErrorCode.DUPLICATE_EMAIL
-            }
-        }
-    }
-})
diff --git a/src/test/kotlin/roomescape/member/controller/MemberControllerTest.kt b/src/test/kotlin/roomescape/member/controller/MemberControllerTest.kt
deleted file mode 100644
index 5f3a9dc1..00000000
--- a/src/test/kotlin/roomescape/member/controller/MemberControllerTest.kt
+++ /dev/null
@@ -1,136 +0,0 @@
-package roomescape.member.controller
-
-import com.ninjasquad.springmockk.MockkBean
-import io.kotest.assertions.assertSoftly
-import io.kotest.matchers.collections.shouldContainAll
-import io.kotest.matchers.shouldBe
-import io.mockk.every
-import org.springframework.boot.test.autoconfigure.web.servlet.WebMvcTest
-import org.springframework.test.web.servlet.MockMvc
-import roomescape.auth.exception.AuthErrorCode
-import roomescape.member.business.MemberService
-import roomescape.member.exception.MemberErrorCode
-import roomescape.member.exception.MemberException
-import roomescape.member.infrastructure.persistence.Role
-import roomescape.member.web.*
-import roomescape.util.MemberFixture
-import roomescape.util.RoomescapeApiTest
-import kotlin.random.Random
-
-@WebMvcTest(controllers = [MemberController::class])
-class MemberControllerTest(val mockMvc: MockMvc) : RoomescapeApiTest() {
-    @MockkBean
-    private lateinit var memberService: MemberService
-
-    init {
-        given("GET /members 요청을") {
-            val endpoint = "/members"
-            val response = listOf(
-                MemberFixture.create(id = Random.nextLong(), name = "name1"),
-                MemberFixture.create(id = Random.nextLong(), name = "name2"),
-                MemberFixture.create(id = Random.nextLong(), name = "name3"),
-            ).toRetrieveListResponse()
-
-            every { memberService.findMembers() } returns response
-
-            `when`("관리자가 보내면") {
-                loginAsAdmin()
-
-                then("성공한다.") {
-                    val result: MemberRetrieveListResponse = runGetTest(
-                        mockMvc = mockMvc,
-                        endpoint = endpoint,
-                    ) {
-                        status { isOk() }
-                    }.andReturn().readValue(MemberRetrieveListResponse::class.java)
-
-
-                    assertSoftly(result.members) {
-                        it.size shouldBe response.members.size
-                        it.map { m -> m.name } shouldContainAll response.members.map { m -> m.name }
-                    }
-                }
-            }
-
-            `when`("관리자가 아니면 에러 응답을 받는다.") {
-                then("비회원") {
-                    doNotLogin()
-                    val expectedError = AuthErrorCode.MEMBER_NOT_FOUND
-
-                    runGetTest(
-                        mockMvc = mockMvc,
-                        endpoint = endpoint,
-                    ) {
-                        status { isEqualTo(expectedError.httpStatus.value()) }
-                    }.andExpect {
-                        jsonPath("$.code") { value(expectedError.errorCode) }
-                    }
-                }
-
-                then("일반 회원") {
-                    loginAsUser()
-                    val expectedError = AuthErrorCode.ACCESS_DENIED
-
-                    runGetTest(
-                        mockMvc = mockMvc,
-                        endpoint = endpoint,
-                    ) {
-                        status { isEqualTo(expectedError.httpStatus.value()) }
-                    }.andExpect {
-                        jsonPath("$.code") { value(expectedError.errorCode) }
-                    }
-                }
-            }
-        }
-
-        given("POST /members") {
-            val endpoint = "/members"
-            val request = SignupRequest(
-                name = "name",
-                email = "email@email.com",
-                password = "password"
-            )
-            `when`("같은 이메일이 없으면") {
-                every {
-                    memberService.createMember(request)
-                } returns MemberFixture.create(
-                    id = 1,
-                    name = request.name,
-                    account = request.email,
-                    password = request.password,
-                    role = Role.MEMBER
-                ).toSignupResponse()
-
-                then("id과 이름을 담아 성공 응답") {
-                    runPostTest(
-                        mockMvc = mockMvc,
-                        endpoint = endpoint,
-                        body = request
-                    ) {
-                        status { isCreated() }
-                        jsonPath("$.data.name") { value(request.name) }
-                        jsonPath("$.data.id") { value(1) }
-                    }
-                }
-            }
-
-            `when`("같은 이메일이 있으면") {
-                val expectedError = MemberErrorCode.DUPLICATE_EMAIL
-                every {
-                    memberService.createMember(request)
-                } throws MemberException(expectedError)
-
-                then("에러 응답") {
-                    runPostTest(
-                        mockMvc = mockMvc,
-                        endpoint = endpoint,
-                        body = request
-                    ) {
-                        status { isEqualTo(expectedError.httpStatus.value()) }
-                        jsonPath("$.code") { value(expectedError.errorCode) }
-                    }
-                }
-            }
-        }
-    }
-}
diff --git a/src/test/kotlin/roomescape/member/implement/MemberFinderTest.kt b/src/test/kotlin/roomescape/member/implement/MemberFinderTest.kt
deleted file mode 100644
index e1be29f7..00000000
--- a/src/test/kotlin/roomescape/member/implement/MemberFinderTest.kt
+++ /dev/null
@@ -1,85 +0,0 @@
-package roomescape.member.implement
-
-import io.kotest.assertions.throwables.shouldThrow
-import io.kotest.core.spec.style.FunSpec
-import io.kotest.matchers.collections.shouldHaveSize
-import io.kotest.matchers.shouldBe
-import io.mockk.every
-import io.mockk.mockk
-import io.mockk.verify
-import org.springframework.data.repository.findByIdOrNull
-import roomescape.member.exception.MemberErrorCode
-import roomescape.member.exception.MemberException
-import roomescape.member.infrastructure.persistence.MemberRepository
-
-class MemberFinderTest : FunSpec({
-
-    val memberRepository: MemberRepository = mockk()
-    val memberFinder = MemberFinder(memberRepository)
-
-    context("findAll") {
-        test("모든 회원을 조회한다.") {
-            every {
-                memberRepository.findAll()
-            } returns listOf(mockk(), mockk(), mockk())
-
-            memberFinder.findAll() shouldHaveSize 3
-        }
-    }
-
-    context("findById") {
-        val memberId = 1L
-        test("동일한 ID인 회원을 찾아 응답한다.") {
-            every {
-                memberRepository.findByIdOrNull(memberId)
-            } returns mockk()
-
-            memberFinder.findById(memberId)
-
-            verify(exactly = 1) {
-                memberRepository.findByIdOrNull(memberId)
-            }
-        }
-
-        test("동일한 ID인 회원이 없으면 실패한다.") {
-            every {
-                memberRepository.findByIdOrNull(memberId)
-            } returns null
-
-            shouldThrow<MemberException> {
-                memberFinder.findById(memberId)
-            }.also {
-                it.errorCode shouldBe MemberErrorCode.MEMBER_NOT_FOUND
-            }
-        }
-    }
-
-    context("findByEmailAndPassword") {
-        val email = "email"
-        val password = "password"
-
-        test("동일한 이메일과 비밀번호를 가진 회원을 찾아 응답한다.") {
-            every {
-                memberRepository.findByEmailAndPassword(email, password)
-            } returns mockk()
-
-            memberFinder.findByEmailAndPassword(email, password)
-
-            verify(exactly = 1) {
-                memberRepository.findByEmailAndPassword(email, password)
-            }
-        }
-
-        test("동일한 이메일과 비밀번호를 가진 회원이 없으면 실패한다.") {
-            every {
-                memberRepository.findByEmailAndPassword(email, password)
-            } returns null
-
-            shouldThrow<MemberException> {
-                memberFinder.findByEmailAndPassword(email, password)
-            }.also {
-                it.errorCode shouldBe MemberErrorCode.MEMBER_NOT_FOUND
-            }
-        }
-    }
-})
diff --git a/src/test/kotlin/roomescape/member/implement/MemberValidatorTest.kt b/src/test/kotlin/roomescape/member/implement/MemberValidatorTest.kt
deleted file mode 100644
index ade55e4b..00000000
--- a/src/test/kotlin/roomescape/member/implement/MemberValidatorTest.kt
+++ /dev/null
@@ -1,44 +0,0 @@
-package roomescape.member.implement
-
-import io.kotest.assertions.throwables.shouldNotThrow
-import io.kotest.assertions.throwables.shouldThrow
-import io.kotest.core.spec.style.FunSpec
-import io.kotest.core.spec.style.StringSpec
-import io.kotest.matchers.shouldBe
-import io.mockk.every
-import io.mockk.mockk
-import roomescape.member.exception.MemberErrorCode
-import roomescape.member.exception.MemberException
-import roomescape.member.infrastructure.persistence.MemberRepository
-
-class MemberValidatorTest : FunSpec({
-
-    val memberRepository: MemberRepository = mockk()
-    val memberValidator = MemberValidator(memberRepository)
-
-    context("validateCanSignup") {
-        val email = "email@email.com"
-
-        test("같은 이메일을 가진 회원이 있으면 예외를 던진다.") {
-            every {
-                memberRepository.existsByEmail(email)
-            } returns true
-
-            shouldThrow<MemberException> {
-                memberValidator.validateCanSignup(email)
-            }.also {
-                it.errorCode shouldBe MemberErrorCode.DUPLICATE_EMAIL
-            }
-        }
-
-        test("같은 이메일을 가진 회원이 없으면 종료한다.") {
-            every {
-                memberRepository.existsByEmail(email)
-            } returns false
-
-            shouldNotThrow<MemberException> {
-                memberValidator.validateCanSignup(email)
-            }
-        }
-    }
-})
diff --git a/src/test/kotlin/roomescape/member/implement/MemberWriterTest.kt b/src/test/kotlin/roomescape/member/implement/MemberWriterTest.kt
deleted file mode 100644
index 16e09201..00000000
--- a/src/test/kotlin/roomescape/member/implement/MemberWriterTest.kt
+++ /dev/null
@@ -1,65 +0,0 @@
-package roomescape.member.implement
-
-import io.kotest.assertions.throwables.shouldThrow
-import io.kotest.core.spec.style.FunSpec
-import io.kotest.core.spec.style.StringSpec
-import io.kotest.matchers.nulls.shouldNotBeNull
-import io.kotest.matchers.shouldBe
-import io.mockk.every
-import io.mockk.mockk
-import io.mockk.slot
-import io.mockk.spyk
-import io.mockk.verify
-import roomescape.member.exception.MemberErrorCode
-import roomescape.member.exception.MemberException
-import roomescape.member.infrastructure.persistence.MemberEntity
-import roomescape.member.infrastructure.persistence.MemberRepository
-import roomescape.member.infrastructure.persistence.Role
-import roomescape.util.MemberFixture
-import roomescape.util.TsidFactory
-
-class MemberWriterTest : FunSpec({
-    val memberRepository: MemberRepository = mockk()
-    val memberValidator = MemberValidator(memberRepository)
-    val memberWriter = MemberWriter(TsidFactory, memberValidator, memberRepository)
-
-    context("create") {
-        val name = "name"
-        val email = "email"
-        val password = "password"
-        val role = Role.MEMBER
-
-        test("중복된 이메일이 있으면 실패한다.") {
-            every {
-                memberRepository.existsByEmail(any())
-            } returns true
-
-            shouldThrow<MemberException> {
-                memberWriter.create(name, email, password, role)
-            }.also {
-                it.errorCode shouldBe MemberErrorCode.DUPLICATE_EMAIL
-            }
-        }
-
-        test("중복된 이메일이 없으면 저장한다.") {
-            every {
-                memberRepository.existsByEmail(any())
-            } returns false
-
-            every {
-                memberRepository.save(any())
-            } returns MemberFixture.create(
-                name = name,
-                account = email,
-                password = password,
-                role = role
-            )
-
-            memberWriter.create(name, email, password, role)
-
-            verify(exactly = 1) {
-                memberRepository.save(any())
-            }
-        }
-    }
-})
diff --git a/src/test/kotlin/roomescape/member/infrastructure/persistence/MemberRepositoryTest.kt b/src/test/kotlin/roomescape/member/infrastructure/persistence/MemberRepositoryTest.kt
deleted file mode 100644
index d5af4d07..00000000
--- a/src/test/kotlin/roomescape/member/infrastructure/persistence/MemberRepositoryTest.kt
+++ /dev/null
@@ -1,63 +0,0 @@
-package roomescape.member.infrastructure.persistence
-
-import io.kotest.core.spec.style.FunSpec
-import io.kotest.matchers.nulls.shouldNotBeNull
-import io.kotest.matchers.shouldBe
-import jakarta.persistence.EntityManager
-import org.springframework.boot.test.autoconfigure.orm.jpa.DataJpaTest
-import roomescape.util.MemberFixture
-
-@DataJpaTest(showSql = true)
-class MemberRepositoryTest(
-    val entityManager: EntityManager,
-    val memberRepository: MemberRepository
-) : FunSpec({
-    context("existsByEmail") {
-        val account = "email"
-        val email = "$account@email.com"
-
-        beforeTest {
-            entityManager.persist(MemberFixture.create(account = account))
-            entityManager.flush()
-            entityManager.clear()
-        }
-
-        test("동일한 이메일이 있으면 true 반환") {
-            val result = memberRepository.existsByEmail(email)
-            result shouldBe true
-        }
-
-        test("동일한 이메일이 없으면 false 반환") {
-            memberRepository.existsByEmail(email.substring(email.length - 1)) shouldBe false
-        }
-    }
-
-    context("findByEmailAndPassword") {
-        val account = "email"
-        val email = "$account@email.com"
-        val password = "password123"
-
-        beforeTest {
-            entityManager.persist(MemberFixture.create(account = account, password = password))
-            entityManager.flush()
-            entityManager.clear()
-        }
-
-        test("둘다 일치하면 정상 반환") {
-            memberRepository.findByEmailAndPassword(email, password) shouldNotBeNull {
-                this.email shouldBe email
-                this.password shouldBe password
-            }
-        }
-
-        test("이메일이 틀리면 null 반환") {
-            val invalidMail = email.substring(email.length - 1)
-            memberRepository.findByEmailAndPassword(invalidMail, password) shouldBe null
-        }
-
-        test("비밀번호가 틀리면 null 반환") {
-            val invalidPassword = password.substring(password.length - 1)
-            memberRepository.findByEmailAndPassword(email, invalidPassword) shouldBe null
-        }
-    }
-})
diff --git a/src/test/kotlin/roomescape/payment/PaymentAPITest.kt b/src/test/kotlin/roomescape/payment/PaymentAPITest.kt
new file mode 100644
index 00000000..e7fd99ef
--- /dev/null
+++ b/src/test/kotlin/roomescape/payment/PaymentAPITest.kt
@@ -0,0 +1,361 @@
+package roomescape.payment
+
+import com.ninjasquad.springmockk.MockkBean
+import io.kotest.matchers.shouldBe
+import io.mockk.every
+import org.hamcrest.CoreMatchers.equalTo
+import org.springframework.data.repository.findByIdOrNull
+import org.springframework.http.HttpStatus
+import roomescape.payment.business.PaymentService
+import roomescape.payment.exception.PaymentErrorCode
+import roomescape.payment.infrastructure.client.CardDetail
+import roomescape.payment.infrastructure.client.EasyPayDetail
+import roomescape.payment.infrastructure.client.TosspayClient
+import roomescape.payment.infrastructure.client.TransferDetail
+import roomescape.payment.infrastructure.common.*
+import roomescape.payment.infrastructure.persistence.*
+import roomescape.payment.web.PaymentConfirmRequest
+import roomescape.payment.web.PaymentCreateResponse
+import roomescape.reservation.infrastructure.persistence.ReservationEntity
+import roomescape.util.FunSpecSpringbootTest
+import roomescape.util.PaymentFixture
+import roomescape.util.runTest
+
+class PaymentAPITest(
+    @MockkBean
+    private val tosspayClient: TosspayClient,
+    private val paymentService: PaymentService,
+    private val paymentRepository: PaymentRepository,
+    private val paymentDetailRepository: PaymentDetailRepository,
+    private val canceledPaymentRepository: CanceledPaymentRepository
+) : FunSpecSpringbootTest() {
+    init {
+        context("결제를 승인한다.") {
+            val amount = 100_000
+            context("간편결제 + 카드로 ${amount}원을 결제한다.") {
+                context("일시불") {
+                    test("토스페이 + 토스뱅크카드(신용)") {
+                        runConfirmTest(
+                            amount = amount,
+                            cardDetail = PaymentFixture.cardDetail(
+                                amount = amount,
+                                issuerCode = CardIssuerCode.TOSS_BANK,
+                                cardType = CardType.CREDIT,
+                            ),
+                            easyPayDetail = PaymentFixture.easypayDetail(
+                                amount = 0,
+                                provider = EasyPayCompanyCode.TOSSPAY
+                            )
+                        )
+                    }
+
+                    test("삼성페이 + 삼성카드(법인)") {
+                        runConfirmTest(
+                            amount = amount,
+                            cardDetail = PaymentFixture.cardDetail(
+                                amount = amount,
+                                issuerCode = CardIssuerCode.SAMSUNG,
+                                cardType = CardType.CREDIT,
+                                ownerType = CardOwnerType.CORPORATE
+                            ),
+                            easyPayDetail = PaymentFixture.easypayDetail(
+                                amount = 0,
+                                provider = EasyPayCompanyCode.SAMSUNGPAY
+                            )
+                        )
+                    }
+                }
+
+                context("할부") {
+                    val installmentPlanMonths = 12
+                    test("네이버페이 + 신한카드 / 12개월") {
+                        runConfirmTest(
+                            amount = amount,
+                            cardDetail = PaymentFixture.cardDetail(
+                                amount = amount,
+                                issuerCode = CardIssuerCode.SHINHAN,
+                                installmentPlanMonths = installmentPlanMonths
+                            ),
+                            easyPayDetail = PaymentFixture.easypayDetail(
+                                amount = 0,
+                                provider = EasyPayCompanyCode.NAVERPAY
+                            )
+                        )
+                    }
+                }
+
+                context("간편결제사 포인트 일부 사용") {
+                    val point = (amount * 0.1).toInt()
+                    test("토스페이 + 국민카드(체크) / 일시불 / $point 포인트 사용") {
+                        runConfirmTest(
+                            amount = amount,
+                            cardDetail = PaymentFixture.cardDetail(
+                                amount = (amount - point),
+                                issuerCode = CardIssuerCode.KOOKMIN,
+                                cardType = CardType.CHECK
+                            ),
+                            easyPayDetail = PaymentFixture.easypayDetail(
+                                amount = 0,
+                                provider = EasyPayCompanyCode.TOSSPAY,
+                                discountAmount = point
+                            )
+                        )
+                    }
+                }
+            }
+
+            context("간편결제사의 선불 충전금액으로 ${amount}원을 결제한다.") {
+                test("토스페이 + 토스페이머니 / 전액") {
+                    runConfirmTest(
+                        easyPayDetail = PaymentFixture.easypayDetail(
+                            amount = amount,
+                            provider = EasyPayCompanyCode.TOSSPAY
+                        )
+                    )
+                }
+
+                val point = (amount * 0.05).toInt()
+
+                test("카카오페이 + 카카오페이머니 / $point 사용") {
+                    runConfirmTest(
+                        easyPayDetail = PaymentFixture.easypayDetail(
+                            amount = (amount - point),
+                            provider = EasyPayCompanyCode.KAKAOPAY,
+                            discountAmount = point
+                        )
+                    )
+                }
+            }
+
+            context("계좌이체로 결제한다.") {
+                test("토스뱅크") {
+                    runConfirmTest(
+                        transferDetail = PaymentFixture.transferDetail(bankCode = BankCode.TOSS_BANK)
+                    )
+                }
+            }
+
+            context("지원하지 않는 결제수단으로 요청시 실패한다.") {
+                val supportedMethod = listOf(
+                    PaymentMethod.CARD,
+                    PaymentMethod.EASY_PAY,
+                    PaymentMethod.TRANSFER,
+                )
+
+                PaymentMethod.entries.filter { it !in supportedMethod }.forEach {
+                    test("결제 수단: ${it.koreanName}") {
+                        val reservation = dummyInitializer.createConfirmReservation(
+                            adminToken = loginUtil.loginAsAdmin(),
+                            reserverToken = loginUtil.loginAsUser()
+                        )
+
+                        val request = PaymentFixture.confirmRequest
+
+                        every {
+                            tosspayClient.confirm(request.paymentKey, request.orderId, request.amount)
+                        } returns PaymentFixture.confirmResponse(
+                            paymentKey = request.paymentKey,
+                            amount = request.amount,
+                            method = it,
+                            cardDetail = null,
+                            easyPayDetail = null,
+                            transferDetail = null,
+                        )
+
+                        runTest(
+                            token = loginUtil.loginAsUser(),
+                            using = {
+                                body(PaymentFixture.confirmRequest)
+                            },
+                            on = {
+                                post("/payments?reservationId=${reservation.id}")
+                            },
+                            expect = {
+                                statusCode(HttpStatus.BAD_REQUEST.value())
+                                body("code", equalTo(PaymentErrorCode.NOT_SUPPORTED_PAYMENT_TYPE.errorCode))
+                            }
+                        )
+                    }
+                }
+            }
+        }
+
+        context("결제를 취소한다.") {
+            test("정상 취소") {
+                val token = loginUtil.loginAsAdmin()
+                val confirmRequest = PaymentFixture.confirmRequest
+                val reservation = dummyInitializer.createConfirmReservation(
+                    adminToken = token,
+                    reserverToken = token
+                )
+
+                val paymentCreateResponse = createPayment(
+                    request = confirmRequest,
+                    reservationId = reservation.id
+                )
+
+                every {
+                    tosspayClient.cancel(
+                        confirmRequest.paymentKey,
+                        confirmRequest.amount,
+                        cancelReason = "cancelReason"
+                    )
+                } returns PaymentFixture.cancelResponse(confirmRequest.amount)
+
+                runTest(
+                    token = token,
+                    using = {
+                        val cancelRequest = PaymentFixture.cancelRequest.copy(
+                            reservationId = reservation.id
+                        )
+                        body(cancelRequest)
+                    },
+                    on = {
+                        post("/payments/cancel")
+                    },
+                    expect = {
+                        statusCode(HttpStatus.OK.value())
+                    }
+                ).also {
+                    val payment = paymentRepository.findByIdOrNull(paymentCreateResponse.paymentId)
+                        ?: throw AssertionError("Unexpected Exception Occurred.")
+                    val canceledPayment =
+                        canceledPaymentRepository.findByPaymentId(paymentCreateResponse.paymentId)
+                            ?: throw AssertionError("Unexpected Exception Occurred.")
+
+                    payment.status shouldBe PaymentStatus.CANCELED
+                    canceledPayment.paymentId shouldBe payment.id
+                    canceledPayment.cancelAmount shouldBe payment.totalAmount
+                }
+            }
+
+            test("예약에 대한 결제 정보가 없으면 실패한다.") {
+                val token = loginUtil.loginAsAdmin()
+                val reservation = dummyInitializer.createConfirmReservation(
+                    adminToken = token,
+                    reserverToken = token,
+                )
+
+                runTest(
+                    token = token,
+                    using = {
+                        body(PaymentFixture.cancelRequest.copy(reservationId = reservation.id))
+                    },
+                    on = {
+                        post("/payments/cancel")
+                    },
+                    expect = {
+                        statusCode(HttpStatus.NOT_FOUND.value())
+                        body("code", equalTo(PaymentErrorCode.PAYMENT_NOT_FOUND.errorCode))
+                    }
+                )
+            }
+        }
+    }
+
+    private fun createPayment(
+        request: PaymentConfirmRequest,
+        reservationId: Long,
+    ): PaymentCreateResponse {
+        every {
+            tosspayClient.confirm(request.paymentKey, request.orderId, request.amount)
+        } returns PaymentFixture.confirmResponse(
+            request.paymentKey,
+            request.amount,
+            method = PaymentMethod.CARD,
+            cardDetail = PaymentFixture.cardDetail(request.amount),
+            easyPayDetail = null,
+            transferDetail = null,
+        )
+
+        return paymentService.confirm(reservationId, request)
+    }
+
+    fun runConfirmTest(
+        cardDetail: CardDetail? = null,
+        easyPayDetail: EasyPayDetail? = null,
+        transferDetail: TransferDetail? = null,
+        paymentKey: String = "paymentKey",
+        amount: Int = 10000,
+    ) {
+
+        val request = PaymentFixture.confirmRequest.copy(paymentKey = paymentKey, amount = amount)
+
+        val reservation: ReservationEntity = dummyInitializer.createPendingReservation(
+            adminToken = loginUtil.loginAsAdmin(),
+            reserverToken = loginUtil.loginAsUser(),
+        )
+
+        val method = if (easyPayDetail != null) {
+            PaymentMethod.EASY_PAY
+        } else if (cardDetail != null) {
+            PaymentMethod.CARD
+        } else if (transferDetail != null) {
+            PaymentMethod.TRANSFER
+        } else {
+            throw AssertionError("결제타입 확인 필요.")
+        }
+
+        val clientResponse = PaymentFixture.confirmResponse(
+            paymentKey, amount, method, cardDetail, easyPayDetail, transferDetail
+        )
+
+        every {
+            tosspayClient.confirm(request.paymentKey, request.orderId, request.amount)
+        } returns clientResponse
+
+        runTest(
+            token = loginUtil.loginAsUser(),
+            using = {
+                body(request)
+            },
+            on = {
+                post("/payments?reservationId=${reservation.id}")
+            },
+            expect = {
+                statusCode(HttpStatus.OK.value())
+            }
+        ).also {
+            val createdPayment = paymentRepository.findByIdOrNull(it.extract().path("data.paymentId"))
+                ?: throw AssertionError("Unexpected Exception Occurred.")
+            val createdPaymentDetail =
+                paymentDetailRepository.findByIdOrNull(it.extract().path("data.detailId"))
+                    ?: throw AssertionError("Unexpected Exception Occurred.")
+
+            createdPayment.status shouldBe clientResponse.status
+            createdPayment.method shouldBe clientResponse.method
+            createdPayment.reservationId shouldBe reservation.id
+
+            when (createdPaymentDetail) {
+                is PaymentCardDetailEntity -> {
+                    createdPaymentDetail.issuerCode shouldBe clientResponse.card!!.issuerCode
+                    createdPaymentDetail.cardType shouldBe clientResponse.card.cardType
+                    createdPaymentDetail.cardNumber shouldBe clientResponse.card.number
+                    createdPaymentDetail.suppliedAmount shouldBe clientResponse.suppliedAmount
+                    createdPaymentDetail.vat shouldBe clientResponse.vat
+                    createdPaymentDetail.amount shouldBe (clientResponse.totalAmount - (clientResponse.easyPay?.discountAmount
+                        ?: 0))
+                    clientResponse.easyPay?.let { easypay ->
+                        createdPaymentDetail.easypayProviderCode shouldBe easypay.provider
+                        createdPaymentDetail.easypayDiscountAmount shouldBe easypay.discountAmount
+                    }
+                }
+
+                is PaymentBankTransferDetailEntity -> {
+                    createdPaymentDetail.suppliedAmount shouldBe clientResponse.suppliedAmount
+                    createdPaymentDetail.vat shouldBe clientResponse.vat
+                    createdPaymentDetail.bankCode shouldBe clientResponse.transfer!!.bankCode
+                    createdPaymentDetail.settlementStatus shouldBe clientResponse.transfer.settlementStatus
+                }
+
+                is PaymentEasypayPrepaidDetailEntity -> {
+                    createdPaymentDetail.suppliedAmount shouldBe clientResponse.suppliedAmount
+                    createdPaymentDetail.vat shouldBe clientResponse.vat
+                    createdPaymentDetail.easypayProviderCode shouldBe clientResponse.easyPay!!.provider
+                    createdPaymentDetail.amount shouldBe clientResponse.easyPay.amount
+                    createdPaymentDetail.discountAmount shouldBe clientResponse.easyPay.discountAmount
+                }
+            }
+        }
+    }
+}
diff --git a/src/test/kotlin/roomescape/payment/SampleTosspayConstant.kt b/src/test/kotlin/roomescape/payment/SampleTosspayConstant.kt
new file mode 100644
index 00000000..07c4a2ad
--- /dev/null
+++ b/src/test/kotlin/roomescape/payment/SampleTosspayConstant.kt
@@ -0,0 +1,288 @@
+package roomescape.payment
+
+import java.time.OffsetDateTime
+
+object SampleTosspayConstant {
+    const val PAYMENT_KEY: String = "5EnNZRJGvaBX7zk2yd8ydw26XvwXkLrx9POLqKQjmAw4b0e1"
+    const val ORDER_ID: String = "MC4wODU4ODQwMzg4NDk0"
+    const val AMOUNT: Int = 100_000
+    const val CANCEL_REASON: String = "테스트 결제 취소"
+
+    val confirmRequestJson: String = """
+        {
+          "paymentKey": "$PAYMENT_KEY",
+          "orderId": "$ORDER_ID",
+          "amount": "$AMOUNT"
+        }
+    """.trimIndent()
+
+    val cancelRequestJson: String = """
+		{
+		  "cancelReason": "$CANCEL_REASON",
+          "cancelAmount": "$AMOUNT"
+		}
+	""".trimIndent()
+
+    val tossPaymentErrorJson: String = """
+		{
+		    "code": "ERROR_CODE",
+		    "message": "Error message"
+		}	
+	""".trimIndent()
+
+    val easypayCardConfirmJson: String = """
+        {
+          "mId": "tgen_docs",
+          "lastTransactionKey": "txrd_a01k4mtanmyx0hm6hmmbvfvmhky",
+          "paymentKey": "$PAYMENT_KEY",
+          "orderId": "$ORDER_ID",
+          "orderName": "Sonya Aguirre 예약 결제",
+          "taxExemptionAmount": 0,
+          "status": "DONE",
+          "requestedAt": "${OffsetDateTime.now()}",
+          "approvedAt": "${OffsetDateTime.now().plusSeconds(5)}",
+          "useEscrow": false,
+          "cultureExpense": false,
+          "card": {
+            "issuerCode": "41",
+            "acquirerCode": "41",
+            "number": "12748273****675*",
+            "installmentPlanMonths": 0,
+            "isInterestFree": false,
+            "interestPayer": null,
+            "approveNo": "00000000",
+            "useCardPoint": false,
+            "cardType": "신용",
+            "ownerType": "개인",
+            "acquireStatus": "READY",
+            "amount": $AMOUNT
+          },
+          "virtualAccount": null,
+          "transfer": null,
+          "mobilePhone": null,
+          "giftCertificate": null,
+          "cashReceipt": null,
+          "cashReceipts": null,
+          "discount": null,
+          "cancels": null,
+          "secret": "ps_6BYq7GWPVvGNAwZeRBDLrNE5vbo1",
+          "type": "NORMAL",
+          "easyPay": {
+            "provider": "토스페이",
+            "amount": 0,
+            "discountAmount": 0
+          },
+          "country": "KR",
+          "failure": null,
+          "isPartialCancelable": true,
+          "receipt": {
+            "url": "https://dashboard-sandbox.tosspayments.com/receipt/redirection?transactionId=tgen_20250908230510v2rY2&ref=PX"
+          },
+          "checkout": {
+            "url": "https://api.tosspayments.com/v1/payments/tgen_20250908230510v2rY2/checkout"
+          },
+          "currency": "KRW",
+          "totalAmount": $AMOUNT,
+          "balanceAmount": $AMOUNT,
+          "suppliedAmount": ${(AMOUNT * 0.9).toInt()},
+          "vat": ${(AMOUNT * 0.1).toInt()},
+          "taxFreeAmount": 0,
+          "method": "간편결제",
+          "version": "2022-11-16",
+          "metadata": null
+        }
+    """.trimIndent()
+
+    val easypayCardCancelJson: String = """
+        {
+          "mId": "tgen_docs",
+          "lastTransactionKey": "txrd_a01k4mtgh26vgrn1evbdckyqmdr",
+          "paymentKey": "$PAYMENT_KEY",
+          "orderId": "$ORDER_ID",
+          "orderName": "Sonya Aguirre 예약 결제",
+          "taxExemptionAmount": 0,
+          "status": "CANCELED",
+          "requestedAt": "${OffsetDateTime.now()}",
+          "approvedAt": "${OffsetDateTime.now().plusSeconds(5)}",
+          "useEscrow": false,
+          "cultureExpense": false,
+          "card": {
+            "issuerCode": "41",
+            "acquirerCode": "41",
+            "number": "12748273****675*",
+            "installmentPlanMonths": 0,
+            "isInterestFree": false,
+            "interestPayer": null,
+            "approveNo": "00000000",
+            "useCardPoint": false,
+            "cardType": "신용",
+            "ownerType": "개인",
+            "acquireStatus": "READY",
+            "amount": $AMOUNT
+          },
+          "virtualAccount": null,
+          "transfer": null,
+          "mobilePhone": null,
+          "giftCertificate": null,
+          "cashReceipt": null,
+          "cashReceipts": null,
+          "discount": null,
+          "cancels": [
+            {
+              "transactionKey": "txrd_a01k4mtgh26vgrn1evbdckyqmdr",
+              "cancelReason": "$CANCEL_REASON",
+              "taxExemptionAmount": 0,
+              "canceledAt": "${OffsetDateTime.now().plusMinutes(1)}",
+              "cardDiscountAmount": 0,
+              "transferDiscountAmount": 0,
+              "easyPayDiscountAmount": 0,
+              "receiptKey": null,
+              "cancelStatus": "DONE",
+              "cancelRequestId": null,
+              "cancelAmount": $AMOUNT,
+              "taxFreeAmount": 0,
+              "refundableAmount": 0
+            }
+          ],
+          "secret": "ps_6BYq7GWPVvGNAwZeRBDLrNE5vbo1",
+          "type": "NORMAL",
+          "easyPay": {
+            "provider": "토스페이",
+            "amount": 0,
+            "discountAmount": 0
+          },
+          "country": "KR",
+          "failure": null,
+          "isPartialCancelable": true,
+          "receipt": {
+            "url": "https://dashboard-sandbox.tosspayments.com/receipt/redirection?transactionId=tgen_20250908230510v2rY2&ref=PX"
+          },
+          "checkout": {
+            "url": "https://api.tosspayments.com/v1/payments/tgen_20250908230510v2rY2/checkout"
+          },
+          "currency": "KRW",
+          "totalAmount": ${AMOUNT},
+          "balanceAmount": 0,
+          "suppliedAmount": 0,
+          "vat": 0,
+          "taxFreeAmount": 0,
+          "method": "간편결제",
+          "version": "2022-11-16",
+          "metadata": null
+        }
+    """.trimIndent()
+
+    val transferConfirmJson: String = """
+         {
+           "mId": "tgen_docs",
+           "lastTransactionKey": "txrd_a01k4mtanmyx0hm6hmmbvfvmhky",
+           "paymentKey": "$PAYMENT_KEY",
+           "orderId": "$ORDER_ID",
+           "orderName": "Sonya Aguirre 예약 결제",
+           "taxExemptionAmount": 0,
+           "status": "DONE",
+           "requestedAt": "${OffsetDateTime.now()}",
+           "approvedAt": "${OffsetDateTime.now().plusSeconds(5)}",
+           "useEscrow": false,
+           "cultureExpense": false,
+           "card": null,
+           "virtualAccount": null,
+           "transfer": {
+             "bankCode": "92",
+             "settlementStatus": "COMPLETED"
+           },
+           "mobilePhone": null,
+           "giftCertificate": null,
+           "cashReceipt": null,
+           "cashReceipts": null,
+           "discount": null,
+           "cancels": null,
+           "secret": "ps_6BYq7GWPVvGNAwZeRBDLrNE5vbo1",
+           "type": "NORMAL",
+           "easyPay": null,
+           "country": "KR",
+           "failure": null,
+           "isPartialCancelable": true,
+           "receipt": {
+             "url": "https://dashboard-sandbox.tosspayments.com/receipt/redirection?transactionId=tgen_20250908230510v2rY2&ref=PX"
+           },
+           "checkout": {
+             "url": "https://api.tosspayments.com/v1/payments/tgen_20250908230510v2rY2/checkout"
+           },
+           "currency": "KRW",
+           "totalAmount": $AMOUNT,
+           "balanceAmount": $AMOUNT,
+           "suppliedAmount": ${(AMOUNT * 0.9).toInt()},
+           "vat": ${(AMOUNT * 0.1).toInt()},
+           "taxFreeAmount": 0,
+           "method": "간편결제",
+           "version": "2022-11-16",
+           "metadata": null
+         }
+    """.trimIndent()
+
+    val transferCancelJson: String = """
+         {
+           "mId": "tgen_docs",
+           "lastTransactionKey": "txrd_a01k4mtanmyx0hm6hmmbvfvmhky",
+           "paymentKey": "$PAYMENT_KEY",
+           "orderId": "$ORDER_ID",
+           "orderName": "Sonya Aguirre 예약 결제",
+           "taxExemptionAmount": 0,
+           "status": "DONE",
+           "requestedAt": "${OffsetDateTime.now()}",
+           "approvedAt": "${OffsetDateTime.now().plusSeconds(5)}",
+           "useEscrow": false,
+           "cultureExpense": false,
+           "card": null,
+           "virtualAccount": null,
+           "transfer": {
+             "bankCode": "92",
+             "settlementStatus": "COMPLETED"
+           },
+           "mobilePhone": null,
+           "giftCertificate": null,
+           "cashReceipt": null,
+           "cashReceipts": null,
+           "discount": null,
+           "cancels": [
+             {
+               "transactionKey": "txrd_a01k4mtgh26vgrn1evbdckyqmdr",
+               "cancelReason": "$CANCEL_REASON",
+               "taxExemptionAmount": 0,
+               "canceledAt": "${OffsetDateTime.now().plusMinutes(1)}",
+               "cardDiscountAmount": 0,
+               "transferDiscountAmount": 0,
+               "easyPayDiscountAmount": 0,
+               "receiptKey": null,
+               "cancelStatus": "DONE",
+               "cancelRequestId": null,
+               "cancelAmount": $AMOUNT,
+               "taxFreeAmount": 0,
+               "refundableAmount": 0
+             }
+           ],
+           "secret": "ps_6BYq7GWPVvGNAwZeRBDLrNE5vbo1",
+           "type": "NORMAL",
+           "easyPay": null,
+           "country": "KR",
+           "failure": null,
+           "isPartialCancelable": true,
+           "receipt": {
+             "url": "https://dashboard-sandbox.tosspayments.com/receipt/redirection?transactionId=tgen_20250908230510v2rY2&ref=PX"
+           },
+           "checkout": {
+             "url": "https://api.tosspayments.com/v1/payments/tgen_20250908230510v2rY2/checkout"
+           },
+           "currency": "KRW",
+           "totalAmount": $AMOUNT,
+           "balanceAmount": $AMOUNT,
+           "suppliedAmount": ${(AMOUNT * 0.9).toInt()},
+           "vat": ${(AMOUNT * 0.1).toInt()},
+           "taxFreeAmount": 0,
+           "method": "간편결제",
+           "version": "2022-11-16",
+           "metadata": null
+         }
+    """.trimIndent()
+}
diff --git a/src/test/kotlin/roomescape/payment/infrastructure/client/TossPaymentClientTest.kt b/src/test/kotlin/roomescape/payment/TosspayClientTest.kt
similarity index 56%
rename from src/test/kotlin/roomescape/payment/infrastructure/client/TossPaymentClientTest.kt
rename to src/test/kotlin/roomescape/payment/TosspayClientTest.kt
index 98419344..d0665a06 100644
--- a/src/test/kotlin/roomescape/payment/infrastructure/client/TossPaymentClientTest.kt
+++ b/src/test/kotlin/roomescape/payment/TosspayClientTest.kt
@@ -1,4 +1,4 @@
-package roomescape.payment.infrastructure.client
+package roomescape.payment
 
 import com.ninjasquad.springmockk.MockkBean
 import io.kotest.assertions.assertSoftly
@@ -18,13 +18,15 @@ import org.springframework.test.web.client.response.MockRestResponseCreators.wit
 import org.springframework.test.web.client.response.MockRestResponseCreators.withSuccess
 import roomescape.payment.exception.PaymentErrorCode
 import roomescape.payment.exception.PaymentException
-import roomescape.payment.web.PaymentCancelRequest
-import roomescape.payment.web.PaymentCancelResponse
+import roomescape.payment.infrastructure.client.PaymentClientCancelResponse
+import roomescape.payment.infrastructure.client.PaymentClientConfirmResponse
+import roomescape.payment.infrastructure.client.TosspayClient
+import roomescape.payment.infrastructure.common.PaymentStatus
 
-@RestClientTest(TossPaymentClient::class)
+@RestClientTest(TosspayClient::class)
 @MockkBean(JpaMetamodelMappingContext::class)
-class TossPaymentClientTest(
-    @Autowired val client: TossPaymentClient,
+class TosspayClientTest(
+    @Autowired val client: TosspayClient,
     @Autowired val mockServer: MockRestServiceServer
 ) : FunSpec() {
 
@@ -37,24 +39,30 @@ class TossPaymentClientTest(
             }.andExpect {
                 content().contentType(MediaType.APPLICATION_JSON)
             }.andExpect {
-                content().json(SampleTossPaymentConst.paymentRequestJson)
+                content().json(SampleTosspayConstant.confirmRequestJson)
             }
 
-            test("성공 응답") {
-                commonAction().andRespond {
-                    withSuccess()
-                        .contentType(MediaType.APPLICATION_JSON)
-                        .body(SampleTossPaymentConst.confirmJson)
-                        .createResponse(it)
+            context("성공 응답") {
+                test("간편결제 + 카드") {
+                    commonAction().andRespond {
+                        withSuccess()
+                            .contentType(MediaType.APPLICATION_JSON)
+                            .body(SampleTosspayConstant.easypayCardConfirmJson)
+                            .createResponse(it)
+                    }
+
+                    runConfirmTest()
                 }
 
-                val paymentRequest = SampleTossPaymentConst.paymentRequest
-                val paymentResponse: PaymentApproveResponse = client.confirm(paymentRequest)
+                test("계좌이체") {
+                    commonAction().andRespond {
+                        withSuccess()
+                            .contentType(MediaType.APPLICATION_JSON)
+                            .body(SampleTosspayConstant.transferConfirmJson)
+                            .createResponse(it)
+                    }
 
-                assertSoftly(paymentResponse) {
-                    this.paymentKey shouldBe paymentRequest.paymentKey
-                    this.orderId shouldBe paymentRequest.orderId
-                    this.totalAmount shouldBe paymentRequest.amount
+                    runConfirmTest()
                 }
             }
 
@@ -63,16 +71,18 @@ class TossPaymentClientTest(
                     commonAction().andRespond {
                         withStatus(httpStatus)
                             .contentType(MediaType.APPLICATION_JSON)
-                            .body(SampleTossPaymentConst.tossPaymentErrorJson)
+                            .body(SampleTosspayConstant.tossPaymentErrorJson)
                             .createResponse(it)
                     }
 
-                    val paymentRequest = SampleTossPaymentConst.paymentRequest
-
-                    // then
                     val exception = shouldThrow<PaymentException> {
-                        client.confirm(paymentRequest)
+                        client.confirm(
+                            SampleTosspayConstant.PAYMENT_KEY,
+                            SampleTosspayConstant.ORDER_ID,
+                            SampleTosspayConstant.AMOUNT
+                        )
                     }
+
                     exception.errorCode shouldBe expectedError
                 }
 
@@ -88,31 +98,35 @@ class TossPaymentClientTest(
 
         context("결제 취소 요청") {
             fun commonAction(): ResponseActions = mockServer.expect {
-                requestTo("/v1/payments/${SampleTossPaymentConst.paymentKey}/cancel")
+                requestTo("/v1/payments/${SampleTosspayConstant.PAYMENT_KEY}/cancel")
             }.andExpect {
                 method(HttpMethod.POST)
             }.andExpect {
                 content().contentType(MediaType.APPLICATION_JSON)
             }.andExpect {
-                content().json(SampleTossPaymentConst.cancelRequestJson)
+                content().json(SampleTosspayConstant.cancelRequestJson)
             }
 
             test("성공 응답") {
                 commonAction().andRespond {
                     withSuccess()
                         .contentType(MediaType.APPLICATION_JSON)
-                        .body(SampleTossPaymentConst.cancelJson)
+                        .body(SampleTosspayConstant.easypayCardCancelJson)
                         .createResponse(it)
                 }
 
-
-                val cancelRequest: PaymentCancelRequest = SampleTossPaymentConst.cancelRequest
-                val cancelResponse: PaymentCancelResponse = client.cancel(cancelRequest)
+                val cancelResponse: PaymentClientCancelResponse = client.cancel(
+                    SampleTosspayConstant.PAYMENT_KEY,
+                    SampleTosspayConstant.AMOUNT,
+                    SampleTosspayConstant.CANCEL_REASON
+                )
 
                 assertSoftly(cancelResponse) {
-                    this.cancelStatus shouldBe "DONE"
-                    this.cancelReason shouldBe cancelRequest.cancelReason
-                    this.cancelAmount shouldBe cancelRequest.amount
+                    this.status shouldBe PaymentStatus.CANCELED
+                    with(this.cancels) {
+                        this.cancelAmount shouldBe SampleTosspayConstant.AMOUNT
+                        this.cancelReason shouldBe SampleTosspayConstant.CANCEL_REASON
+                    }
                 }
             }
 
@@ -121,14 +135,16 @@ class TossPaymentClientTest(
                     commonAction().andRespond {
                         withStatus(httpStatus)
                             .contentType(MediaType.APPLICATION_JSON)
-                            .body(SampleTossPaymentConst.tossPaymentErrorJson)
+                            .body(SampleTosspayConstant.tossPaymentErrorJson)
                             .createResponse(it)
                     }
 
-                    val cancelRequest: PaymentCancelRequest = SampleTossPaymentConst.cancelRequest
-
                     val exception = shouldThrow<PaymentException> {
-                        client.cancel(cancelRequest)
+                        client.cancel(
+                            SampleTosspayConstant.PAYMENT_KEY,
+                            SampleTosspayConstant.AMOUNT,
+                            SampleTosspayConstant.CANCEL_REASON
+                        )
                     }
                     exception.errorCode shouldBe expectedError
                 }
@@ -143,4 +159,17 @@ class TossPaymentClientTest(
             }
         }
     }
+
+    fun runConfirmTest() {
+        val paymentResponse: PaymentClientConfirmResponse = client.confirm(
+            SampleTosspayConstant.PAYMENT_KEY,
+            SampleTosspayConstant.ORDER_ID,
+            SampleTosspayConstant.AMOUNT
+        )
+
+        assertSoftly(paymentResponse) {
+            this.paymentKey shouldBe SampleTosspayConstant.PAYMENT_KEY
+            this.totalAmount shouldBe SampleTosspayConstant.AMOUNT
+        }
+    }
 }
diff --git a/src/test/kotlin/roomescape/payment/business/PaymentServiceTest.kt b/src/test/kotlin/roomescape/payment/business/PaymentServiceTest.kt
deleted file mode 100644
index 94ff5c8e..00000000
--- a/src/test/kotlin/roomescape/payment/business/PaymentServiceTest.kt
+++ /dev/null
@@ -1,166 +0,0 @@
-package roomescape.payment.business
-
-import io.kotest.assertions.assertSoftly
-import io.kotest.assertions.throwables.shouldThrow
-import io.kotest.core.spec.style.FunSpec
-import io.kotest.matchers.shouldBe
-import io.kotest.matchers.types.shouldBeInstanceOf
-import io.mockk.every
-import io.mockk.mockk
-import io.mockk.slot
-import roomescape.payment.exception.PaymentErrorCode
-import roomescape.payment.exception.PaymentException
-import roomescape.payment.implement.PaymentFinder
-import roomescape.payment.implement.PaymentWriter
-import roomescape.payment.infrastructure.client.PaymentApproveResponse
-import roomescape.payment.infrastructure.persistence.CanceledPaymentEntity
-import roomescape.payment.web.PaymentCancelRequest
-import roomescape.payment.web.PaymentCancelResponse
-import roomescape.util.PaymentFixture
-import roomescape.util.ReservationFixture
-import java.time.LocalDate
-import java.time.LocalTime
-import java.time.OffsetDateTime
-import java.time.ZoneOffset
-
-class PaymentServiceTest : FunSpec({
-    val paymentFinder: PaymentFinder = mockk()
-    val paymentWriter: PaymentWriter = mockk()
-
-    val paymentService = PaymentService(paymentFinder, paymentWriter)
-
-    context("createPayment") {
-        val approvedPaymentInfo = PaymentApproveResponse(
-            paymentKey = "paymentKey",
-            orderId = "orderId",
-            totalAmount = 1000L,
-            approvedAt = OffsetDateTime.now(),
-        )
-        val reservation = ReservationFixture.create(id = 1L)
-
-        test("정상 응답") {
-            every {
-                paymentWriter.create(
-                    paymentKey = approvedPaymentInfo.paymentKey,
-                    orderId = approvedPaymentInfo.orderId,
-                    totalAmount = approvedPaymentInfo.totalAmount,
-                    approvedAt = approvedPaymentInfo.approvedAt,
-                    reservation = reservation
-                )
-            } returns PaymentFixture.create(
-                id = 1L,
-                orderId = approvedPaymentInfo.orderId,
-                paymentKey = approvedPaymentInfo.paymentKey,
-                totalAmount = approvedPaymentInfo.totalAmount,
-                approvedAt = approvedPaymentInfo.approvedAt,
-                reservation = reservation
-            )
-
-            val response = paymentService.createPayment(approvedPaymentInfo, reservation)
-
-            assertSoftly(response) {
-                it.id shouldBe 1L
-                it.paymentKey shouldBe approvedPaymentInfo.paymentKey
-                it.reservationId shouldBe reservation.id
-            }
-        }
-    }
-
-    context("createCanceledPayment(canceledPaymentInfo)") {
-        val canceledPaymentInfo = PaymentCancelResponse(
-            cancelStatus = "normal",
-            cancelReason = "고객 요청",
-            cancelAmount = 1000L,
-            canceledAt = OffsetDateTime.now(),
-        )
-        val approvedAt = OffsetDateTime.now()
-        val paymentKey = "paymentKey"
-
-        test("CanceledPaymentEntity를 응답") {
-            every {
-                paymentWriter.createCanceled(
-                    cancelReason = canceledPaymentInfo.cancelReason,
-                    cancelAmount = canceledPaymentInfo.cancelAmount,
-                    canceledAt = canceledPaymentInfo.canceledAt,
-                    approvedAt = approvedAt,
-                    paymentKey = paymentKey
-                )
-            } returns PaymentFixture.createCanceled(
-                id = 1L,
-                paymentKey = paymentKey,
-                cancelAmount = canceledPaymentInfo.cancelAmount
-            )
-
-            val response = paymentService.createCanceledPayment(canceledPaymentInfo, approvedAt, paymentKey)
-
-            response.shouldBeInstanceOf<CanceledPaymentEntity>()
-            response.paymentKey shouldBe paymentKey
-        }
-    }
-
-    context("createCanceledPayment(reservationId)") {
-        val reservationId = 1L
-
-        test("취소 사유를 '예약 취소'로 하여 PaymentCancelRequest를 응답") {
-            val payment = PaymentFixture.create(id = 1L, paymentKey = "paymentKey", totalAmount = 1000L)
-            every {
-                paymentFinder.findByReservationId(reservationId)
-            } returns payment
-
-            val cancelReasonSlot = slot<String>()
-
-            every {
-                paymentWriter.createCanceled(payment, capture(cancelReasonSlot), any())
-            } returns PaymentFixture.createCanceled(
-                id = 1L,
-                paymentKey = payment.paymentKey,
-                cancelAmount = payment.totalAmount
-            )
-
-            val response = paymentService.createCanceledPayment(reservationId)
-
-            response.shouldBeInstanceOf<PaymentCancelRequest>()
-            cancelReasonSlot.captured shouldBe "예약 취소"
-        }
-
-        test("결제 정보가 없으면 예외 응답") {
-            every {
-                paymentFinder.findByReservationId(reservationId)
-            } throws PaymentException(PaymentErrorCode.PAYMENT_NOT_FOUND)
-
-            shouldThrow<PaymentException> {
-                paymentService.createCanceledPayment(reservationId)
-            }.also {
-                it.errorCode shouldBe PaymentErrorCode.PAYMENT_NOT_FOUND
-            }
-        }
-    }
-
-    context("updateCanceledTime") {
-        val paymentKey = "paymentKey"
-        val canceledAt = OffsetDateTime.of(LocalDate.of(2025, 8, 5), LocalTime.of(10, 0), ZoneOffset.UTC)
-
-        test("정상 응답") {
-            val canceled = PaymentFixture.createCanceled(id = 1L)
-            every {
-                paymentFinder.findCanceledByKey(paymentKey)
-            } returns canceled
-
-            paymentService.updateCanceledTime(paymentKey, canceledAt)
-
-            canceled.canceledAt shouldBe canceledAt
-        }
-
-        test("결제 취소 정보가 없으면 예외 응답") {
-            every {
-                paymentFinder.findCanceledByKey(paymentKey)
-            } throws PaymentException(PaymentErrorCode.PAYMENT_NOT_FOUND)
-
-            shouldThrow<PaymentException> {
-                paymentService.updateCanceledTime(paymentKey, canceledAt)
-            }.also {
-                it.errorCode shouldBe PaymentErrorCode.PAYMENT_NOT_FOUND
-            }
-        }
-    }
-})
diff --git a/src/test/kotlin/roomescape/payment/implement/PaymentFinderTest.kt b/src/test/kotlin/roomescape/payment/implement/PaymentFinderTest.kt
deleted file mode 100644
index b5fd6d10..00000000
--- a/src/test/kotlin/roomescape/payment/implement/PaymentFinderTest.kt
+++ /dev/null
@@ -1,93 +0,0 @@
-package roomescape.payment.implement
-
-import io.kotest.assertions.throwables.shouldThrow
-import io.kotest.core.spec.style.FunSpec
-import io.kotest.matchers.shouldBe
-import io.mockk.every
-import io.mockk.mockk
-import io.mockk.verify
-import roomescape.payment.exception.PaymentErrorCode
-import roomescape.payment.exception.PaymentException
-import roomescape.payment.infrastructure.persistence.CanceledPaymentRepository
-import roomescape.payment.infrastructure.persistence.PaymentRepository
-
-class PaymentFinderTest : FunSpec({
-    val paymentRepository: PaymentRepository = mockk()
-    val canceledPaymentRepository: CanceledPaymentRepository = mockk()
-
-    val paymentFinder = PaymentFinder(paymentRepository, canceledPaymentRepository)
-
-    context("existsPaymentByReservationId") {
-        val reservationId = 1L
-        test("결제 정보가 있으면 true를 반환한다.") {
-            every {
-                paymentRepository.existsByReservationId(reservationId)
-            } returns true
-
-            paymentFinder.existsPaymentByReservationId(reservationId) shouldBe true
-        }
-
-        test("결제 정보가 없으면 false를 반환한다.") {
-            every {
-                paymentRepository.existsByReservationId(reservationId)
-            } returns false
-
-            paymentFinder.existsPaymentByReservationId(reservationId) shouldBe false
-        }
-    }
-
-    context("findByReservationId") {
-        val reservationId = 1L
-        test("결제 정보를 조회한다.") {
-            every {
-                paymentRepository.findByReservationId(reservationId)
-            } returns mockk()
-
-            paymentFinder.findByReservationId(reservationId)
-
-            verify(exactly = 1) {
-                paymentRepository.findByReservationId(reservationId)
-            }
-        }
-
-        test("결제 정보가 없으면 실패한다.") {
-            every {
-                paymentRepository.findByReservationId(reservationId)
-            } returns null
-
-            shouldThrow<PaymentException> {
-                paymentFinder.findByReservationId(reservationId)
-            }.also {
-                it.errorCode shouldBe PaymentErrorCode.PAYMENT_NOT_FOUND
-            }
-        }
-    }
-
-    context("findCanceledByKey") {
-        val paymentKey = "paymentKey"
-
-        test("결제 취소 정보를 조회한다.") {
-            every {
-                canceledPaymentRepository.findByPaymentKey(paymentKey)
-            } returns mockk()
-
-            paymentFinder.findCanceledByKey(paymentKey)
-
-            verify(exactly = 1) {
-                canceledPaymentRepository.findByPaymentKey(paymentKey)
-            }
-        }
-
-        test("결제 취소 정보가 없으면 실패한다.")  {
-            every {
-                canceledPaymentRepository.findByPaymentKey(paymentKey)
-            } returns null
-
-            shouldThrow<PaymentException> {
-                paymentFinder.findCanceledByKey(paymentKey)
-            }.also {
-                it.errorCode shouldBe PaymentErrorCode.CANCELED_PAYMENT_NOT_FOUND
-            }
-        }
-    }
-})
diff --git a/src/test/kotlin/roomescape/payment/implement/PaymentWriterTest.kt b/src/test/kotlin/roomescape/payment/implement/PaymentWriterTest.kt
deleted file mode 100644
index ac003c06..00000000
--- a/src/test/kotlin/roomescape/payment/implement/PaymentWriterTest.kt
+++ /dev/null
@@ -1,121 +0,0 @@
-package roomescape.payment.implement
-
-import com.ninjasquad.springmockk.MockkClear
-import com.ninjasquad.springmockk.clear
-import io.kotest.core.spec.style.FunSpec
-import io.kotest.matchers.date.after
-import io.kotest.matchers.shouldBe
-import io.mockk.clearMocks
-import io.mockk.every
-import io.mockk.mockk
-import io.mockk.slot
-import io.mockk.verify
-import roomescape.payment.infrastructure.persistence.CanceledPaymentEntity
-import roomescape.payment.infrastructure.persistence.CanceledPaymentRepository
-import roomescape.payment.infrastructure.persistence.PaymentEntity
-import roomescape.payment.infrastructure.persistence.PaymentRepository
-import roomescape.reservation.infrastructure.persistence.ReservationEntity
-import roomescape.util.PaymentFixture
-import roomescape.util.ReservationFixture
-import roomescape.util.TsidFactory
-import java.time.OffsetDateTime
-
-class PaymentWriterTest : FunSpec({
-    val paymentRepository: PaymentRepository = mockk()
-    val canceledPaymentRepository: CanceledPaymentRepository = mockk()
-
-    val paymentWriter = PaymentWriter(paymentRepository, canceledPaymentRepository, TsidFactory)
-
-    val paymentKey = "paymentKey"
-    val orderId = "orderId"
-    val totalAmount = 1000L
-    val approvedAt = OffsetDateTime.now()
-
-    context("create") {
-        val reservation: ReservationEntity = ReservationFixture.create(id = 1L)
-        test("결제 정보를 저장한다.") {
-            val slot = slot<PaymentEntity>()
-            every {
-                paymentRepository.save(capture(slot))
-            } returns mockk()
-
-            paymentWriter.create(paymentKey, orderId, totalAmount, approvedAt, reservation)
-
-            verify(exactly = 1) {
-                paymentRepository.save(any())
-            }
-
-            slot.captured.also {
-                it.paymentKey shouldBe paymentKey
-                it.orderId shouldBe orderId
-                it.totalAmount shouldBe totalAmount
-                it.approvedAt shouldBe approvedAt
-            }
-
-            paymentRepository.clear(MockkClear.AFTER)
-        }
-    }
-
-    context("createCanceled") {
-        val cancelReason = "고객 요청"
-        val canceledAt = OffsetDateTime.now()
-
-        afterTest {
-            clearMocks(paymentRepository)
-            clearMocks(canceledPaymentRepository)
-        }
-
-        test("PaymentEntity를 받아 저장한다.") {
-            val payment: PaymentEntity = PaymentFixture.create(id = 1L)
-            val slot = slot<CanceledPaymentEntity>()
-
-            every {
-                canceledPaymentRepository.save(capture(slot))
-            } returns mockk()
-
-            every {
-                paymentRepository.deleteByPaymentKey(paymentKey)
-            } returns Unit
-
-            paymentWriter.createCanceled(payment, cancelReason, canceledAt)
-
-            verify(exactly = 1) { canceledPaymentRepository.save(any()) }
-            verify(exactly = 1) { paymentRepository.deleteByPaymentKey(any()) }
-
-            slot.captured.also {
-                it.paymentKey shouldBe payment.paymentKey
-                it.cancelAmount shouldBe payment.totalAmount
-                it.approvedAt shouldBe payment.approvedAt
-            }
-        }
-
-        test("취소 정보를 받아 저장한다.") {
-            val slot = slot<CanceledPaymentEntity>()
-
-            every {
-                canceledPaymentRepository.save(capture(slot))
-            } returns mockk()
-
-            every {
-                paymentRepository.deleteByPaymentKey(paymentKey)
-            } returns Unit
-
-            paymentWriter.createCanceled(
-                cancelReason = cancelReason,
-                cancelAmount = totalAmount,
-                canceledAt = canceledAt,
-                approvedAt = approvedAt,
-                paymentKey = paymentKey
-            )
-
-            verify(exactly = 1) { canceledPaymentRepository.save(any()) }
-            verify(exactly = 1) { paymentRepository.deleteByPaymentKey(any()) }
-
-            slot.captured.also {
-                it.paymentKey shouldBe paymentKey
-                it.cancelAmount shouldBe totalAmount
-                it.approvedAt shouldBe approvedAt
-            }
-        }
-    }
-})
diff --git a/src/test/kotlin/roomescape/payment/infrastructure/client/PaymentCancelResponseDeserializerTest.kt b/src/test/kotlin/roomescape/payment/infrastructure/client/PaymentCancelResponseDeserializerTest.kt
deleted file mode 100644
index eb4f74aa..00000000
--- a/src/test/kotlin/roomescape/payment/infrastructure/client/PaymentCancelResponseDeserializerTest.kt
+++ /dev/null
@@ -1,34 +0,0 @@
-package roomescape.payment.infrastructure.client
-
-import com.fasterxml.jackson.databind.ObjectMapper
-import com.fasterxml.jackson.databind.module.SimpleModule
-import com.fasterxml.jackson.module.kotlin.jacksonObjectMapper
-import io.kotest.assertions.assertSoftly
-import io.kotest.core.spec.style.StringSpec
-import io.kotest.matchers.shouldBe
-import roomescape.payment.web.PaymentCancelResponse
-
-class PaymentCancelResponseDeserializerTest : StringSpec({
-
-    val objectMapper: ObjectMapper = jacksonObjectMapper().registerModule(
-        SimpleModule().addDeserializer(
-            PaymentCancelResponse::class.java,
-            PaymentCancelResponseDeserializer()
-        )
-    )
-
-    "결제 취소 응답을 역직렬화하여 PaymentCancelResponse 객체를 생성한다" {
-        val cancelResponseJson: String = SampleTossPaymentConst.cancelJson
-        val cancelResponse: PaymentCancelResponse = objectMapper.readValue(
-            cancelResponseJson,
-            PaymentCancelResponse::class.java
-        )
-
-        assertSoftly(cancelResponse) {
-            cancelResponse.cancelStatus shouldBe "DONE"
-            cancelResponse.cancelReason shouldBe SampleTossPaymentConst.cancelReason
-            cancelResponse.cancelAmount shouldBe SampleTossPaymentConst.amount
-            cancelResponse.canceledAt.toString() shouldBe "2024-02-13T12:20:23+09:00"
-        }
-    }
-})
\ No newline at end of file
diff --git a/src/test/kotlin/roomescape/payment/infrastructure/client/SampleTossPaymentConst.kt b/src/test/kotlin/roomescape/payment/infrastructure/client/SampleTossPaymentConst.kt
deleted file mode 100644
index 8715c2be..00000000
--- a/src/test/kotlin/roomescape/payment/infrastructure/client/SampleTossPaymentConst.kt
+++ /dev/null
@@ -1,194 +0,0 @@
-package roomescape.payment.infrastructure.client
-
-import roomescape.payment.web.PaymentCancelRequest
-import kotlin.math.roundToLong
-
-object SampleTossPaymentConst {
-    val paymentKey: String = "5EnNZRJGvaBX7zk2yd8ydw26XvwXkLrx9POLqKQjmAw4b0e1"
-
-    val orderId: String = "MC4wODU4ODQwMzg4NDk0"
-
-    val amount: Long = 1000L
-
-    val paymentType: String = "카드"
-
-    val cancelReason: String = "테스트 결제 취소"
-
-    val paymentRequest: PaymentApproveRequest = PaymentApproveRequest(
-        paymentKey,
-        orderId,
-        amount,
-        paymentType
-    )
-
-    val paymentRequestJson: String = """
-		{
-		  "paymentKey": "$paymentKey",
-		  "orderId": "$orderId",
-		  "amount": $amount,
-		  "paymentType": "$paymentType"
-		}
-		""".trimIndent()
-
-    val cancelRequest: PaymentCancelRequest = PaymentCancelRequest(
-        paymentKey,
-        amount,
-        cancelReason
-    )
-
-    val cancelRequestJson: String = """
-		{
-		  "cancelReason": "$cancelReason"
-		}
-	""".trimIndent()
-
-    val tossPaymentErrorJson: String = """
-		{
-		    "code": "ERROR_CODE",
-		    "message": "Error message"
-		}	
-	""".trimIndent()
-
-    val confirmJson: String = """
-		{
-		  "mId": "tosspayments",
-		  "lastTransactionKey": "9C62B18EEF0DE3EB7F4422EB6D14BC6E",
-		  "paymentKey": "$paymentKey",
-		  "orderId": "$orderId",
-		  "orderName": "토스 티셔츠 외 2건",
-		  "taxExemptionAmount": 0,
-		  "status": "DONE",
-		  "requestedAt": "2024-02-13T12:17:57+09:00",
-		  "approvedAt": "2024-02-13T12:18:14+09:00",
-		  "useEscrow": false,
-		  "cultureExpense": false,
-		  "card": {
-		    "issuerCode": "71",
-		    "acquirerCode": "71",
-		    "number": "12345678****000*",
-		    "installmentPlanMonths": 0,
-		    "isInterestFree": false,
-		    "interestPayer": null,
-		    "approveNo": "00000000",
-		    "useCardPoint": false,
-		    "cardType": "신용",
-		    "ownerType": "개인",
-		    "acquireStatus": "READY",
-		    "receiptUrl": "https://dashboard.tosspayments.com/receipt/redirection?transactionId=tviva20240213121757MvuS8&ref=PX",
-		    "amount": 1000
-		  },
-		  "virtualAccount": null,
-		  "transfer": null,
-		  "mobilePhone": null,
-		  "giftCertificate": null,
-		  "cashReceipt": null,
-		  "cashReceipts": null,
-		  "discount": null,
-		  "cancels": null,
-		  "secret": null,
-		  "type": "NORMAL",
-		  "easyPay": {
-		    "provider": "토스페이",
-		    "amount": 0,
-		    "discountAmount": 0
-		  },
-		  "easyPayAmount": 0,
-		  "easyPayDiscountAmount": 0,
-		  "country": "KR",
-		  "failure": null,
-		  "isPartialCancelable": true,
-		  "receipt": {
-		    "url": "https://dashboard.tosspayments.com/receipt/redirection?transactionId=tviva20240213121757MvuS8&ref=PX"
-		  },
-		  "checkout": {
-		    "url": "https://api.tosspayments.com/v1/payments/5EnNZRJGvaBX7zk2yd8ydw26XvwXkLrx9POLqKQjmAw4b0e1/checkout"
-		  },
-		  "currency": "KRW",
-		  "totalAmount": $amount,
-		  "balanceAmount": $amount,
-		  "suppliedAmount": ${(amount / 1.1).roundToLong()},
-		  "vat": ${amount - (amount / 1.1).roundToLong()},
-		  "taxFreeAmount": 0,
-		  "method": "$paymentType",
-		  "version": "2022-11-16"
-		}
-		""".trimIndent()
-
-    val cancelJson: String = """
-		{
-		  "mId": "tosspayments",
-		  "lastTransactionKey": "090A796806E726BBB929F4A2CA7DB9A7",
-		  "paymentKey": "$paymentKey",
-		  "orderId": "$orderId",
-		  "orderName": "토스 티셔츠 외 2건",
-		  "taxExemptionAmount": 0,
-		  "status": "CANCELED",
-		  "requestedAt": "2024-02-13T12:17:57+09:00",
-		  "approvedAt": "2024-02-13T12:18:14+09:00",
-		  "useEscrow": false,
-		  "cultureExpense": false,
-		  "card": {
-		    "issuerCode": "71",
-		    "acquirerCode": "71",
-		    "number": "12345678****000*",
-		    "installmentPlanMonths": 0,
-		    "isInterestFree": false,
-		    "interestPayer": null,
-		    "approveNo": "00000000",
-		    "useCardPoint": false,
-		    "cardType": "신용",
-		    "ownerType": "개인",
-		    "acquireStatus": "READY",
-		    "amount": 1000
-		  },
-		  "virtualAccount": null,
-		  "transfer": null,
-		  "mobilePhone": null,
-		  "giftCertificate": null,
-		  "cashReceipt": null,
-		  "cashReceipts": null,
-		  "discount": null,
-		  "cancels": [
-		    {
-		      "transactionKey": "090A796806E726BBB929F4A2CA7DB9A7",
-		      "cancelReason": "$cancelReason",
-		      "taxExemptionAmount": 0,
-		      "canceledAt": "2024-02-13T12:20:23+09:00",
-		      "easyPayDiscountAmount": 0,
-		      "receiptKey": null,
-		      "cancelAmount": $amount,
-		      "taxFreeAmount": 0,
-		      "refundableAmount": 0,
-		      "cancelStatus": "DONE",
-		      "cancelRequestId": null
-		    }
-		  ],
-		  "secret": null,
-		  "type": "NORMAL",
-		  "easyPay": {
-		    "provider": "토스페이",
-		    "amount": 0,
-		    "discountAmount": 0
-		  },
-		  "easyPayAmount": 0,
-		  "easyPayDiscountAmount": 0,
-		  "country": "KR",
-		  "failure": null,
-		  "isPartialCancelable": true,
-		  "receipt": {
-		    "url": "https://dashboard.tosspayments.com/receipt/redirection?transactionId=tviva20240213121757MvuS8&ref=PX"
-		  },
-		  "checkout": {
-		    "url": "https://api.tosspayments.com/v1/payments/5EnNZRJGvaBX7zk2yd8ydw26XvwXkLrx9POLqKQjmAw4b0e1/checkout"
-		  },
-		  "currency": "KRW",
-		  "totalAmount": $amount,
-		  "balanceAmount": 0,
-		  "suppliedAmount": 0,
-		  "vat": 0,
-		  "taxFreeAmount": 0,
-		  "method": "$paymentType",
-		  "version": "2022-11-16"
-		}
-		""".trimIndent()
-}
diff --git a/src/test/kotlin/roomescape/payment/infrastructure/persistence/CanceledPaymentRepositoryTest.kt b/src/test/kotlin/roomescape/payment/infrastructure/persistence/CanceledPaymentRepositoryTest.kt
deleted file mode 100644
index 052d1eb8..00000000
--- a/src/test/kotlin/roomescape/payment/infrastructure/persistence/CanceledPaymentRepositoryTest.kt
+++ /dev/null
@@ -1,39 +0,0 @@
-package roomescape.payment.infrastructure.persistence
-
-import io.kotest.assertions.assertSoftly
-import io.kotest.core.spec.style.FunSpec
-import io.kotest.matchers.shouldBe
-import org.springframework.beans.factory.annotation.Autowired
-import org.springframework.boot.test.autoconfigure.orm.jpa.DataJpaTest
-import roomescape.common.config.next
-import roomescape.util.PaymentFixture
-import roomescape.util.TsidFactory
-import java.util.*
-
-@DataJpaTest(showSql = false)
-class CanceledPaymentRepositoryTest(
-    @Autowired val canceledPaymentRepository: CanceledPaymentRepository,
-) : FunSpec() {
-    init {
-        context("paymentKey로 CanceledPaymentEntity 조회") {
-            val paymentKey = "test-payment-key"
-            beforeTest {
-                PaymentFixture.createCanceled(id = TsidFactory.next(), paymentKey = paymentKey)
-                    .also { canceledPaymentRepository.save(it) }
-            }
-
-            test("정상 반환") {
-                canceledPaymentRepository.findByPaymentKey(paymentKey)?.let {
-                    assertSoftly(it) {
-                        this.paymentKey shouldBe paymentKey
-                    }
-                } ?: throw AssertionError("Unexpected null value")
-            }
-
-            test("null 반환") {
-                canceledPaymentRepository.findByPaymentKey(UUID.randomUUID().toString())
-                    .also { it shouldBe null }
-            }
-        }
-    }
-}
diff --git a/src/test/kotlin/roomescape/payment/infrastructure/persistence/PaymentRepositoryTest.kt b/src/test/kotlin/roomescape/payment/infrastructure/persistence/PaymentRepositoryTest.kt
deleted file mode 100644
index a58d0580..00000000
--- a/src/test/kotlin/roomescape/payment/infrastructure/persistence/PaymentRepositoryTest.kt
+++ /dev/null
@@ -1,56 +0,0 @@
-package roomescape.payment.infrastructure.persistence
-
-import io.kotest.assertions.assertSoftly
-import io.kotest.core.spec.style.FunSpec
-import io.kotest.matchers.shouldBe
-import jakarta.persistence.EntityManager
-import org.springframework.beans.factory.annotation.Autowired
-import org.springframework.boot.test.autoconfigure.orm.jpa.DataJpaTest
-import roomescape.common.config.next
-import roomescape.reservation.infrastructure.persistence.ReservationEntity
-import roomescape.util.PaymentFixture
-import roomescape.util.ReservationFixture
-import roomescape.util.TsidFactory
-
-@DataJpaTest(showSql = false)
-class PaymentRepositoryTest(
-    @Autowired val paymentRepository: PaymentRepository,
-    @Autowired val entityManager: EntityManager
-) : FunSpec() {
-
-    lateinit var reservation: ReservationEntity
-
-    init {
-        context("existsByReservationId") {
-            beforeTest {
-                reservation = setupReservation()
-                PaymentFixture.create(reservation = reservation)
-                    .also { paymentRepository.save(it) }
-            }
-
-            test("true") {
-                paymentRepository.existsByReservationId(reservation.id!!)
-                    .also { it shouldBe true }
-            }
-
-            test("false") {
-                paymentRepository.existsByReservationId(reservation.id!! + 1L)
-                    .also { it shouldBe false }
-            }
-        }
-    }
-
-    private fun setupReservation(): ReservationEntity {
-        return ReservationFixture.create(
-            id = TsidFactory.next()
-        ).also {
-            entityManager.persist(it.member)
-            entityManager.persist(it.theme)
-            entityManager.persist(it.time)
-            entityManager.persist(it)
-
-            entityManager.flush()
-            entityManager.clear()
-        }
-    }
-}
diff --git a/src/test/kotlin/roomescape/reservation/ReservationApiTest.kt b/src/test/kotlin/roomescape/reservation/ReservationApiTest.kt
new file mode 100644
index 00000000..f9589a50
--- /dev/null
+++ b/src/test/kotlin/roomescape/reservation/ReservationApiTest.kt
@@ -0,0 +1,571 @@
+package roomescape.reservation
+
+import io.kotest.matchers.shouldBe
+import org.hamcrest.CoreMatchers.equalTo
+import org.springframework.data.repository.findByIdOrNull
+import org.springframework.http.HttpStatus
+import roomescape.common.exception.CommonErrorCode
+import roomescape.member.infrastructure.persistence.Role
+import roomescape.payment.exception.PaymentErrorCode
+import roomescape.payment.infrastructure.common.BankCode
+import roomescape.payment.infrastructure.common.CardIssuerCode
+import roomescape.payment.infrastructure.common.EasyPayCompanyCode
+import roomescape.payment.infrastructure.persistence.PaymentDetailRepository
+import roomescape.reservation.exception.ReservationErrorCode
+import roomescape.reservation.infrastructure.persistence.CanceledReservationRepository
+import roomescape.reservation.infrastructure.persistence.ReservationEntity
+import roomescape.reservation.infrastructure.persistence.ReservationRepository
+import roomescape.reservation.infrastructure.persistence.ReservationStatus
+import roomescape.reservation.web.ReservationCancelRequest
+import roomescape.schedule.infrastructure.persistence.ScheduleEntity
+import roomescape.schedule.infrastructure.persistence.ScheduleRepository
+import roomescape.schedule.infrastructure.persistence.ScheduleStatus
+import roomescape.theme.infrastructure.persistence.ThemeEntity
+import roomescape.util.*
+import java.time.LocalDate
+import java.time.LocalTime
+
+class ReservationApiTest(
+    private val reservationRepository: ReservationRepository,
+    private val canceledReservationRepository: CanceledReservationRepository,
+    private val scheduleRepository: ScheduleRepository,
+    private val paymentDetailRepository: PaymentDetailRepository,
+) : FunSpecSpringbootTest() {
+
+    init {
+        context("결제 전 임시 예약을 생성한다.") {
+            val commonRequest = ReservationFixture.pendingCreateRequest
+
+            test("정상 생성") {
+                val schedule: ScheduleEntity = dummyInitializer.createSchedule(
+                    adminToken = loginUtil.loginAsAdmin(),
+                    request = ScheduleFixture.createRequest,
+                    status = ScheduleStatus.HOLD
+                )
+
+                runTest(
+                    token = loginUtil.loginAsUser(),
+                    using = {
+                        body(commonRequest.copy(scheduleId = schedule.id))
+                    },
+                    on = {
+                        post("/reservations/pending")
+                    },
+                    expect = {
+                        statusCode(HttpStatus.OK.value())
+                    }
+                ).also {
+                    val reservation: ReservationEntity =
+                        reservationRepository.findByIdOrNull(it.extract().path("data.id"))
+                            ?: throw AssertionError("Unexpected Exception Occurred.")
+
+                    reservation.status shouldBe ReservationStatus.PENDING
+                    reservation.scheduleId shouldBe schedule.id
+                    reservation.reserverName shouldBe commonRequest.reserverName
+                }
+            }
+
+            test("예약을 생성할 때 해당 일정이 ${ScheduleStatus.HOLD} 상태가 아니면 실패한다.") {
+                val schedule: ScheduleEntity = dummyInitializer.createSchedule(
+                    adminToken = loginUtil.loginAsAdmin(),
+                    request = ScheduleFixture.createRequest,
+                    status = ScheduleStatus.AVAILABLE
+                )
+
+                runTest(
+                    token = loginUtil.loginAsUser(),
+                    using = {
+                        body(commonRequest.copy(scheduleId = schedule.id))
+                    },
+                    on = {
+                        post("/reservations/pending")
+                    },
+                    expect = {
+                        statusCode(HttpStatus.BAD_REQUEST.value())
+                        body("code", equalTo(ReservationErrorCode.SCHEDULE_NOT_HOLD.errorCode))
+                    }
+                )
+            }
+
+            test("예약 인원이 테마의 최소 인원보다 작거나 최대 인원보다 많으면 실패한다.") {
+                val adminToken = loginUtil.loginAsAdmin()
+                val theme: ThemeEntity = dummyInitializer.createTheme(
+                    adminToken = adminToken,
+                    request = ThemeFixture.createRequest
+                )
+
+                val schedule: ScheduleEntity = dummyInitializer.createSchedule(
+                    adminToken = adminToken,
+                    request = ScheduleFixture.createRequest.copy(themeId = theme.id),
+                    status = ScheduleStatus.HOLD
+                )
+
+                runTest(
+                    token = loginUtil.loginAsUser(),
+                    using = {
+                        body(
+                            commonRequest.copy(
+                                scheduleId = schedule.id,
+                                participantCount = ((theme.minParticipants - 1).toShort())
+                            )
+                        )
+                    },
+                    on = {
+                        post("/reservations/pending")
+                    },
+                    expect = {
+                        statusCode(HttpStatus.BAD_REQUEST.value())
+                        body("code", equalTo(ReservationErrorCode.INVALID_PARTICIPANT_COUNT.errorCode))
+                    }
+                )
+
+                runTest(
+                    token = loginUtil.loginAsUser(),
+                    using = {
+                        body(
+                            commonRequest.copy(
+                                scheduleId = schedule.id,
+                                participantCount = ((theme.maxParticipants + 1).toShort())
+                            )
+                        )
+                    },
+                    on = {
+                        post("/reservations/pending")
+                    },
+                    expect = {
+                        statusCode(HttpStatus.BAD_REQUEST.value())
+                        body("code", equalTo(ReservationErrorCode.INVALID_PARTICIPANT_COUNT.errorCode))
+                    }
+                )
+            }
+
+            context("필수 입력값이 입력되지 않으면 실패한다.") {
+                test("예약자명") {
+                    runTest(
+                        token = loginUtil.loginAsUser(),
+                        using = {
+                            body(commonRequest.copy(reserverName = ""))
+                        },
+                        on = {
+                            post("/reservations/pending")
+                        },
+                        expect = {
+                            statusCode(HttpStatus.BAD_REQUEST.value())
+                            body("code", equalTo(CommonErrorCode.INVALID_INPUT_VALUE.errorCode))
+                        }
+                    )
+                }
+
+                test("예약자 연락처") {
+                    runTest(
+                        token = loginUtil.loginAsUser(),
+                        using = {
+                            body(commonRequest.copy(reserverContact = ""))
+                        },
+                        on = {
+                            post("/reservations/pending")
+                        },
+                        expect = {
+                            statusCode(HttpStatus.BAD_REQUEST.value())
+                            body("code", equalTo(CommonErrorCode.INVALID_INPUT_VALUE.errorCode))
+                        }
+                    )
+                }
+            }
+        }
+
+        context("예약을 확정한다.") {
+            test("정상 응답") {
+                val userToken = loginUtil.loginAsUser()
+
+                val reservation: ReservationEntity = dummyInitializer.createPendingReservation(
+                    adminToken = loginUtil.loginAsAdmin(),
+                    reserverToken = userToken,
+                )
+
+                runTest(
+                    token = userToken,
+                    on = {
+                        post("/reservations/${reservation.id}/confirm")
+                    },
+                    expect = {
+                        statusCode(HttpStatus.OK.value())
+                    }
+                ).also {
+                    val updatedReservation = reservationRepository.findByIdOrNull(reservation.id)
+                        ?: throw AssertionError("Unexpected Exception Occurred.")
+
+                    val updatedSchedule = scheduleRepository.findByIdOrNull(updatedReservation.scheduleId)
+                        ?: throw AssertionError("Unexpected Exception Occurred.")
+
+                    updatedSchedule.status shouldBe ScheduleStatus.RESERVED
+                    updatedReservation.status shouldBe ReservationStatus.CONFIRMED
+                }
+            }
+
+            test("예약이 없으면 실패한다.") {
+                runTest(
+                    token = loginUtil.loginAsUser(),
+                    on = {
+                        post("/reservations/$INVALID_PK/confirm")
+                    },
+                    expect = {
+                        statusCode(HttpStatus.NOT_FOUND.value())
+                        body("code", equalTo(ReservationErrorCode.RESERVATION_NOT_FOUND.errorCode))
+                    }
+                )
+            }
+        }
+
+        context("예약을 취소한다.") {
+            test("정상 응답") {
+                val userToken = loginUtil.loginAsUser()
+
+                val reservation: ReservationEntity = dummyInitializer.createConfirmReservation(
+                    adminToken = loginUtil.loginAsAdmin(),
+                    reserverToken = userToken,
+                )
+
+                runTest(
+                    token = userToken,
+                    using = {
+                        body(ReservationCancelRequest(cancelReason = "test"))
+                    },
+                    on = {
+                        post("/reservations/${reservation.id}/cancel")
+                    },
+                    expect = {
+                        statusCode(HttpStatus.OK.value())
+                    }
+                ).also {
+                    val updatedReservation = reservationRepository.findByIdOrNull(reservation.id)
+                        ?: throw AssertionError("Unexpected Exception Occurred.")
+                    val updatedSchedule = scheduleRepository.findByIdOrNull(updatedReservation.scheduleId)
+                        ?: throw AssertionError("Unexpected Exception Occurred.")
+
+                    updatedReservation.status shouldBe ReservationStatus.CANCELED
+                    updatedSchedule.status shouldBe ScheduleStatus.AVAILABLE
+                    canceledReservationRepository.findAll()[0].reservationId shouldBe updatedReservation.id
+                }
+            }
+
+            test("예약이 없으면 실패한다.") {
+                runTest(
+                    token = loginUtil.loginAsUser(),
+                    using = {
+                        body(ReservationCancelRequest(cancelReason = "test"))
+                    },
+                    on = {
+                        post("/reservations/$INVALID_PK/cancel")
+                    },
+                    expect = {
+                        statusCode(HttpStatus.NOT_FOUND.value())
+                        body("code", equalTo(ReservationErrorCode.RESERVATION_NOT_FOUND.errorCode))
+                    }
+                )
+            }
+
+            test("관리자가 아닌 회원은 다른 회원의 예약을 취소할 수 없다.") {
+                val reservation: ReservationEntity = dummyInitializer.createConfirmReservation(
+                    adminToken = loginUtil.loginAsAdmin(),
+                    reserverToken = loginUtil.loginAsUser(),
+                )
+
+                val otherUserToken = loginUtil.login("other@example.com", "other", role = Role.MEMBER)
+
+                runTest(
+                    token = otherUserToken,
+                    using = {
+                        body(ReservationCancelRequest(cancelReason = "test"))
+                    },
+                    on = {
+                        post("/reservations/${reservation.id}/cancel")
+                    },
+                    expect = {
+                        statusCode(HttpStatus.FORBIDDEN.value())
+                        body("code", equalTo(ReservationErrorCode.NO_PERMISSION_TO_CANCEL_RESERVATION.errorCode))
+                    }
+                )
+            }
+
+            test("관리자는 다른 회원의 예약을 취소할 수 있다.") {
+                val reservation: ReservationEntity = dummyInitializer.createConfirmReservation(
+                    adminToken = loginUtil.loginAsAdmin(),
+                    reserverToken = loginUtil.loginAsAdmin(),
+                )
+
+                val otherAdminToken = loginUtil.login("admin1@example.com", "admin1", role = Role.ADMIN)
+
+                runTest(
+                    token = otherAdminToken,
+                    using = {
+                        body(ReservationCancelRequest(cancelReason = "test"))
+                    },
+                    on = {
+                        post("/reservations/${reservation.id}/cancel")
+                    },
+                    expect = {
+                        statusCode(HttpStatus.OK.value())
+                    }
+                ).also {
+                    val updatedReservation = reservationRepository.findByIdOrNull(reservation.id)
+                        ?: throw AssertionError("Unexpected Exception Occurred.")
+                    val updatedSchedule = scheduleRepository.findByIdOrNull(updatedReservation.scheduleId)
+                        ?: throw AssertionError("Unexpected Exception Occurred.")
+
+                    updatedSchedule.status shouldBe ScheduleStatus.AVAILABLE
+                    updatedReservation.status shouldBe ReservationStatus.CANCELED
+                    canceledReservationRepository.findAll()[0].reservationId shouldBe updatedReservation.id
+                }
+            }
+        }
+
+        context("나의 예약 목록을 조회한다.") {
+            test("정상 응답") {
+                val userToken = loginUtil.loginAsUser()
+                val adminToken = loginUtil.loginAsAdmin()
+
+                for (i in 1..3) {
+                    dummyInitializer.createConfirmReservation(
+                        adminToken = adminToken,
+                        reserverToken = userToken,
+                        themeRequest = ThemeFixture.createRequest.copy(name = "theme-$i"),
+                        scheduleRequest = ScheduleFixture.createRequest.copy(
+                            date = LocalDate.now().plusDays(i.toLong()),
+                            time = LocalTime.now().plusHours(i.toLong())
+                        )
+                    )
+                }
+
+                runTest(
+                    token = userToken,
+                    on = {
+                        get("/reservations/summary")
+                    },
+                    expect = {
+                        statusCode(HttpStatus.OK.value())
+                        body("data.reservations.size()", equalTo(3))
+                        assertProperties(
+                            props = setOf("id", "themeName", "date", "startAt", "status"),
+                            propsNameIfList = "reservations"
+                        )
+                    }
+                )
+            }
+        }
+
+        context("예약 상세 정보를 조회한다.") {
+            context("정상 응답") {
+                val commonPaymentRequest = PaymentFixture.confirmRequest
+
+                lateinit var reservation: ReservationEntity
+
+                beforeTest {
+                    reservation = dummyInitializer.createConfirmReservation(
+                        adminToken = loginUtil.loginAsAdmin(),
+                        reserverToken = loginUtil.loginAsUser(),
+                    )
+                }
+
+                test("카드 결제") {
+                    dummyInitializer.createPayment(
+                        reservationId = reservation.id,
+                        request = commonPaymentRequest,
+                        cardDetail = PaymentFixture.cardDetail(
+                            amount = commonPaymentRequest.amount,
+                            issuerCode = CardIssuerCode.SHINHAN
+                        )
+                    )
+
+                    runDetailRetrieveTest(reservation).also {
+                        it["method"] shouldBe "카드"
+
+                        with(it.get("detail") as LinkedHashMap<*, *>) {
+                            this["type"] shouldBe "CARD"
+                            this["issuerCode"] shouldBe "신한"
+                        }
+                    }
+                }
+
+                test("카드 + 간편결제") {
+                    dummyInitializer.createPayment(
+                        reservationId = reservation.id,
+                        request = commonPaymentRequest,
+                        easyPayDetail = PaymentFixture.easypayDetail(
+                            amount = 0,
+                            provider = EasyPayCompanyCode.TOSSPAY,
+                        ),
+                        cardDetail = PaymentFixture.cardDetail(
+                            amount = commonPaymentRequest.amount,
+                        )
+                    )
+
+                    runDetailRetrieveTest(reservation).also {
+                        it["method"] shouldBe "간편결제"
+
+                        with(it.get("detail") as LinkedHashMap<*, *>) {
+                            this["type"] shouldBe "CARD"
+                            this["easypayProviderName"] shouldBe "토스페이"
+                        }
+                    }
+                }
+
+                test("결제 취소 / 카드 + 간편결제 + 포인트 사용") {
+                    val point = 5_000
+
+                    dummyInitializer.createPayment(
+                        reservationId = reservation.id,
+                        request = commonPaymentRequest,
+                        easyPayDetail = PaymentFixture.easypayDetail(
+                            amount = 0,
+                            provider = EasyPayCompanyCode.TOSSPAY,
+                            discountAmount = point,
+                        ),
+                        cardDetail = PaymentFixture.cardDetail(
+                            amount = commonPaymentRequest.amount,
+                            issuerCode = CardIssuerCode.SHINHAN
+                        )
+                    )
+
+                    val cancelReason = "테스트입니다."
+                    val memberId = loginUtil.getUser().id!!
+
+                    dummyInitializer.cancelPayment(
+                        memberId = memberId,
+                        reservationId = reservation.id,
+                        cancelReason = cancelReason,
+                    )
+
+                    runDetailRetrieveTest(reservation).also {
+                        it["method"] shouldBe "간편결제"
+
+                        with(it.get("detail") as LinkedHashMap<*, *>) {
+                            this["type"] shouldBe "CARD"
+                            this["issuerCode"] shouldBe "신한"
+                            this["easypayProviderName"] shouldBe "토스페이"
+                            this["easypayDiscountAmount"] shouldBe point
+                        }
+
+                        with((it.get("cancel") as LinkedHashMap<*, *>)) {
+                            this["cancelReason"] shouldBe cancelReason
+                            this["canceledBy"] shouldBe memberId
+                        }
+                    }
+                }
+
+                test("간편결제 선불충전금액 사용") {
+                    dummyInitializer.createPayment(
+                        reservationId = reservation.id,
+                        request = commonPaymentRequest,
+                        easyPayDetail = PaymentFixture.easypayDetail(
+                            amount = commonPaymentRequest.amount,
+                            provider = EasyPayCompanyCode.TOSSPAY,
+                        ),
+                    )
+
+                    runDetailRetrieveTest(reservation).also {
+                        it["method"] shouldBe "간편결제"
+
+                        with(it.get("detail") as LinkedHashMap<*, *>) {
+                            this["type"] shouldBe "EASYPAY_PREPAID"
+                            this["providerName"] shouldBe "토스페이"
+                        }
+                    }
+                }
+
+                test("계좌이체 사용") {
+                    dummyInitializer.createPayment(
+                        reservationId = reservation.id,
+                        request = commonPaymentRequest,
+                        transferDetail = PaymentFixture.transferDetail(
+                            bankCode = BankCode.SHINHAN
+                        )
+                    )
+
+                    runDetailRetrieveTest(reservation).also {
+                        it["method"] shouldBe "계좌이체"
+
+                        with(it.get("detail") as LinkedHashMap<*, *>) {
+                            this["type"] shouldBe "BANK_TRANSFER"
+                            this["bankName"] shouldBe "신한"
+                        }
+                    }
+                }
+            }
+
+            test("예약이 없으면 실패한다.") {
+                runTest(
+                    token = loginUtil.loginAsUser(),
+                    on = {
+                        get("/reservations/$INVALID_PK/detail")
+                    },
+                    expect = {
+                        statusCode(HttpStatus.NOT_FOUND.value())
+                        body("code", equalTo(ReservationErrorCode.RESERVATION_NOT_FOUND.errorCode))
+                    }
+                )
+            }
+
+            test("예약은 있지만, 결제 정보가 없으면 실패한다.") {
+                val reservation = dummyInitializer.createConfirmReservation(
+                    adminToken = loginUtil.loginAsAdmin(),
+                    reserverToken = loginUtil.loginAsUser(),
+                )
+
+                runTest(
+                    token = loginUtil.loginAsUser(),
+                    on = {
+                        get("/reservations/${reservation.id}/detail")
+                    },
+                    expect = {
+                        statusCode(HttpStatus.NOT_FOUND.value())
+                        body("code", equalTo(PaymentErrorCode.PAYMENT_NOT_FOUND.errorCode))
+                    }
+                )
+            }
+
+            test("예약과 결제는 있지만, 결제 세부 내역이 없으면 실패한다.") {
+                val reservation = dummyInitializer.createConfirmReservation(
+                    adminToken = loginUtil.loginAsAdmin(),
+                    reserverToken = loginUtil.loginAsUser(),
+                )
+
+                dummyInitializer.createPayment(
+                    reservationId = reservation.id,
+                    easyPayDetail = PaymentFixture.easypayDetail(amount = 100_000)
+                ).also {
+                    paymentDetailRepository.deleteAll()
+                }
+
+                runTest(
+                    token = loginUtil.loginAsUser(),
+                    on = {
+                        get("/reservations/${reservation.id}/detail")
+                    },
+                    expect = {
+                        statusCode(HttpStatus.NOT_FOUND.value())
+                        body("code", equalTo(PaymentErrorCode.PAYMENT_DETAIL_NOT_FOUND.errorCode))
+                    }
+                )
+            }
+        }
+    }
+
+    fun runDetailRetrieveTest(
+        reservation: ReservationEntity
+    ): LinkedHashMap<String, Any> {
+        return runTest(
+            token = loginUtil.loginAsUser(),
+            on = {
+                get("/reservations/${reservation.id}/detail")
+            },
+            expect = {
+                statusCode(HttpStatus.OK.value())
+                assertProperties(props = setOf("id", "member", "applicationDateTime", "payment"))
+            }
+        ).also {
+            it.extract().path<Long>("data.id") shouldBe reservation.id
+            it.extract().path<Long>("data.member.id") shouldBe reservation.memberId
+        }.extract().path("data.payment")
+    }
+}
diff --git a/src/test/kotlin/roomescape/reservation/business/ReservationCommandServiceTest.kt b/src/test/kotlin/roomescape/reservation/business/ReservationCommandServiceTest.kt
deleted file mode 100644
index d75b2366..00000000
--- a/src/test/kotlin/roomescape/reservation/business/ReservationCommandServiceTest.kt
+++ /dev/null
@@ -1,284 +0,0 @@
-package roomescape.reservation.business
-
-import io.kotest.assertions.assertSoftly
-import io.kotest.assertions.throwables.shouldNotThrow
-import io.kotest.assertions.throwables.shouldThrow
-import io.kotest.core.spec.style.FunSpec
-import io.kotest.matchers.shouldBe
-import io.mockk.*
-import roomescape.reservation.exception.ReservationErrorCode
-import roomescape.reservation.exception.ReservationException
-import roomescape.reservation.implement.ReservationFinder
-import roomescape.reservation.implement.ReservationWriter
-import roomescape.reservation.infrastructure.persistence.ReservationStatus
-import roomescape.util.MemberFixture
-import roomescape.util.ReservationFixture
-import roomescape.util.ThemeFixture
-import roomescape.util.TimeFixture
-
-class ReservationCommandServiceTest : FunSpec({
-
-    val reservationFinder: ReservationFinder = mockk()
-    val reservationWriter: ReservationWriter = mockk()
-    val reservationWriteService = ReservationWriteService(reservationFinder, reservationWriter)
-
-    context("createReservationWithPayment") {
-        val request = ReservationFixture.createRequest()
-        val memberId = 1L
-
-        test("정상 응답") {
-            val createdReservation = ReservationFixture.create(
-                date = request.date,
-                time = TimeFixture.create(id = request.timeId),
-                theme = ThemeFixture.create(id = request.themeId),
-                member = MemberFixture.create(id = memberId),
-                status = ReservationStatus.CONFIRMED
-            )
-
-            every {
-                reservationWriter.create(
-                    date = request.date,
-                    timeId = request.timeId,
-                    themeId = request.themeId,
-                    status = ReservationStatus.CONFIRMED,
-                    memberId = memberId,
-                    requesterId = memberId
-                )
-            } returns createdReservation
-
-            val result = reservationWriteService.createReservationWithPayment(request, memberId)
-
-            assertSoftly(result) {
-                this.date shouldBe request.date
-                this.time.id shouldBe request.timeId
-                this.theme.id shouldBe request.themeId
-                this.member.id shouldBe memberId
-                this.status shouldBe ReservationStatus.CONFIRMED
-            }
-        }
-
-        test("예약 생성에 실패하면 예외 응답") {
-            every {
-                reservationWriter.create(any(), any(), any(), any(), any(), any())
-            } throws ReservationException(ReservationErrorCode.RESERVATION_DUPLICATED)
-
-            shouldThrow<ReservationException> {
-                reservationWriteService.createReservationWithPayment(request, memberId)
-            }.also {
-                it.errorCode shouldBe ReservationErrorCode.RESERVATION_DUPLICATED
-            }
-        }
-    }
-
-    context("createReservationByAdmin") {
-        val request = ReservationFixture.createAdminRequest()
-        val adminId = request.memberId + 1
-
-        test("정상 응답") {
-            val createdReservation = ReservationFixture.create(
-                date = request.date,
-                time = TimeFixture.create(id = request.timeId),
-                theme = ThemeFixture.create(id = request.themeId),
-                member = MemberFixture.create(id = request.memberId),
-                status = ReservationStatus.CONFIRMED_PAYMENT_REQUIRED
-            )
-
-            every {
-                reservationWriter.create(
-                    date = request.date,
-                    timeId = request.timeId,
-                    themeId = request.themeId,
-                    status = ReservationStatus.CONFIRMED_PAYMENT_REQUIRED,
-                    memberId = request.memberId,
-                    requesterId = adminId
-                )
-            } returns createdReservation
-
-            val response = reservationWriteService.createReservationByAdmin(request, adminId)
-
-            assertSoftly(response) {
-                this.date shouldBe request.date
-                this.time.id shouldBe request.timeId
-                this.theme.id shouldBe request.themeId
-                this.member.id shouldBe request.memberId
-                this.status shouldBe ReservationStatus.CONFIRMED_PAYMENT_REQUIRED
-            }
-        }
-    }
-
-    context("createWaiting") {
-        val request = ReservationFixture.createWaitingRequest()
-        val memberId = 1L
-
-        test("정상 응답") {
-            val createdWaiting = ReservationFixture.create(
-                date = request.date,
-                time = TimeFixture.create(id = request.timeId),
-                theme = ThemeFixture.create(id = request.themeId),
-                member = MemberFixture.create(id = memberId),
-                status = ReservationStatus.WAITING
-            )
-
-            every {
-                reservationWriter.create(
-                    date = request.date,
-                    timeId = request.timeId,
-                    themeId = request.themeId,
-                    status = ReservationStatus.WAITING,
-                    memberId = memberId,
-                    requesterId = memberId
-                )
-            } returns createdWaiting
-
-            val response = reservationWriteService.createWaiting(request, memberId)
-
-            assertSoftly(response) {
-                this.date shouldBe request.date
-                this.time.id shouldBe request.timeId
-                this.theme.id shouldBe request.themeId
-                this.member.id shouldBe memberId
-                this.status shouldBe ReservationStatus.WAITING
-            }
-        }
-
-        test("이미 예약한 내역이 있으면 예외 응답") {
-            every {
-                reservationWriter.create(any(), any(), any(), any(), any(), any())
-            } throws ReservationException(ReservationErrorCode.ALREADY_RESERVE)
-
-            shouldThrow<ReservationException> {
-                reservationWriteService.createWaiting(request, memberId)
-            }.also {
-                it.errorCode shouldBe ReservationErrorCode.ALREADY_RESERVE
-            }
-        }
-    }
-
-    context("deleteReservation") {
-        val reservationId = 1L
-        val memberId = 1L
-        val reservation = ReservationFixture.create(id = reservationId, member = MemberFixture.create(id = memberId))
-
-        test("정상 응답") {
-            every { reservationFinder.findById(reservationId) } returns reservation
-            every { reservationWriter.deleteConfirmed(reservation, memberId) } just Runs
-
-            shouldNotThrow<Exception> {
-                reservationWriteService.deleteReservation(reservationId, memberId)
-            }
-
-            verify(exactly = 1) { reservationWriter.deleteConfirmed(reservation, memberId) }
-        }
-
-        test("예약을 찾을 수 없으면 예외 응답") {
-            every {
-                reservationFinder.findById(reservationId)
-            } throws ReservationException(ReservationErrorCode.RESERVATION_NOT_FOUND)
-
-            shouldThrow<ReservationException> {
-                reservationWriteService.deleteReservation(reservationId, memberId)
-            }.also {
-                it.errorCode shouldBe ReservationErrorCode.RESERVATION_NOT_FOUND
-            }
-        }
-
-        test("삭제하려는 회원이 관리자가 아니고, 대기한 회원과 다르면 예외 응답") {
-            every { reservationFinder.findById(reservationId) } returns reservation
-            every {
-                reservationWriter.deleteConfirmed(reservation, memberId)
-            } throws ReservationException(ReservationErrorCode.NOT_RESERVATION_OWNER)
-
-            shouldThrow<ReservationException> {
-                reservationWriteService.deleteReservation(reservationId, memberId)
-            }.also {
-                it.errorCode shouldBe ReservationErrorCode.NOT_RESERVATION_OWNER
-            }
-        }
-    }
-
-    context("confirmWaiting") {
-        val reservationId = 1L
-        val memberId = 99L // Admin
-
-        test("정상 응답") {
-            every { reservationWriter.confirm(reservationId) } just Runs
-
-            shouldNotThrow<Exception> {
-                reservationWriteService.confirmWaiting(reservationId, memberId)
-            }
-
-            verify(exactly = 1) { reservationWriter.confirm(reservationId) }
-        }
-
-        test("이미 확정된 예약이 있으면 예외 응답") {
-            every {
-                reservationWriter.confirm(reservationId)
-            } throws ReservationException(ReservationErrorCode.CONFIRMED_RESERVATION_ALREADY_EXISTS)
-
-            shouldThrow<ReservationException> {
-                reservationWriteService.confirmWaiting(reservationId, memberId)
-            }.also {
-                it.errorCode shouldBe ReservationErrorCode.CONFIRMED_RESERVATION_ALREADY_EXISTS
-            }
-        }
-    }
-
-    context("deleteWaiting") {
-        val reservationId = 1L
-        val memberId = 1L
-        val waitingReservation = ReservationFixture.create(
-            id = reservationId,
-            member = MemberFixture.create(id = memberId),
-            status = ReservationStatus.WAITING
-        )
-
-        test("정상 응답") {
-            every { reservationFinder.findById(reservationId) } returns waitingReservation
-            every { reservationWriter.deleteWaiting(waitingReservation, memberId) } just Runs
-
-            shouldNotThrow<Exception> {
-                reservationWriteService.deleteWaiting(reservationId, memberId)
-            }
-
-            verify(exactly = 1) { reservationWriter.deleteWaiting(waitingReservation, memberId) }
-        }
-
-        test("예약을 찾을 수 없으면 예외 응답") {
-            every {
-                reservationFinder.findById(reservationId)
-            } throws ReservationException(ReservationErrorCode.RESERVATION_NOT_FOUND)
-
-            shouldThrow< ReservationException> {
-                reservationWriteService.deleteWaiting(reservationId, memberId)
-            }.also {
-                it.errorCode shouldBe ReservationErrorCode.RESERVATION_NOT_FOUND
-            }
-        }
-
-        test("대기 상태가 아니면 예외 응답") {
-            every { reservationFinder.findById(reservationId) } returns waitingReservation
-            every {
-                reservationWriter.deleteWaiting(waitingReservation, memberId)
-            } throws ReservationException(ReservationErrorCode.ALREADY_CONFIRMED)
-
-            shouldThrow<ReservationException> {
-                reservationWriteService.deleteWaiting(reservationId, memberId)
-            }.also {
-                it.errorCode shouldBe ReservationErrorCode.ALREADY_CONFIRMED
-            }
-        }
-
-        test("삭제하려는 회원이 관리자가 아니고, 대기한 회원과 다르면 예외 응답") {
-            every { reservationFinder.findById(reservationId) } returns waitingReservation
-            every {
-                reservationWriter.deleteWaiting(waitingReservation, memberId)
-            } throws ReservationException(ReservationErrorCode.NOT_RESERVATION_OWNER)
-
-            shouldThrow<ReservationException> {
-                reservationWriteService.deleteWaiting(reservationId, memberId)
-            }.also {
-                it.errorCode shouldBe ReservationErrorCode.NOT_RESERVATION_OWNER
-            }
-        }
-    }
-})
diff --git a/src/test/kotlin/roomescape/reservation/business/ReservationQueryServiceTest.kt b/src/test/kotlin/roomescape/reservation/business/ReservationQueryServiceTest.kt
deleted file mode 100644
index 782b149c..00000000
--- a/src/test/kotlin/roomescape/reservation/business/ReservationQueryServiceTest.kt
+++ /dev/null
@@ -1,118 +0,0 @@
-package roomescape.reservation.business
-
-import io.kotest.assertions.assertSoftly
-import io.kotest.assertions.throwables.shouldThrow
-import io.kotest.core.spec.style.FunSpec
-import io.kotest.matchers.collections.shouldHaveSize
-import io.kotest.matchers.shouldBe
-import io.mockk.every
-import io.mockk.mockk
-import roomescape.reservation.exception.ReservationErrorCode
-import roomescape.reservation.exception.ReservationException
-import roomescape.reservation.implement.ReservationFinder
-import roomescape.reservation.infrastructure.persistence.ReservationStatus
-import roomescape.reservation.web.MyReservationRetrieveResponse
-import roomescape.util.MemberFixture
-import roomescape.util.ReservationFixture
-import roomescape.util.ThemeFixture
-import java.time.LocalDate
-
-class ReservationQueryServiceTest : FunSpec({
-
-    val reservationFinder: ReservationFinder = mockk()
-    val reservationFindService = ReservationFindService(reservationFinder)
-
-    context("findReservations") {
-        test("정상 응답") {
-            val confirmedReservations = listOf(
-                ReservationFixture.create(status = ReservationStatus.CONFIRMED),
-                ReservationFixture.create(status = ReservationStatus.CONFIRMED_PAYMENT_REQUIRED)
-            )
-            every {
-                reservationFinder.findAllByStatuses(*ReservationStatus.confirmedStatus())
-            } returns confirmedReservations
-
-            val response = reservationFindService.findReservations()
-
-            assertSoftly(response.reservations) {
-                this shouldHaveSize 2
-            }
-        }
-    }
-
-    context("findAllWaiting") {
-        test("정상 응답") {
-            val waitingReservations = listOf(
-                ReservationFixture.create(status = ReservationStatus.WAITING),
-                ReservationFixture.create(status = ReservationStatus.WAITING)
-            )
-            every {
-                reservationFinder.findAllByStatuses(ReservationStatus.WAITING)
-            } returns waitingReservations
-
-            val response = reservationFindService.findAllWaiting()
-
-            assertSoftly(response.reservations) {
-                this shouldHaveSize 2
-            }
-        }
-    }
-
-    context("findReservationsByMemberId") {
-        val memberId = 1L
-        test("정상 응답") {
-            val myReservations = listOf<MyReservationRetrieveResponse>(mockk(), mockk())
-
-            every {
-                reservationFinder.findAllByMemberId(memberId)
-            } returns myReservations
-
-            val response = reservationFindService.findReservationsByMemberId(memberId)
-
-            response.reservations shouldHaveSize 2
-        }
-    }
-
-    context("searchReservations") {
-        val themeId = 1L
-        val memberId = 1L
-        val startFrom = LocalDate.now()
-        val endAt = LocalDate.now().plusDays(1)
-
-        test("정상 응답") {
-            val searchedReservations = listOf(
-                ReservationFixture.create(
-                    theme = ThemeFixture.create(themeId),
-                    member = MemberFixture.create(memberId),
-                    date = startFrom
-                )
-            )
-
-            every {
-                reservationFinder.searchReservations(themeId, memberId, startFrom, endAt)
-            } returns searchedReservations
-
-            val response = reservationFindService.searchReservations(themeId, memberId, startFrom, endAt)
-
-            assertSoftly(response.reservations) {
-                this shouldHaveSize 1
-                this[0].theme.id shouldBe themeId
-                this[0].member.id shouldBe memberId
-                this[0].date shouldBe startFrom
-            }
-        }
-
-        test("종료 날짜가 시작 날짜 이전이면 예외 응답") {
-            val invalidEndAt = startFrom.minusDays(1)
-            every {
-                reservationFinder.searchReservations(themeId, memberId, startFrom, invalidEndAt)
-            } throws ReservationException(ReservationErrorCode.INVALID_SEARCH_DATE_RANGE)
-
-            shouldThrow<ReservationException> {
-                reservationFindService.searchReservations(themeId, memberId, startFrom, invalidEndAt)
-            }.also {
-                it.errorCode shouldBe ReservationErrorCode.INVALID_SEARCH_DATE_RANGE
-            }
-        }
-    }
-})
diff --git a/src/test/kotlin/roomescape/reservation/business/ReservationWithPaymentServiceTest.kt b/src/test/kotlin/roomescape/reservation/business/ReservationWithPaymentServiceTest.kt
deleted file mode 100644
index b3d0ed60..00000000
--- a/src/test/kotlin/roomescape/reservation/business/ReservationWithPaymentServiceTest.kt
+++ /dev/null
@@ -1,122 +0,0 @@
-package roomescape.reservation.business
-
-import io.kotest.assertions.assertSoftly
-import io.kotest.core.spec.style.FunSpec
-import io.kotest.matchers.shouldBe
-import io.mockk.Runs
-import io.mockk.every
-import io.mockk.just
-import io.mockk.mockk
-import roomescape.payment.business.PaymentService
-import roomescape.payment.infrastructure.persistence.PaymentEntity
-import roomescape.payment.web.PaymentCancelRequest
-import roomescape.payment.web.toCreateResponse
-import roomescape.reservation.infrastructure.persistence.ReservationEntity
-import roomescape.reservation.infrastructure.persistence.ReservationStatus
-import roomescape.reservation.web.ReservationCreateResponse
-import roomescape.reservation.web.ReservationCreateWithPaymentRequest
-import roomescape.util.*
-
-class ReservationWithPaymentServiceTest : FunSpec({
-    val reservationService: ReservationWriteService = mockk()
-    val paymentService: PaymentService = mockk()
-
-    val reservationWithPaymentService = ReservationWithPaymentService(
-        reservationWriteService = reservationService,
-        paymentService = paymentService
-    )
-
-    val reservationCreateWithPaymentRequest: ReservationCreateWithPaymentRequest = ReservationFixture.createRequest()
-    val paymentApproveResponse = PaymentFixture.createApproveResponse()
-    val memberId = 1L
-    val reservationEntity: ReservationEntity = ReservationFixture.create(
-        id = 1L,
-        date = reservationCreateWithPaymentRequest.date,
-        time = TimeFixture.create(id = reservationCreateWithPaymentRequest.timeId),
-        theme = ThemeFixture.create(id = reservationCreateWithPaymentRequest.themeId),
-        member = MemberFixture.create(id = memberId),
-        status = ReservationStatus.CONFIRMED
-    )
-    val paymentEntity: PaymentEntity = PaymentFixture.create(
-        id = 1L,
-        orderId = reservationCreateWithPaymentRequest.orderId,
-        paymentKey = reservationCreateWithPaymentRequest.paymentKey,
-        totalAmount = reservationCreateWithPaymentRequest.amount,
-        reservation = reservationEntity,
-    )
-
-    context("addReservationWithPayment") {
-        test("예약 및 결제 정보를 저장한다.") {
-            every {
-                reservationService.createReservationWithPayment(reservationCreateWithPaymentRequest, memberId)
-            } returns reservationEntity
-
-            every {
-                paymentService.createPayment(paymentApproveResponse, reservationEntity)
-            } returns paymentEntity.toCreateResponse()
-
-            val result: ReservationCreateResponse = reservationWithPaymentService.createReservationAndPayment(
-                request = reservationCreateWithPaymentRequest,
-                approvedPaymentInfo = paymentApproveResponse,
-                memberId = memberId
-            )
-
-            assertSoftly(result) {
-                this.id shouldBe reservationEntity.id
-                this.date shouldBe reservationEntity.date
-                this.member.id shouldBe reservationEntity.member.id
-                this.time.id shouldBe reservationEntity.time.id
-                this.theme.id shouldBe reservationEntity.theme.id
-                this.status shouldBe ReservationStatus.CONFIRMED
-            }
-        }
-
-
-        context("removeReservationWithPayment") {
-            test("예약 및 결제 정보를 삭제하고, 결제 취소 정보를 저장한다.") {
-                val paymentCancelRequest: PaymentCancelRequest = PaymentFixture.createCancelRequest().copy(
-                    paymentKey = paymentEntity.paymentKey,
-                    amount = paymentEntity.totalAmount,
-                    cancelReason = "고객 요청"
-                )
-
-                every {
-                    paymentService.createCanceledPayment(reservationEntity.id!!)
-                } returns paymentCancelRequest
-
-                every {
-                    reservationService.deleteReservation(reservationEntity.id!!, reservationEntity.member.id!!)
-                } just Runs
-
-                val result: PaymentCancelRequest = reservationWithPaymentService.deleteReservationAndPayment(
-                    reservationId = reservationEntity.id!!,
-                    memberId = reservationEntity.member.id!!
-                )
-
-                result shouldBe paymentCancelRequest
-            }
-        }
-
-        context("isNotPaidReservation") {
-            test("결제된 예약이면 true를 반환한다.") {
-                every {
-                    paymentService.existsByReservationId(reservationEntity.id!!)
-                } returns false
-
-                val result: Boolean = reservationWithPaymentService.isNotPaidReservation(reservationEntity.id!!)
-
-                result shouldBe true
-            }
-
-            test("결제되지 않은 예약이면 false를 반환한다.") {
-                every {
-                    paymentService.existsByReservationId(reservationEntity.id!!)
-                } returns true
-
-                val result: Boolean = reservationWithPaymentService.isNotPaidReservation(reservationEntity.id!!)
-
-                result shouldBe false
-            }
-        }
-    }
-})
diff --git a/src/test/kotlin/roomescape/reservation/implement/ReservationFinderTest.kt b/src/test/kotlin/roomescape/reservation/implement/ReservationFinderTest.kt
deleted file mode 100644
index e11946d3..00000000
--- a/src/test/kotlin/roomescape/reservation/implement/ReservationFinderTest.kt
+++ /dev/null
@@ -1,64 +0,0 @@
-package roomescape.reservation.implement
-
-import io.kotest.assertions.throwables.shouldThrow
-import io.kotest.core.spec.style.FunSpec
-import io.kotest.matchers.shouldBe
-import io.mockk.every
-import io.mockk.mockk
-import io.mockk.spyk
-import io.mockk.verify
-import org.springframework.data.jpa.domain.Specification
-import org.springframework.data.repository.findByIdOrNull
-import roomescape.reservation.exception.ReservationErrorCode
-import roomescape.reservation.exception.ReservationException
-import roomescape.reservation.infrastructure.persistence.ReservationEntity
-import roomescape.reservation.infrastructure.persistence.ReservationRepository
-import roomescape.reservation.infrastructure.persistence.ReservationSearchSpecification
-import roomescape.reservation.infrastructure.persistence.ReservationStatus
-import roomescape.time.exception.TimeErrorCode
-import roomescape.time.exception.TimeException
-import java.time.LocalDate
-
-class ReservationFinderTest : FunSpec({
-    val reservationRepository: ReservationRepository = mockk()
-    val reservationValidator = ReservationValidator(reservationRepository)
-
-    val reservationFinder = ReservationFinder(reservationRepository, reservationValidator)
-
-    context("findById") {
-        val reservationId = 1L
-        test("동일한 ID인 시간을 찾아 응답한다.") {
-            every {
-                reservationRepository.findByIdOrNull(reservationId)
-            } returns mockk()
-
-            reservationFinder.findById(reservationId)
-
-            verify(exactly = 1) {
-                reservationRepository.findByIdOrNull(reservationId)
-            }
-        }
-
-        test("동일한 ID인 시간이 없으면 실패한다.") {
-            every {
-                reservationRepository.findByIdOrNull(reservationId)
-            } returns null
-
-            shouldThrow<ReservationException> {
-                reservationFinder.findById(reservationId)
-            }.also {
-                it.errorCode shouldBe ReservationErrorCode.RESERVATION_NOT_FOUND
-            }
-        }
-    }
-
-    context("searchReservations") {
-        test("시작 날짜가 종료 날짜 이전이면 실패한다.") {
-            shouldThrow<ReservationException> {
-                reservationFinder.searchReservations(1L, 1L, LocalDate.now(), LocalDate.now().minusDays(1))
-            }.also {
-                it.errorCode shouldBe ReservationErrorCode.INVALID_SEARCH_DATE_RANGE
-            }
-        }
-    }
-})
diff --git a/src/test/kotlin/roomescape/reservation/implement/ReservationValidatorTest.kt b/src/test/kotlin/roomescape/reservation/implement/ReservationValidatorTest.kt
deleted file mode 100644
index 878a5cc0..00000000
--- a/src/test/kotlin/roomescape/reservation/implement/ReservationValidatorTest.kt
+++ /dev/null
@@ -1,170 +0,0 @@
-package roomescape.reservation.implement
-
-import io.kotest.assertions.throwables.shouldNotThrow
-import io.kotest.assertions.throwables.shouldThrow
-import io.kotest.core.spec.style.FunSpec
-import io.kotest.matchers.shouldBe
-import io.mockk.every
-import io.mockk.mockk
-import org.springframework.data.jpa.domain.Specification
-import roomescape.member.infrastructure.persistence.Role
-import roomescape.reservation.exception.ReservationErrorCode
-import roomescape.reservation.exception.ReservationException
-import roomescape.reservation.infrastructure.persistence.ReservationEntity
-import roomescape.reservation.infrastructure.persistence.ReservationRepository
-import roomescape.reservation.infrastructure.persistence.ReservationStatus
-import roomescape.util.MemberFixture
-import roomescape.util.ReservationFixture
-import roomescape.util.ThemeFixture
-import roomescape.util.TimeFixture
-import java.time.LocalDate
-import java.time.LocalTime
-
-class ReservationValidatorTest : FunSpec({
-    val reservationRepository: ReservationRepository = mockk()
-
-    val reservationValidator = ReservationValidator(reservationRepository)
-
-    context("validateIsNotPast") {
-        val today = LocalDate.now()
-        val now = LocalTime.now()
-
-        test("입력된 날짜가 오늘 이전이면 예외를 던진다.") {
-            val requestDate = today.minusDays(1)
-
-            shouldThrow<ReservationException> {
-                reservationValidator.validateIsPast(requestDate, now)
-            }.also {
-                it.errorCode shouldBe ReservationErrorCode.PAST_REQUEST_DATETIME
-            }
-        }
-
-        test("오늘 날짜라도 시간이 지났다면 예외를 던진다.") {
-            val requestTime = now.minusMinutes(1)
-
-            shouldThrow<ReservationException> {
-                reservationValidator.validateIsPast(today, requestTime)
-            }.also {
-                it.errorCode shouldBe ReservationErrorCode.PAST_REQUEST_DATETIME
-            }
-        }
-    }
-
-    context("validateSearchDateRange") {
-        test("시작 날짜만 입력되면 종료한다.") {
-            shouldNotThrow<ReservationException> {
-                reservationValidator.validateSearchDateRange(LocalDate.now(), null)
-            }
-        }
-
-        test("종료 날짜만 입력되면 종료한다.") {
-            shouldNotThrow<ReservationException> {
-                reservationValidator.validateSearchDateRange(null, LocalDate.now())
-            }
-        }
-
-        test("두 날짜가 같으면 종료한다.") {
-            shouldNotThrow<ReservationException> {
-                reservationValidator.validateSearchDateRange(LocalDate.now(), LocalDate.now())
-            }
-        }
-
-        test("종료 날짜가 시작 날짜 이전이면 예외를 던진다.") {
-            shouldThrow<ReservationException> {
-                reservationValidator.validateSearchDateRange(LocalDate.now(), LocalDate.now().minusDays(1))
-            }.also {
-                it.errorCode shouldBe ReservationErrorCode.INVALID_SEARCH_DATE_RANGE
-            }
-        }
-    }
-
-    context("validateIsAlreadyExists") {
-        test("동일한 날짜, 시간, 테마를 가지는 예약이 있으면 예외를 던진다.") {
-            every {
-                reservationRepository.exists(any<Specification<ReservationEntity>>())
-            } returns true
-
-            shouldThrow<ReservationException> {
-                reservationValidator.validateIsAlreadyExists(
-                    LocalDate.now(),
-                    TimeFixture.create(),
-                    ThemeFixture.create()
-                )
-            }.also {
-                it.errorCode shouldBe ReservationErrorCode.RESERVATION_DUPLICATED
-            }
-        }
-    }
-
-    context("validateMemberAlreadyReserve") {
-        test("회원이 동일한 날짜, 시간, 테마인 예약(대기)를 이미 했다면 예외를 던진다.") {
-            every {
-                reservationRepository.exists(any<Specification<ReservationEntity>>())
-            } returns true
-
-            shouldThrow<ReservationException> {
-                reservationValidator.validateMemberAlreadyReserve(1L, 1L, LocalDate.now(), 1L)
-            }.also {
-                it.errorCode shouldBe ReservationErrorCode.ALREADY_RESERVE
-            }
-        }
-    }
-
-    context("validateIsWaiting") {
-        test("예약 상태가 WAITING이 아니면 예외를 던진다.") {
-            ReservationStatus.confirmedStatus().forEach { status ->
-                shouldThrow<ReservationException> {
-                    val reservation = ReservationFixture.create(status = status)
-                    reservationValidator.validateIsWaiting(reservation)
-                }.also {
-                    it.errorCode shouldBe ReservationErrorCode.ALREADY_CONFIRMED
-                }
-            }
-        }
-    }
-
-    context("validateCreateAuthority") {
-        test("관리자가 아니면 예외를 던진다.") {
-            shouldThrow<ReservationException> {
-                reservationValidator.validateCreateAuthority(MemberFixture.user())
-            }.also {
-                it.errorCode shouldBe ReservationErrorCode.NO_PERMISSION
-            }
-        }
-    }
-
-    context("validateDeleteAuthority") {
-        test("입력된 회원이 관리자이면 종료한다.") {
-            shouldNotThrow<ReservationException> {
-                reservationValidator.validateDeleteAuthority(mockk(), MemberFixture.admin())
-            }
-        }
-
-        test("입력된 회원이 관리자가 아니고, 예약한 회원과 다른 회원이면 예외를 던진다.") {
-            shouldThrow<ReservationException> {
-                reservationValidator.validateDeleteAuthority(
-                    ReservationFixture.create(member = MemberFixture.create(id = 1L)),
-                    MemberFixture.create(id = 2L, role = Role.MEMBER)
-                )
-            }.also {
-                it.errorCode shouldBe ReservationErrorCode.NOT_RESERVATION_OWNER
-            }
-        }
-    }
-
-    context("validateAlreadyConfirmed") {
-        val reservationId = 1L
-
-        test("입력된 ID의 예약과 동일한 날짜, 시간, 테마를 가지는 다른 확정 예약이 있으면 예외를 던진다.") {
-            every {
-                reservationRepository.isExistConfirmedReservation(reservationId)
-            } returns true
-
-            shouldThrow<ReservationException> {
-                reservationValidator.validateAlreadyConfirmed(reservationId)
-            }.also {
-                it.errorCode shouldBe ReservationErrorCode.CONFIRMED_RESERVATION_ALREADY_EXISTS
-            }
-        }
-    }
-})
diff --git a/src/test/kotlin/roomescape/reservation/implement/ReservationWriterTest.kt b/src/test/kotlin/roomescape/reservation/implement/ReservationWriterTest.kt
deleted file mode 100644
index 2fe07bce..00000000
--- a/src/test/kotlin/roomescape/reservation/implement/ReservationWriterTest.kt
+++ /dev/null
@@ -1,246 +0,0 @@
-package roomescape.reservation.implement
-
-import io.kotest.assertions.throwables.shouldThrow
-import io.kotest.core.spec.style.FunSpec
-import io.kotest.matchers.shouldBe
-import io.mockk.every
-import io.mockk.mockk
-import roomescape.member.exception.MemberErrorCode
-import roomescape.member.exception.MemberException
-import roomescape.member.implement.MemberFinder
-import roomescape.reservation.exception.ReservationErrorCode
-import roomescape.reservation.exception.ReservationException
-import roomescape.reservation.infrastructure.persistence.ReservationEntity
-import roomescape.reservation.infrastructure.persistence.ReservationRepository
-import roomescape.reservation.infrastructure.persistence.ReservationStatus
-import roomescape.theme.exception.ThemeErrorCode
-import roomescape.theme.exception.ThemeException
-import roomescape.theme.implement.ThemeFinder
-import roomescape.time.exception.TimeErrorCode
-import roomescape.time.exception.TimeException
-import roomescape.time.implement.TimeFinder
-import roomescape.util.MemberFixture
-import roomescape.util.ThemeFixture
-import roomescape.util.TimeFixture
-import roomescape.util.TsidFactory
-import java.time.LocalDate
-import java.time.LocalTime
-
-class ReservationWriterTest : FunSpec({
-
-    val reservationValidator: ReservationValidator = mockk()
-    val reservationRepository: ReservationRepository = mockk()
-    val memberFinder: MemberFinder = mockk()
-    val timeFinder: TimeFinder = mockk()
-    val themeFinder: ThemeFinder = mockk()
-
-    val reservationWriter = ReservationWriter(
-        reservationValidator, reservationRepository, memberFinder, timeFinder, themeFinder, TsidFactory
-    )
-
-    context("create") {
-        val today = LocalDate.now()
-        val timeId = 1L
-        val themeId = 1L
-        val memberId = 1L
-        val status = ReservationStatus.CONFIRMED
-        val requesterId = 1L
-
-        test("시간을 찾을 수 없으면 실패한다.") {
-            every {
-                timeFinder.findById(any())
-            } throws TimeException(TimeErrorCode.TIME_NOT_FOUND)
-
-            shouldThrow<TimeException> {
-                reservationWriter.create(today, timeId, themeId, memberId, status, requesterId)
-            }.also {
-                it.errorCode shouldBe TimeErrorCode.TIME_NOT_FOUND
-            }
-        }
-
-        test("이전 날짜이면 실패한다.") {
-            every {
-                timeFinder.findById(timeId)
-            } returns TimeFixture.create(id = timeId, startAt = LocalTime.now().plusHours(1))
-
-            every {
-                reservationValidator.validateIsPast(any(), any())
-            } throws ReservationException(ReservationErrorCode.PAST_REQUEST_DATETIME)
-
-            shouldThrow<ReservationException> {
-                reservationWriter.create(today.minusDays(1), timeId, themeId, memberId, status, requesterId)
-            }.also {
-                it.errorCode shouldBe ReservationErrorCode.PAST_REQUEST_DATETIME
-            }
-        }
-
-        test("테마를 찾을 수 없으면 실패한다.") {
-            every { timeFinder.findById(timeId) } returns TimeFixture.create(id = timeId)
-            every { reservationValidator.validateIsPast(any(), any()) } returns Unit
-
-            every {
-                themeFinder.findById(themeId)
-            } throws ThemeException(ThemeErrorCode.THEME_NOT_FOUND)
-
-            shouldThrow<ThemeException> {
-                reservationWriter.create(today.plusDays(1), timeId, themeId, memberId, status, requesterId)
-            }.also {
-                it.errorCode shouldBe ThemeErrorCode.THEME_NOT_FOUND
-            }
-        }
-
-        test("회원을 찾을 수 없으면 실패한다.") {
-            every { timeFinder.findById(timeId) } returns TimeFixture.create(id = timeId)
-            every { reservationValidator.validateIsPast(any(), any()) } returns Unit
-            every { themeFinder.findById(themeId) } returns ThemeFixture.create(id = themeId)
-
-            every {
-                memberFinder.findById(memberId)
-            } throws MemberException(MemberErrorCode.MEMBER_NOT_FOUND)
-
-            shouldThrow<MemberException> {
-                reservationWriter.create(today.plusDays(1), timeId, themeId, memberId, status, requesterId)
-            }.also {
-                it.errorCode shouldBe MemberErrorCode.MEMBER_NOT_FOUND
-            }
-        }
-
-        test("이미 예약이 있는 회원이 대기를 추가하면 실패한다.") {
-            every { timeFinder.findById(timeId) } returns TimeFixture.create(id = timeId)
-            every { reservationValidator.validateIsPast(any(), any()) } returns Unit
-            every { themeFinder.findById(themeId) } returns ThemeFixture.create(id = themeId)
-            every { memberFinder.findById(memberId) } returns MemberFixture.create(id = memberId)
-
-            every {
-                reservationValidator.validateMemberAlreadyReserve(themeId, timeId, today, memberId)
-            } throws ReservationException(ReservationErrorCode.ALREADY_RESERVE)
-
-            shouldThrow<ReservationException> {
-                reservationWriter.create(today, timeId, themeId, memberId, status = ReservationStatus.WAITING, memberId)
-            }.also {
-                it.errorCode shouldBe ReservationErrorCode.ALREADY_RESERVE
-            }
-        }
-
-        test("동일한 날짜, 시간, 테마인 예약이 이미 있으면 실패한다.") {
-            every { timeFinder.findById(timeId) } returns TimeFixture.create(id = timeId)
-            every { reservationValidator.validateIsPast(any(), any()) } returns Unit
-            every { themeFinder.findById(themeId) } returns ThemeFixture.create(id = themeId)
-            every { memberFinder.findById(memberId) } returns MemberFixture.create(id = memberId)
-
-            every {
-                reservationValidator.validateIsAlreadyExists(today, any(), any())
-            } throws ReservationException(ReservationErrorCode.RESERVATION_DUPLICATED)
-
-            shouldThrow<ReservationException> {
-                reservationWriter.create(today, timeId, themeId, memberId, status, memberId)
-            }.also {
-                it.errorCode shouldBe ReservationErrorCode.RESERVATION_DUPLICATED
-            }
-        }
-
-        test("예약하려는 회원과 신청한 회원이 다를 때, 신청한 회원을 찾을 수 없으면 실패한다.") {
-            every { timeFinder.findById(timeId) } returns TimeFixture.create(id = timeId)
-            every { reservationValidator.validateIsPast(any(), any()) } returns Unit
-            every { themeFinder.findById(themeId) } returns ThemeFixture.create(id = themeId)
-            every { memberFinder.findById(memberId) } returns MemberFixture.create(id = memberId)
-            every { reservationValidator.validateIsAlreadyExists(today, any(), any()) } returns Unit
-
-            every {
-                memberFinder.findById(memberId + 1)
-            } throws MemberException(MemberErrorCode.MEMBER_NOT_FOUND)
-
-            shouldThrow<MemberException> {
-                reservationWriter.create(today, timeId, themeId, memberId = memberId, status, requesterId = (memberId + 1))
-            }.also {
-                it.errorCode shouldBe MemberErrorCode.MEMBER_NOT_FOUND
-            }
-        }
-
-        test("예약하려는 회원과 신청한 회원이 다를 때, 신청한 회원이 관리자가 아니면 실패한다.") {
-            every { timeFinder.findById(timeId) } returns TimeFixture.create(id = timeId)
-            every { reservationValidator.validateIsPast(any(), any()) } returns Unit
-            every { themeFinder.findById(themeId) } returns ThemeFixture.create(id = themeId)
-            every { memberFinder.findById(memberId) } returns MemberFixture.create(id = memberId)
-            every { reservationValidator.validateIsAlreadyExists(today, any(), any()) } returns Unit
-
-            every {
-                memberFinder.findById(memberId + 1)
-            } returns MemberFixture.create(id = memberId + 1)
-
-            every {
-                reservationValidator.validateCreateAuthority(any())
-            } throws ReservationException(ReservationErrorCode.NO_PERMISSION)
-
-            shouldThrow<ReservationException> {
-                reservationWriter.create(today, timeId, themeId, memberId = memberId, status, requesterId = (memberId + 1))
-            }.also {
-                it.errorCode shouldBe ReservationErrorCode.NO_PERMISSION
-            }
-        }
-    }
-
-    context("deleteWaiting") {
-        val reservation: ReservationEntity = mockk()
-        val requesterId = 1L
-
-        test("대기 상태가 아니면 실패한다.") {
-            every {
-                reservationValidator.validateIsWaiting(any())
-            } throws ReservationException(ReservationErrorCode.ALREADY_CONFIRMED)
-
-            shouldThrow<ReservationException> {
-                reservationWriter.deleteWaiting(reservation, requesterId)
-            }.also {
-                it.errorCode shouldBe ReservationErrorCode.ALREADY_CONFIRMED
-            }
-        }
-
-        test("삭제하려는 회원이 관리자가 아니고, 예약한 회원과 다르면 실패한다.") {
-            every { reservationValidator.validateIsWaiting(any()) } returns Unit
-            every {
-                reservationValidator.validateDeleteAuthority(any(), any())
-            } throws ReservationException(ReservationErrorCode.NOT_RESERVATION_OWNER)
-
-            shouldThrow<ReservationException> {
-                reservationWriter.deleteWaiting(reservation, requesterId)
-            }.also {
-                it.errorCode shouldBe ReservationErrorCode.NOT_RESERVATION_OWNER
-            }
-        }
-    }
-
-    context("deleteConfirm") {
-        val reservation: ReservationEntity = mockk()
-        val requesterId = 1L
-
-        test("삭제하려는 회원이 관리자가 아니고, 예약한 회원과 다르면 실패한다.") {
-            every { reservationValidator.validateIsWaiting(any()) } returns Unit
-            every {
-                reservationValidator.validateDeleteAuthority(any(), any())
-            } throws ReservationException(ReservationErrorCode.NOT_RESERVATION_OWNER)
-
-            shouldThrow<ReservationException> {
-                reservationWriter.deleteConfirmed(reservation, requesterId)
-            }.also {
-                it.errorCode shouldBe ReservationErrorCode.NOT_RESERVATION_OWNER
-            }
-        }
-    }
-
-    context("confirm") {
-        val reservationId = 1L
-
-        test("승인하려는 대기와 같은 날짜,시간,테마를 가진 확정 예약이 있으면 실패한다.") {
-            every {
-                reservationValidator.validateAlreadyConfirmed(reservationId)
-            } throws ReservationException(ReservationErrorCode.CONFIRMED_RESERVATION_ALREADY_EXISTS)
-
-            shouldThrow<ReservationException> {
-                reservationWriter.confirm(reservationId)
-            }.also {
-                it.errorCode shouldBe ReservationErrorCode.CONFIRMED_RESERVATION_ALREADY_EXISTS
-            }
-        }
-    }
-})
diff --git a/src/test/kotlin/roomescape/reservation/infrastructure/persistence/ReservationRepositoryTest.kt b/src/test/kotlin/roomescape/reservation/infrastructure/persistence/ReservationRepositoryTest.kt
deleted file mode 100644
index 78d44d3f..00000000
--- a/src/test/kotlin/roomescape/reservation/infrastructure/persistence/ReservationRepositoryTest.kt
+++ /dev/null
@@ -1,205 +0,0 @@
-package roomescape.reservation.infrastructure.persistence
-
-import io.kotest.assertions.assertSoftly
-import io.kotest.core.spec.style.FunSpec
-import io.kotest.matchers.collections.shouldHaveSize
-import io.kotest.matchers.shouldBe
-import jakarta.persistence.EntityManager
-import org.springframework.boot.test.autoconfigure.orm.jpa.DataJpaTest
-import org.springframework.data.repository.findByIdOrNull
-import roomescape.payment.infrastructure.persistence.PaymentEntity
-import roomescape.reservation.web.MyReservationRetrieveResponse
-import roomescape.theme.infrastructure.persistence.ThemeEntity
-import roomescape.util.PaymentFixture
-import roomescape.util.ReservationFixture
-import roomescape.util.ThemeFixture
-import roomescape.util.TimeFixture
-
-@DataJpaTest(showSql = false)
-class ReservationRepositoryTest(
-    val entityManager: EntityManager,
-    val reservationRepository: ReservationRepository,
-) : FunSpec() {
-    init {
-        context("findByTime") {
-            val time = TimeFixture.create()
-
-            beforeTest {
-                listOf(
-                    ReservationFixture.create(time = time),
-                    ReservationFixture.create(
-                        time = TimeFixture.create(
-                            startAt = time.startAt.plusSeconds(1)
-                        )
-                    )
-                ).forEach {
-                    persistReservation(it)
-                }
-
-                entityManager.flush()
-                entityManager.clear()
-            }
-
-            test("입력된 시간과 일치하는 예약을 반환한다.") {
-                assertSoftly(reservationRepository.findAllByTime(time)) {
-                    it shouldHaveSize 1
-                    assertSoftly(it.first().time.startAt) { result ->
-                        result.hour shouldBe time.startAt.hour
-                        result.minute shouldBe time.startAt.minute
-                    }
-                }
-            }
-        }
-
-        context("findByDateAndThemeId") {
-            val date = ReservationFixture.create().date
-            lateinit var theme1: ThemeEntity
-            lateinit var theme2: ThemeEntity
-
-            beforeTest {
-                theme1 = ThemeFixture.create(name = "theme1").also {
-                    entityManager.persist(it)
-                }
-
-                theme2 = ThemeFixture.create(name = "theme2").also {
-                    entityManager.persist(it)
-                }
-
-                listOf(
-                    ReservationFixture.create(date = date, theme = theme1),
-                    ReservationFixture.create(date = date.plusDays(1), theme = theme1),
-                    ReservationFixture.create(date = date, theme = theme2),
-                ).forEach {
-                    entityManager.persist(it.time)
-                    entityManager.persist(it.member)
-                    entityManager.persist(it)
-                }
-            }
-
-            test("입력된 날짜와 테마 ID에 해당하는 예약을 반환한다.") {
-                assertSoftly(reservationRepository.findByDateAndThemeId(date, theme1.id!!)) {
-                    it shouldHaveSize 1
-                    it.first().theme shouldBe theme1
-                }
-            }
-        }
-
-        context("updateStatusByReservationId") {
-            lateinit var reservation: ReservationEntity
-
-            beforeTest {
-                reservation = ReservationFixture.create().also {
-                    persistReservation(it)
-                }
-
-                entityManager.flush()
-                entityManager.clear()
-            }
-
-            test("예약 상태를 업데이트한다.") {
-                ReservationStatus.entries.forEach {
-                    val reservationId = reservation.id!!
-                    val updatedRows = reservationRepository.updateStatusByReservationId(reservationId, it)
-                    updatedRows shouldBe 1
-
-                    entityManager.flush()
-                    entityManager.clear()
-
-                    reservationRepository.findByIdOrNull(reservationId)?.also { updated ->
-                        updated.status shouldBe it
-                    }
-                }
-            }
-        }
-
-        context("isExistConfirmedReservation") {
-            lateinit var waiting: ReservationEntity
-            lateinit var confirmed: ReservationEntity
-            lateinit var confirmedPaymentRequired: ReservationEntity
-
-            beforeTest {
-                waiting = ReservationFixture.create(status = ReservationStatus.WAITING).also {
-                    persistReservation(it)
-                }
-
-                confirmed = ReservationFixture.create(status = ReservationStatus.CONFIRMED_PAYMENT_REQUIRED).also {
-                    persistReservation(it)
-                }
-
-                confirmedPaymentRequired =
-                    ReservationFixture.create(status = ReservationStatus.CONFIRMED_PAYMENT_REQUIRED).also {
-                        persistReservation(it)
-                    }
-
-                entityManager.flush()
-                entityManager.clear()
-            }
-
-            test("예약이 없으면 false를 반환한다.") {
-                val maxId: Long = listOf(waiting, confirmed, confirmedPaymentRequired)
-                    .maxOfOrNull { it.id ?: 0L } ?: 0L
-                reservationRepository.isExistConfirmedReservation(maxId + 1L) shouldBe false
-            }
-
-            test("예약이 대기중이면 false를 반환한다.") {
-                reservationRepository.isExistConfirmedReservation(waiting.id!!) shouldBe false
-            }
-
-            test("예약이 결제 완료 상태이면 true를 반환한다.") {
-                reservationRepository.isExistConfirmedReservation(confirmed.id!!) shouldBe true
-            }
-
-            test("예약이 결제 대기 상태이면 true를 반환한다.") {
-                reservationRepository.isExistConfirmedReservation(confirmedPaymentRequired.id!!) shouldBe true
-            }
-        }
-
-        context("findMyReservations") {
-            lateinit var reservation: ReservationEntity
-
-            beforeTest {
-                reservation = ReservationFixture.create()
-                persistReservation(reservation)
-            }
-
-            test("결제 정보를 포함한 회원의 예약 목록을 반환한다.") {
-                val payment: PaymentEntity = PaymentFixture.create(
-                    reservation = reservation
-                ).also {
-                    entityManager.persist(it)
-                    entityManager.flush()
-                    entityManager.clear()
-                }
-
-                val result: List<MyReservationRetrieveResponse> =
-                    reservationRepository.findAllByMemberId(reservation.member.id!!)
-
-                result shouldHaveSize 1
-                assertSoftly(result.first()) {
-                    it.id shouldBe reservation.id
-                    it.paymentKey shouldBe payment.paymentKey
-                    it.amount shouldBe payment.totalAmount
-                }
-            }
-
-            test("결제 정보가 없다면 paymentKey와 amount는 null로 반환한다.") {
-                val result: List<MyReservationRetrieveResponse> =
-                    reservationRepository.findAllByMemberId(reservation.member.id!!)
-
-                result shouldHaveSize 1
-                assertSoftly(result.first()) {
-                    it.id shouldBe reservation.id
-                    it.paymentKey shouldBe null
-                    it.amount shouldBe null
-                }
-            }
-        }
-    }
-
-    fun persistReservation(reservation: ReservationEntity) {
-        entityManager.persist(reservation.time)
-        entityManager.persist(reservation.theme)
-        entityManager.persist(reservation.member)
-        entityManager.persist(reservation)
-    }
-}
diff --git a/src/test/kotlin/roomescape/reservation/infrastructure/persistence/ReservationSearchSpecificationTest.kt b/src/test/kotlin/roomescape/reservation/infrastructure/persistence/ReservationSearchSpecificationTest.kt
deleted file mode 100644
index c9cf5570..00000000
--- a/src/test/kotlin/roomescape/reservation/infrastructure/persistence/ReservationSearchSpecificationTest.kt
+++ /dev/null
@@ -1,195 +0,0 @@
-package roomescape.reservation.infrastructure.persistence
-
-import io.kotest.assertions.assertSoftly
-import io.kotest.core.spec.style.StringSpec
-import io.kotest.matchers.collections.shouldContainExactly
-import io.kotest.matchers.collections.shouldHaveSize
-import jakarta.persistence.EntityManager
-import org.springframework.boot.test.autoconfigure.orm.jpa.DataJpaTest
-import roomescape.member.infrastructure.persistence.MemberEntity
-import roomescape.theme.infrastructure.persistence.ThemeEntity
-import roomescape.time.infrastructure.persistence.TimeEntity
-import roomescape.util.MemberFixture
-import roomescape.util.ReservationFixture
-import roomescape.util.ThemeFixture
-import roomescape.util.TimeFixture
-import java.time.LocalDate
-
-@DataJpaTest(showSql = false)
-class ReservationSearchSpecificationTest(
-    val entityManager: EntityManager,
-    val reservationRepository: ReservationRepository
-) : StringSpec() {
-
-    init {
-        lateinit var confirmedNow: ReservationEntity
-        lateinit var confirmedNotPaidYesterday: ReservationEntity
-        lateinit var waitingTomorrow: ReservationEntity
-        lateinit var member: MemberEntity
-        lateinit var time: TimeEntity
-        lateinit var theme: ThemeEntity
-
-        "동일한 테마의 예약을 조회한다" {
-            val spec = ReservationSearchSpecification()
-                .sameThemeId(theme.id)
-                .build()
-
-            val results: List<ReservationEntity> = reservationRepository.findAll(spec)
-
-            assertSoftly(results) {
-                this shouldHaveSize 3
-                this shouldContainExactly listOf(confirmedNow, confirmedNotPaidYesterday, waitingTomorrow)
-            }
-        }
-
-        "동일한 회원의 예약을 조회한다" {
-            val spec = ReservationSearchSpecification()
-                .sameMemberId(member.id)
-                .build()
-
-            val results: List<ReservationEntity> = reservationRepository.findAll(spec)
-
-            assertSoftly(results) {
-                this shouldHaveSize 3
-                this shouldContainExactly listOf(confirmedNow, confirmedNotPaidYesterday, waitingTomorrow)
-            }
-        }
-
-        "동일한 예약 시간의 예약을 조회한다" {
-            val spec = ReservationSearchSpecification()
-                .sameTimeId(time.id)
-                .build()
-
-            val results: List<ReservationEntity> = reservationRepository.findAll(spec)
-
-            assertSoftly(results) {
-                this shouldHaveSize 3
-                this shouldContainExactly listOf(confirmedNow, confirmedNotPaidYesterday, waitingTomorrow)
-            }
-        }
-
-        "동일한 날짜의 예약을 조회한다" {
-            val spec = ReservationSearchSpecification()
-                .sameDate(LocalDate.now())
-                .build()
-
-            val results: List<ReservationEntity> = reservationRepository.findAll(spec)
-
-            assertSoftly(results) {
-                this shouldHaveSize 1
-                this shouldContainExactly listOf(confirmedNow)
-            }
-        }
-
-        "여러 상태를 입력받아 같은 상태안 예약을 조회한다." {
-            val spec = ReservationSearchSpecification()
-                .status(
-                    ReservationStatus.CONFIRMED,
-                    ReservationStatus.CONFIRMED_PAYMENT_REQUIRED,
-                    ReservationStatus.WAITING
-                ).build()
-
-            val results: List<ReservationEntity> = reservationRepository.findAll(spec)
-
-            assertSoftly(results) {
-                this shouldHaveSize reservationRepository.findAll().size
-            }
-        }
-
-        "확정 상태인 예약을 조회한다" {
-            val spec = ReservationSearchSpecification()
-                .confirmed()
-                .build()
-
-            val results: List<ReservationEntity> = reservationRepository.findAll(spec)
-
-            assertSoftly(results) {
-                this shouldHaveSize 2
-                this shouldContainExactly listOf(confirmedNow, confirmedNotPaidYesterday)
-            }
-        }
-
-        "대기 상태인 예약을 조회한다" {
-            val spec = ReservationSearchSpecification()
-                .waiting()
-                .build()
-
-            val results: List<ReservationEntity> = reservationRepository.findAll(spec)
-
-            assertSoftly(results) {
-                this shouldHaveSize 1
-                this shouldContainExactly listOf(waitingTomorrow)
-            }
-        }
-
-        "예약 날짜가 오늘 이후인 예약을 조회한다" {
-            val spec = ReservationSearchSpecification()
-                .dateStartFrom(LocalDate.now())
-                .build()
-
-            val results: List<ReservationEntity> = reservationRepository.findAll(spec)
-
-            assertSoftly(results) {
-                this shouldHaveSize 2
-                this shouldContainExactly listOf(confirmedNow, waitingTomorrow)
-            }
-        }
-
-        "예약 날짜가 내일 이전인 예약을 조회한다" {
-            val spec = ReservationSearchSpecification()
-                .dateEndAt(LocalDate.now().plusDays(1))
-                .build()
-
-            val results: List<ReservationEntity> = reservationRepository.findAll(spec)
-
-            assertSoftly(results) {
-                this shouldHaveSize 3
-                this shouldContainExactly listOf(confirmedNow, confirmedNotPaidYesterday, waitingTomorrow)
-            }
-        }
-
-        beforeTest {
-            member = MemberFixture.create().also {
-                entityManager.persist(it)
-            }
-            time = TimeFixture.create().also {
-                entityManager.persist(it)
-            }
-            theme = ThemeFixture.create().also {
-                entityManager.persist(it)
-            }
-
-            confirmedNow = ReservationFixture.create(
-                time = time,
-                member = member,
-                theme = theme,
-                date = LocalDate.now(),
-                status = ReservationStatus.CONFIRMED
-            ).also {
-                entityManager.persist(it)
-            }
-
-            confirmedNotPaidYesterday = ReservationFixture.create(
-                time = time,
-                member = member,
-                theme = theme,
-                date = LocalDate.now().minusDays(1),
-                status = ReservationStatus.CONFIRMED_PAYMENT_REQUIRED
-            ).also {
-                entityManager.persist(it)
-            }
-
-            waitingTomorrow = ReservationFixture.create(
-                time = time,
-                member = member,
-                theme = theme,
-                date = LocalDate.now().plusDays(1),
-                status = ReservationStatus.WAITING
-            ).also {
-                entityManager.persist(it)
-            }
-
-            entityManager.flush()
-        }
-    }
-}
diff --git a/src/test/kotlin/roomescape/reservation/web/ReservationControllerTest.kt b/src/test/kotlin/roomescape/reservation/web/ReservationControllerTest.kt
deleted file mode 100644
index 06d59c98..00000000
--- a/src/test/kotlin/roomescape/reservation/web/ReservationControllerTest.kt
+++ /dev/null
@@ -1,730 +0,0 @@
-package roomescape.reservation.web
-
-import com.ninjasquad.springmockk.MockkBean
-import com.ninjasquad.springmockk.SpykBean
-import io.kotest.core.spec.style.FunSpec
-import io.kotest.matchers.shouldBe
-import io.mockk.every
-import io.restassured.module.kotlin.extensions.Given
-import io.restassured.module.kotlin.extensions.Then
-import io.restassured.module.kotlin.extensions.When
-import jakarta.persistence.EntityManager
-import org.hamcrest.Matchers.equalTo
-import org.springframework.boot.test.context.SpringBootTest
-import org.springframework.boot.test.web.server.LocalServerPort
-import org.springframework.http.HttpStatus
-import org.springframework.http.MediaType
-import org.springframework.transaction.support.TransactionTemplate
-import roomescape.auth.exception.AuthErrorCode
-import roomescape.auth.infrastructure.jwt.JwtHandler
-import roomescape.auth.web.support.MemberIdResolver
-import roomescape.member.business.MemberService
-import roomescape.member.infrastructure.persistence.MemberEntity
-import roomescape.member.infrastructure.persistence.Role
-import roomescape.payment.exception.PaymentErrorCode
-import roomescape.payment.exception.PaymentException
-import roomescape.payment.infrastructure.client.TossPaymentClient
-import roomescape.payment.infrastructure.persistence.PaymentEntity
-import roomescape.reservation.exception.ReservationErrorCode
-import roomescape.reservation.infrastructure.persistence.ReservationEntity
-import roomescape.reservation.infrastructure.persistence.ReservationStatus
-import roomescape.theme.exception.ThemeErrorCode
-import roomescape.theme.infrastructure.persistence.ThemeEntity
-import roomescape.time.infrastructure.persistence.TimeEntity
-import roomescape.util.*
-import java.time.LocalDate
-import java.time.LocalTime
-
-@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT)
-class ReservationControllerTest(
-    @LocalServerPort val port: Int,
-    val entityManager: EntityManager,
-    val transactionTemplate: TransactionTemplate,
-) : FunSpec({
-    extension(DatabaseCleanerExtension(mode = CleanerMode.AFTER_EACH_TEST))
-}) {
-    @MockkBean
-    lateinit var paymentClient: TossPaymentClient
-
-    @SpykBean
-    lateinit var memberIdResolver: MemberIdResolver
-
-    @SpykBean
-    lateinit var memberService: MemberService
-
-    @MockkBean
-    lateinit var jwtHandler: JwtHandler
-
-    lateinit var testDataHelper: TestDataHelper
-
-    fun login(member: MemberEntity) {
-        every { jwtHandler.getMemberIdFromToken(any()) } returns member.id!!
-        every { memberService.findById(member.id!!) } returns member
-        every { memberIdResolver.resolveArgument(any(), any(), any(), any()) } returns member.id!!
-    }
-
-    init {
-        beforeSpec {
-            testDataHelper = TestDataHelper(entityManager, transactionTemplate)
-        }
-
-        context("POST /reservations") {
-            beforeTest {
-                val member = testDataHelper.createMember(role = Role.MEMBER)
-                login(member)
-            }
-
-            test("정상 응답") {
-                val reservationRequest = testDataHelper.createReservationRequest()
-                val paymentApproveResponse = PaymentFixture.createApproveResponse().copy(
-                    paymentKey = reservationRequest.paymentKey,
-                    orderId = reservationRequest.orderId,
-                    totalAmount = reservationRequest.amount,
-                )
-
-                every { paymentClient.confirm(any()) } returns paymentApproveResponse
-
-                Given {
-                    port(port)
-                    contentType(MediaType.APPLICATION_JSON_VALUE)
-                    body(reservationRequest)
-                }.When {
-                    post("/reservations")
-                }.Then {
-                    statusCode(201)
-                    body("data.date", equalTo(reservationRequest.date.toString()))
-                    body("data.status", equalTo(ReservationStatus.CONFIRMED.name))
-                }
-            }
-
-            test("결제 과정에서 발생하는 에러는 그대로 응답") {
-                val reservationRequest = testDataHelper.createReservationRequest()
-                val paymentException = PaymentException(PaymentErrorCode.PAYMENT_PROVIDER_ERROR)
-
-                every { paymentClient.confirm(any()) } throws paymentException
-
-                Given {
-                    port(port)
-                    contentType(MediaType.APPLICATION_JSON_VALUE)
-                    body(reservationRequest)
-                }.When {
-                    post("/reservations")
-                }.Then {
-                    statusCode(paymentException.errorCode.httpStatus.value())
-                    body("code", equalTo(paymentException.errorCode.errorCode))
-                }
-            }
-
-            test("결제 완료 후 예약 / 결제 정보 저장 과정에서 에러 발생시 결제 취소 후 에러 응답을 받는다.") {
-                val reservationRequest = testDataHelper.createReservationRequest()
-                val paymentApproveResponse = PaymentFixture.createApproveResponse().copy(
-                    paymentKey = reservationRequest.paymentKey,
-                    orderId = reservationRequest.orderId,
-                    totalAmount = reservationRequest.amount,
-                )
-
-                every { paymentClient.confirm(any()) } returns paymentApproveResponse
-
-                // 예약 저장 과정에서 테마가 없는 예외
-                val invalidRequest = reservationRequest.copy(themeId = reservationRequest.themeId + 1)
-                val expectedException = ThemeErrorCode.THEME_NOT_FOUND
-
-                every { paymentClient.cancel(any()) } returns PaymentFixture.createCancelResponse()
-
-                val canceledPaymentSizeBeforeApiCall: Long = entityManager.createQuery(
-                    "SELECT COUNT(c) FROM CanceledPaymentEntity c",
-                    Long::class.java
-                ).singleResult
-
-                Given {
-                    port(port)
-                    contentType(MediaType.APPLICATION_JSON_VALUE)
-                    body(invalidRequest)
-                }.When {
-                    post("/reservations")
-                }.Then {
-                    statusCode(expectedException.httpStatus.value())
-                    body("code", equalTo(expectedException.errorCode))
-                }
-
-                val canceledPaymentSizeAfterApiCall: Long = entityManager.createQuery(
-                    "SELECT COUNT(c) FROM CanceledPaymentEntity c",
-                    Long::class.java
-                ).singleResult
-
-                canceledPaymentSizeAfterApiCall shouldBe canceledPaymentSizeBeforeApiCall + 1L
-            }
-        }
-
-        context("GET /reservations") {
-            lateinit var reservations: Map<MemberEntity, List<ReservationEntity>>
-            beforeTest {
-                reservations = testDataHelper.createDummyReservations()
-            }
-
-            test("관리자이면 정상 응답") {
-                login(testDataHelper.createMember(role = Role.ADMIN))
-                Given {
-                    port(port)
-                    contentType(MediaType.APPLICATION_JSON_VALUE)
-                }.When {
-                    get("/reservations")
-                }.Then {
-                    statusCode(200)
-                    body("data.reservations.size()", equalTo(reservations.values.sumOf { it.size }))
-                }
-            }
-        }
-
-        context("GET /reservations-mine") {
-            lateinit var reservations: Map<MemberEntity, List<ReservationEntity>>
-            beforeTest {
-                reservations = testDataHelper.createDummyReservations()
-            }
-
-            test("로그인한 회원이 자신의 예약 목록을 조회한다.") {
-                val member = reservations.keys.first()
-                login(member)
-                val expectedReservations: Int = reservations[member]?.size ?: 0
-
-                Given {
-                    port(port)
-                    contentType(MediaType.APPLICATION_JSON_VALUE)
-                }.When {
-                    get("/reservations-mine")
-                }.Then {
-                    statusCode(200)
-                    body("data.reservations.size()", equalTo(expectedReservations))
-                }
-            }
-        }
-
-        context("GET /reservations/search") {
-            lateinit var reservations: Map<MemberEntity, List<ReservationEntity>>
-            beforeTest {
-                reservations = testDataHelper.createDummyReservations()
-            }
-
-            test("관리자만 검색할 수 있다.") {
-                login(reservations.keys.first())
-                val expectedError = AuthErrorCode.ACCESS_DENIED
-
-                Given {
-                    port(port)
-                    contentType(MediaType.APPLICATION_JSON_VALUE)
-                }.When {
-                    get("/reservations/search")
-                }.Then {
-                    statusCode(expectedError.httpStatus.value())
-                    body("code", equalTo(expectedError.errorCode))
-                }
-            }
-
-            test("파라미터를 지정하지 않으면 전체 목록 응답") {
-                login(testDataHelper.createMember(role = Role.ADMIN))
-
-                Given {
-                    port(port)
-                    contentType(MediaType.APPLICATION_JSON_VALUE)
-                }.When {
-                    get("/reservations/search")
-                }.Then {
-                    statusCode(200)
-                    body("data.reservations.size()", equalTo(reservations.values.sumOf { it.size }))
-                }
-            }
-
-            test("시작 날짜가 종료 날짜 이전이면 예외 응답") {
-                login(testDataHelper.createMember(role = Role.ADMIN))
-
-                val startDate = LocalDate.now().plusDays(1)
-                val endDate = LocalDate.now()
-                val expectedError = ReservationErrorCode.INVALID_SEARCH_DATE_RANGE
-
-                Given {
-                    port(port)
-                    contentType(MediaType.APPLICATION_JSON_VALUE)
-                    param("dateFrom", startDate.toString())
-                    param("dateTo", endDate.toString())
-                }.When {
-                    get("/reservations/search")
-                }.Then {
-                    statusCode(expectedError.httpStatus.value())
-                    body("code", equalTo(expectedError.errorCode))
-                }
-            }
-
-            test("동일한 회원의 모든 예약 응답") {
-                login(testDataHelper.createMember(role = Role.ADMIN))
-                val member = reservations.keys.first()
-
-                Given {
-                    port(port)
-                    contentType(MediaType.APPLICATION_JSON_VALUE)
-                    param("memberId", member.id)
-                }.When {
-                    get("/reservations/search")
-                }.Then {
-                    statusCode(200)
-                    body("data.reservations.size()", equalTo(reservations[member]?.size ?: 0))
-                }
-            }
-
-            test("동일한 테마의 모든 예약 응답") {
-                login(testDataHelper.createMember(role = Role.ADMIN))
-                val themes = reservations.values.flatten().map { it.theme }
-                val requestThemeId: Long = themes.first().id!!
-
-                Given {
-                    port(port)
-                    contentType(MediaType.APPLICATION_JSON_VALUE)
-                    param("themeId", requestThemeId)
-                }.When {
-                    get("/reservations/search")
-                }.Then {
-                    statusCode(200)
-                    body("data.reservations.size()", equalTo(themes.count { it.id == requestThemeId }))
-                }
-            }
-
-            test("시작 날짜와 종료 날짜 사이의 예약 응답") {
-                login(testDataHelper.createMember(role = Role.ADMIN))
-                val dateFrom: LocalDate = reservations.values.flatten().minOf { it.date }
-                val dateTo: LocalDate = reservations.values.flatten().maxOf { it.date }
-
-                Given {
-                    port(port)
-                    contentType(MediaType.APPLICATION_JSON_VALUE)
-                    param("dateFrom", dateFrom.toString())
-                    param("dateTo", dateTo.toString())
-                }.When {
-                    get("/reservations/search")
-                }.Then {
-                    statusCode(200)
-                    body("data.reservations.size()", equalTo(reservations.values.sumOf { it.size }))
-                }
-            }
-        }
-
-        context("DELETE /reservations/{id}") {
-            lateinit var reservations: Map<MemberEntity, List<ReservationEntity>>
-            beforeTest {
-                reservations = testDataHelper.createDummyReservations()
-            }
-
-            test("관리자만 예약을 삭제할 수 있다.") {
-                login(testDataHelper.createMember(role = Role.MEMBER))
-                val reservation = reservations.values.flatten().first()
-                val expectedError = AuthErrorCode.ACCESS_DENIED
-
-                Given {
-                    port(port)
-                }.When {
-                    delete("/reservations/${reservation.id}")
-                }.Then {
-                    statusCode(expectedError.httpStatus.value())
-                    body("code", equalTo(expectedError.errorCode))
-                }
-            }
-
-            test("결제되지 않은 예약은 바로 제거") {
-                login(testDataHelper.createMember(role = Role.ADMIN))
-                val reservationId = reservations.values.flatten().first().id!!
-
-                transactionTemplate.executeWithoutResult {
-                    val reservation = entityManager.find(ReservationEntity::class.java, reservationId)
-                    reservation.status = ReservationStatus.CONFIRMED_PAYMENT_REQUIRED
-                }
-
-                Given {
-                    port(port)
-                }.When {
-                    delete("/reservations/$reservationId")
-                }.Then {
-                    statusCode(HttpStatus.NO_CONTENT.value())
-                }
-
-                val deletedReservation = transactionTemplate.execute {
-                    entityManager.find(ReservationEntity::class.java, reservationId)
-                }
-                deletedReservation shouldBe null
-            }
-
-            test("결제된 예약은 취소 후 제거") {
-                login(testDataHelper.createMember(role = Role.ADMIN))
-                val reservation = reservations.values.flatten().first { it.status == ReservationStatus.CONFIRMED }
-                testDataHelper.createPayment(reservation)
-
-                every { paymentClient.cancel(any()) } returns PaymentFixture.createCancelResponse()
-
-                val canceledPaymentSizeBeforeApiCall: Long = entityManager.createQuery(
-                    "SELECT COUNT(c) FROM CanceledPaymentEntity c",
-                    Long::class.java
-                ).singleResult
-
-                Given {
-                    port(port)
-                }.When {
-                    delete("/reservations/${reservation.id}")
-                }.Then {
-                    statusCode(HttpStatus.NO_CONTENT.value())
-                }
-
-                val canceledPaymentSizeAfterApiCall: Long = entityManager.createQuery(
-                    "SELECT COUNT(c) FROM CanceledPaymentEntity c",
-                    Long::class.java
-                ).singleResult
-
-                canceledPaymentSizeAfterApiCall shouldBe canceledPaymentSizeBeforeApiCall + 1L
-            }
-        }
-
-        context("POST /reservations/admin") {
-            test("관리자가 예약을 추가하면 결제 대기 상태로 예약 생성") {
-                val admin = testDataHelper.createMember(role = Role.ADMIN)
-                login(admin)
-                val theme = testDataHelper.createTheme()
-                val time = testDataHelper.createTime()
-
-                val adminRequest = AdminReservationCreateRequest(
-                    date = LocalDate.now().plusDays(1),
-                    themeId = theme.id!!,
-                    timeId = time.id!!,
-                    memberId = admin.id!!,
-                )
-
-                Given {
-                    port(port)
-                    contentType(MediaType.APPLICATION_JSON_VALUE)
-                    body(adminRequest)
-                }.When {
-                    post("/reservations/admin")
-                }.Then {
-                    statusCode(201)
-                    body("data.status", equalTo(ReservationStatus.CONFIRMED_PAYMENT_REQUIRED.name))
-                }
-            }
-        }
-
-        context("GET /reservations/waiting") {
-            lateinit var reservations: Map<MemberEntity, List<ReservationEntity>>
-            beforeTest {
-                reservations = testDataHelper.createDummyReservations(reservationCount = 5)
-            }
-
-            test("관리자가 아니면 조회할 수 없다.") {
-                login(testDataHelper.createMember(role = Role.MEMBER))
-                val expectedError = AuthErrorCode.ACCESS_DENIED
-
-                Given {
-                    port(port)
-                    contentType(MediaType.APPLICATION_JSON_VALUE)
-                }.When {
-                    get("/reservations/waiting")
-                }.Then {
-                    statusCode(expectedError.httpStatus.value())
-                    body("code", equalTo(expectedError.errorCode))
-                }
-            }
-
-            test("대기 중인 예약 목록을 조회한다.") {
-                login(testDataHelper.createMember(role = Role.ADMIN))
-                val expected = reservations.values.flatten()
-                    .count { it.status == ReservationStatus.WAITING }
-
-                Given {
-                    port(port)
-                    contentType(MediaType.APPLICATION_JSON_VALUE)
-                }.When {
-                    get("/reservations/waiting")
-                }.Then {
-                    statusCode(200)
-                    body("data.reservations.size()", equalTo(expected))
-                }
-            }
-        }
-
-        context("POST /reservations/waiting") {
-            test("회원이 대기 예약을 추가한다.") {
-                val member = testDataHelper.createMember(role = Role.MEMBER)
-                login(member)
-                val theme = testDataHelper.createTheme()
-                val time = testDataHelper.createTime()
-
-                val waitingCreateRequest = WaitingCreateRequest(
-                    date = LocalDate.now().plusDays(1),
-                    themeId = theme.id!!,
-                    timeId = time.id!!
-                )
-
-                Given {
-                    port(port)
-                    contentType(MediaType.APPLICATION_JSON_VALUE)
-                    body(waitingCreateRequest)
-                }.When {
-                    post("/reservations/waiting")
-                }.Then {
-                    statusCode(201)
-                    body("data.member.id", equalTo(member.id!!.toString()))
-                    body("data.status", equalTo(ReservationStatus.WAITING.name))
-                }
-            }
-
-            test("이미 예약된 시간, 테마로 대기 예약 요청 시 예외 응답") {
-                val member = testDataHelper.createMember(role = Role.MEMBER)
-                login(member)
-                val theme = testDataHelper.createTheme()
-                val time = testDataHelper.createTime()
-                val date = LocalDate.now().plusDays(1)
-
-                testDataHelper.createReservation(
-                    date = date,
-                    theme = theme,
-                    time = time,
-                    member = member,
-                    status = ReservationStatus.CONFIRMED
-                )
-
-                val waitingCreateRequest = WaitingCreateRequest(
-                    date = date,
-                    themeId = theme.id!!,
-                    timeId = time.id!!
-                )
-                val expectedError = ReservationErrorCode.ALREADY_RESERVE
-
-                Given {
-                    port(port)
-                    contentType(MediaType.APPLICATION_JSON_VALUE)
-                    body(waitingCreateRequest)
-                }.When {
-                    post("/reservations/waiting")
-                }.Then {
-                    statusCode(expectedError.httpStatus.value())
-                    body("code", equalTo(expectedError.errorCode))
-                }
-            }
-        }
-
-        context("DELETE /reservations/waiting/{id}") {
-            test("대기 중인 예약을 취소한다.") {
-                val member = testDataHelper.createMember(role = Role.MEMBER)
-                login(member)
-                val waiting = testDataHelper.createReservation(
-                    member = member,
-                    status = ReservationStatus.WAITING
-                )
-
-                Given {
-                    port(port)
-                }.When {
-                    delete("/reservations/waiting/${waiting.id}")
-                }.Then {
-                    statusCode(HttpStatus.NO_CONTENT.value())
-                }
-
-                val deleted = transactionTemplate.execute {
-                    entityManager.find(ReservationEntity::class.java, waiting.id)
-                }
-                deleted shouldBe null
-            }
-
-            test("이미 확정된 예약을 삭제하면 예외 응답") {
-                val member = testDataHelper.createMember(role = Role.MEMBER)
-                login(member)
-                val reservation = testDataHelper.createReservation(
-                    member = member,
-                    status = ReservationStatus.CONFIRMED_PAYMENT_REQUIRED
-                )
-
-                val expectedError = ReservationErrorCode.ALREADY_CONFIRMED
-                Given {
-                    port(port)
-                }.When {
-                    delete("/reservations/waiting/${reservation.id}")
-                }.Then {
-                    statusCode(expectedError.httpStatus.value())
-                    body("code", equalTo(expectedError.errorCode))
-                }
-            }
-        }
-
-        context("POST /reservations/waiting/{id}/confirm") {
-            test("관리자만 승인할 수 있다.") {
-                login(testDataHelper.createMember(role = Role.MEMBER))
-                val expectedError = AuthErrorCode.ACCESS_DENIED
-                Given {
-                    port(port)
-                }.When {
-                    post("/reservations/waiting/1/confirm")
-                }.Then {
-                    statusCode(expectedError.httpStatus.value())
-                    body("code", equalTo(expectedError.errorCode))
-                }
-            }
-
-            test("대기 예약을 승인하면 결제 대기 상태로 변경") {
-                login(testDataHelper.createMember(role = Role.ADMIN))
-                val reservation = testDataHelper.createReservation(
-                    status = ReservationStatus.WAITING
-                )
-
-                Given {
-                    port(port)
-                }.When {
-                    post("/reservations/waiting/${reservation.id!!}/confirm")
-                }.Then {
-                    statusCode(200)
-                }
-
-                val updatedReservation = transactionTemplate.execute {
-                    entityManager.find(ReservationEntity::class.java, reservation.id)
-                }
-                updatedReservation?.status shouldBe ReservationStatus.CONFIRMED_PAYMENT_REQUIRED
-            }
-
-            test("다른 확정된 예약을 승인하면 예외 응답") {
-                val admin = testDataHelper.createMember(role = Role.ADMIN)
-                login(admin)
-                val alreadyReserved = testDataHelper.createReservation(
-                    member = admin,
-                    status = ReservationStatus.CONFIRMED
-                )
-
-                val member = testDataHelper.createMember(role = Role.MEMBER)
-                val waiting = testDataHelper.createReservation(
-                    date = alreadyReserved.date,
-                    time = alreadyReserved.time,
-                    theme = alreadyReserved.theme,
-                    member = member,
-                    status = ReservationStatus.WAITING
-                )
-
-                val expectedError = ReservationErrorCode.CONFIRMED_RESERVATION_ALREADY_EXISTS
-                Given {
-                    port(port)
-                }.When {
-                    post("/reservations/waiting/${waiting.id!!}/confirm")
-                }.Then {
-                    statusCode(expectedError.httpStatus.value())
-                    body("code", equalTo(expectedError.errorCode))
-                }
-            }
-        }
-
-        context("POST /reservations/waiting/{id}/reject") {
-            test("관리자만 거절할 수 있다.") {
-                login(testDataHelper.createMember(role = Role.MEMBER))
-                val expectedError = AuthErrorCode.ACCESS_DENIED
-
-                Given {
-                    port(port)
-                }.When {
-                    post("/reservations/waiting/1/reject")
-                }.Then {
-                    statusCode(expectedError.httpStatus.value())
-                    body("code", equalTo(expectedError.errorCode))
-                }
-            }
-
-            test("거절된 예약은 삭제된다.") {
-                login(testDataHelper.createMember(role = Role.ADMIN))
-                val reservation = testDataHelper.createReservation(
-                    status = ReservationStatus.WAITING
-                )
-
-                Given {
-                    port(port)
-                }.When {
-                    post("/reservations/waiting/${reservation.id!!}/reject")
-                }.Then {
-                    statusCode(204)
-                }
-
-                val rejected = transactionTemplate.execute {
-                    entityManager.find(ReservationEntity::class.java, reservation.id)
-                }
-                rejected shouldBe null
-            }
-        }
-    }
-}
-
-class TestDataHelper(
-    private val entityManager: EntityManager,
-    private val transactionTemplate: TransactionTemplate,
-) {
-    private var memberSequence = 0L
-    private var themeSequence = 0L
-    private var timeSequence = 0L
-
-    fun createMember(
-        role: Role = Role.MEMBER,
-        account: String = "member${++memberSequence}@test.com",
-    ): MemberEntity {
-        val member = MemberFixture.create(role = role, account = account)
-        return persist(member)
-    }
-
-    fun createTheme(name: String = "theme-${++themeSequence}"): ThemeEntity {
-        val theme = ThemeFixture.create(name = name)
-        return persist(theme)
-    }
-
-    fun createTime(startAt: LocalTime = LocalTime.of(10, 0).plusMinutes(++timeSequence * 10)): TimeEntity {
-        val time = TimeFixture.create(startAt = startAt)
-        return persist(time)
-    }
-
-    fun createReservation(
-        date: LocalDate = LocalDate.now().plusDays(1),
-        theme: ThemeEntity = createTheme(),
-        time: TimeEntity = createTime(),
-        member: MemberEntity = createMember(),
-        status: ReservationStatus = ReservationStatus.CONFIRMED,
-    ): ReservationEntity {
-        val reservation = ReservationFixture.create(
-            date = date,
-            theme = theme,
-            time = time,
-            member = member,
-            status = status
-        )
-        return persist(reservation)
-    }
-
-    fun createPayment(reservation: ReservationEntity): PaymentEntity {
-        val payment = PaymentFixture.create(reservation = reservation)
-        return persist(payment)
-    }
-
-    fun createReservationRequest(
-        theme: ThemeEntity = createTheme(),
-        time: TimeEntity = createTime(),
-    ): ReservationCreateWithPaymentRequest {
-        return ReservationFixture.createRequest(
-            themeId = theme.id!!,
-            timeId = time.id!!,
-        )
-    }
-
-    fun createDummyReservations(
-        memberCount: Int = 2,
-        reservationCount: Int = 10,
-    ): Map<MemberEntity, List<ReservationEntity>> {
-        val members = (1..memberCount).map { createMember(role = Role.MEMBER) }
-        val reservations = (1..reservationCount).map { index ->
-            createReservation(
-                member = members[index % memberCount],
-                status = ReservationStatus.CONFIRMED
-            )
-        }
-        return reservations.groupBy { it.member }
-    }
-
-    private fun <T> persist(entity: T): T {
-        transactionTemplate.executeWithoutResult {
-            entityManager.persist(entity)
-        }
-        return entity
-    }
-}
\ No newline at end of file
diff --git a/src/test/kotlin/roomescape/schedule/ScheduleApiTest.kt b/src/test/kotlin/roomescape/schedule/ScheduleApiTest.kt
index 036060f3..28dc692a 100644
--- a/src/test/kotlin/roomescape/schedule/ScheduleApiTest.kt
+++ b/src/test/kotlin/roomescape/schedule/ScheduleApiTest.kt
@@ -22,6 +22,7 @@ import roomescape.schedule.infrastructure.persistence.ScheduleStatus
 import roomescape.schedule.web.ScheduleCreateRequest
 import roomescape.schedule.web.ScheduleUpdateRequest
 import roomescape.util.*
+import roomescape.util.ScheduleFixture.createRequest
 import java.time.LocalDate
 import java.time.LocalTime
 
@@ -49,7 +50,7 @@ class ScheduleApiTest(
                 runTest(
                     token = token,
                     on = {
-                        get("/schedules/1")
+                        get("/schedules/$INVALID_PK")
                     },
                     expect = commonAssertion
                 )
@@ -59,10 +60,10 @@ class ScheduleApiTest(
                 runTest(
                     token = token,
                     using = {
-                        body(ScheduleFixture.createRequest)
+                        body(createRequest)
                     },
                     on = {
-                        get("/schedules/1")
+                        get("/schedules/$INVALID_PK")
                     },
                     expect = commonAssertion
                 )
@@ -71,13 +72,13 @@ class ScheduleApiTest(
             test("일정 수정: PATCH /schedules/{id}") {
                 val createdSchedule: ScheduleEntity =
                     createDummySchedule(
-                        ScheduleFixture.createRequest
+                        createRequest
                     )
 
                 runTest(
                     token = token,
                     using = {
-                        body(ScheduleFixture.createRequest)
+                        body(createRequest)
                     },
                     on = {
                         patch("/schedules/${createdSchedule.id}")
@@ -89,7 +90,7 @@ class ScheduleApiTest(
             test("일정 삭제: DELETE /schedules/{id}") {
                 val createdSchedule: ScheduleEntity =
                     createDummySchedule(
-                        ScheduleFixture.createRequest
+                        createRequest
                     )
 
                 runTest(
@@ -114,7 +115,7 @@ class ScheduleApiTest(
                 val time = LocalTime.now()
                 val createdSchedule: ScheduleEntity =
                     createDummySchedule(
-                        ScheduleFixture.createRequest.copy(
+                        createRequest.copy(
                             date = date,
                             time = time
                         )
@@ -139,13 +140,13 @@ class ScheduleApiTest(
 
                 val createdSchedule: ScheduleEntity =
                     createDummySchedule(
-                        ScheduleFixture.createRequest.copy(
+                        createRequest.copy(
                             date = date,
                             time = time
                         )
                     )
                 createDummySchedule(
-                    ScheduleFixture.createRequest.copy(
+                    createRequest.copy(
                         date = date.plusDays(1L),
                         time = time,
                         themeId = createdSchedule.themeId
@@ -175,7 +176,7 @@ class ScheduleApiTest(
                 val date = LocalDate.now().plusDays(1)
                 for (i in 1..10) {
                     createDummySchedule(
-                        ScheduleFixture.createRequest.copy(
+                        createRequest.copy(
                             date = date,
                             time = LocalTime.now().plusMinutes(i.toLong())
                         )
@@ -199,14 +200,14 @@ class ScheduleApiTest(
             test("정상 응답") {
                 val date = LocalDate.now().plusDays(1)
                 val createdSchedule = createDummySchedule(
-                    ScheduleFixture.createRequest.copy(
+                    createRequest.copy(
                         date = date,
                         time = LocalTime.now()
                     )
                 )
                 for (i in 1..10) {
                     createDummySchedule(
-                        ScheduleFixture.createRequest.copy(
+                        createRequest.copy(
                             date = date,
                             time = LocalTime.now().plusMinutes(i.toLong()),
                             themeId = createdSchedule.themeId
@@ -233,7 +234,7 @@ class ScheduleApiTest(
 
         context("관리자 페이지에서 특정 일정의 감사 정보를 조회한다.") {
             test("정상 응답") {
-                val createdSchedule = createDummySchedule(ScheduleFixture.createRequest)
+                val createdSchedule = createDummySchedule(createRequest)
 
                 runTest(
                     token = loginUtil.loginAsAdmin(),
@@ -262,7 +263,7 @@ class ScheduleApiTest(
                 runTest(
                     token = loginUtil.loginAsAdmin(),
                     on = {
-                        get("/schedules/1")
+                        get("/schedules/$INVALID_PK")
                     },
                     expect = {
                         statusCode(HttpStatus.NOT_FOUND.value())
@@ -289,7 +290,7 @@ class ScheduleApiTest(
                 val themeId: Long = Given {
                     contentType(MediaType.APPLICATION_JSON_VALUE)
                     header("Authorization", "Bearer $token")
-                    body(ThemeFixtureV2.createRequest.copy(name = "theme-${System.currentTimeMillis()}"))
+                    body(ThemeFixture.createRequest.copy(name = "theme-${System.currentTimeMillis()}"))
                 } When {
                     post("/admin/themes")
                 } Extract {
@@ -302,7 +303,7 @@ class ScheduleApiTest(
                 runTest(
                     token = token,
                     using = {
-                        body(ScheduleFixture.createRequest.copy(themeId = themeId))
+                        body(createRequest.copy(themeId = themeId))
                     },
                     on = {
                         post("/schedules")
@@ -316,9 +317,9 @@ class ScheduleApiTest(
                     val createdSchedule: ScheduleEntity = scheduleRepository.findByIdOrNull(createdScheduleId)
                         ?: throw AssertionError("Unexpected Exception Occurred.")
 
-                    createdSchedule.date shouldBe ScheduleFixture.createRequest.date
-                    createdSchedule.time.hour shouldBe ScheduleFixture.createRequest.time.hour
-                    createdSchedule.time.minute shouldBe ScheduleFixture.createRequest.time.minute
+                    createdSchedule.date shouldBe createRequest.date
+                    createdSchedule.time.hour shouldBe createRequest.time.hour
+                    createdSchedule.time.minute shouldBe createRequest.time.minute
                     createdSchedule.createdAt shouldNotBeNull {}
                     createdSchedule.createdBy shouldNotBeNull {}
                     createdSchedule.updatedAt shouldNotBeNull {}
@@ -331,7 +332,7 @@ class ScheduleApiTest(
                 val time = LocalTime.of(10, 0)
 
                 val alreadyCreated: ScheduleEntity = createDummySchedule(
-                    ScheduleFixture.createRequest.copy(
+                    createRequest.copy(
                         date = date, time = time
                     )
                 )
@@ -340,7 +341,7 @@ class ScheduleApiTest(
                     token = token,
                     using = {
                         body(
-                            ScheduleFixture.createRequest.copy(
+                            createRequest.copy(
                                 date = date, time = time, themeId = alreadyCreated.themeId
                             )
                         )
@@ -360,7 +361,7 @@ class ScheduleApiTest(
                     token = token,
                     using = {
                         body(
-                            ScheduleFixture.createRequest.copy(
+                            createRequest.copy(
                                 date = LocalDate.now(),
                                 time = LocalTime.now().minusMinutes(1)
                             )
@@ -377,6 +378,76 @@ class ScheduleApiTest(
             }
         }
 
+        context("일정을 잠시 Hold 상태로 변경하여 중복 예약을 방지한다.") {
+            test("해당 일정이 ${ScheduleStatus.AVAILABLE} 상태이면 정상 응답") {
+                val createdSchedule: ScheduleEntity = createDummySchedule(createRequest)
+
+                runTest(
+                    token = loginUtil.loginAsUser(),
+                    on = {
+                        patch("/schedules/${createdSchedule.id}/hold")
+                    },
+                    expect = {
+                        statusCode(HttpStatus.OK.value())
+                    }
+                ).also {
+                    val updatedSchedule = scheduleRepository.findByIdOrNull(createdSchedule.id)
+                        ?: throw AssertionError("Unexpected Exception Occurred.")
+
+                    updatedSchedule.status shouldBe ScheduleStatus.HOLD
+                }
+            }
+
+            test("예약이 없으면 실패한다.") {
+                runTest(
+                    token = loginUtil.loginAsUser(),
+                    on = {
+                        patch("/schedules/$INVALID_PK/hold")
+                    },
+                    expect = {
+                        statusCode(HttpStatus.NOT_FOUND.value())
+                        body("code", equalTo(ScheduleErrorCode.SCHEDULE_NOT_FOUND.errorCode))
+                    }
+                )
+            }
+
+            test("해당 일정이 ${ScheduleStatus.AVAILABLE} 상태가 아니면 실패한다.") {
+                val createdSchedule: ScheduleEntity = createDummySchedule(createRequest)
+
+                /*
+               * 테스트를 위해 수정 API를 호출하여 상태를 HOLD 상태로 변경
+               * 생성 API에서는 일정 생성 시 AVAILABLE을 기본 상태로 지정하기 때문.
+               */
+                runTest(
+                    token = loginUtil.loginAsAdmin(),
+                    using = {
+                        body(
+                            ScheduleUpdateRequest(
+                                status = ScheduleStatus.HOLD
+                            )
+                        )
+                    },
+                    on = {
+                        patch("/schedules/${createdSchedule.id}")
+                    },
+                    expect = {
+                        statusCode(HttpStatus.OK.value())
+                    }
+                )
+
+                runTest(
+                    token = loginUtil.loginAsUser(),
+                    on = {
+                        patch("/schedules/${createdSchedule.id}/hold")
+                    },
+                    expect = {
+                        statusCode(HttpStatus.CONFLICT.value())
+                        body("code", equalTo(ScheduleErrorCode.SCHEDULE_NOT_AVAILABLE.errorCode))
+                    }
+                )
+            }
+        }
+
         context("일정을 수정한다.") {
             val updateRequest = ScheduleUpdateRequest(
                 time = LocalTime.now().plusHours(1),
@@ -385,7 +456,7 @@ class ScheduleApiTest(
 
             test("정상 수정 및 감사 정보 변경 확인") {
                 val createdSchedule: ScheduleEntity = createDummySchedule(
-                    ScheduleFixture.createRequest.copy(
+                    createRequest.copy(
                         date = LocalDate.now().plusDays(1),
                         time = LocalTime.now().plusMinutes(1),
                     )
@@ -416,7 +487,7 @@ class ScheduleApiTest(
             }
 
             test("입력값이 없으면 수정하지 않는다.") {
-                val createdSchedule: ScheduleEntity = createDummySchedule(ScheduleFixture.createRequest)
+                val createdSchedule: ScheduleEntity = createDummySchedule(createRequest)
 
                 runTest(
                     token = loginUtil.loginAsAdmin(),
@@ -444,7 +515,7 @@ class ScheduleApiTest(
                         body(updateRequest)
                     },
                     on = {
-                        patch("/schedules/1")
+                        patch("/schedules/$INVALID_PK")
                     },
                     expect = {
                         statusCode(HttpStatus.NOT_FOUND.value())
@@ -455,7 +526,7 @@ class ScheduleApiTest(
 
             test("입력된 날짜 + 시간이 현재 시간 이전이면 실패한다.") {
                 val createdSchedule: ScheduleEntity = createDummySchedule(
-                    ScheduleFixture.createRequest.copy(date = LocalDate.now(), time = LocalTime.now().plusMinutes(1))
+                    createRequest.copy(date = LocalDate.now(), time = LocalTime.now().plusMinutes(1))
                 )
 
                 runTest(
@@ -480,7 +551,7 @@ class ScheduleApiTest(
 
         context("일정을 삭제한다.") {
             test("정상 삭제") {
-                val createdSchedule: ScheduleEntity = createDummySchedule(ScheduleFixture.createRequest)
+                val createdSchedule: ScheduleEntity = createDummySchedule(createRequest)
 
                 runTest(
                     token = loginUtil.loginAsAdmin(),
@@ -496,7 +567,7 @@ class ScheduleApiTest(
             }
 
             test("예약 중이거나 예약이 완료된 일정이면 실패한다.") {
-                val createdSchedule: ScheduleEntity = createDummySchedule(ScheduleFixture.createRequest)
+                val createdSchedule: ScheduleEntity = createDummySchedule(createRequest)
 
                 /*
                  * 테스트를 위해 수정 API를 호출하여 상태를 예약 중 상태로 변경
@@ -545,7 +616,7 @@ class ScheduleApiTest(
             Given {
                 contentType(MediaType.APPLICATION_JSON_VALUE)
                 header("Authorization", "Bearer $token")
-                body(ThemeFixtureV2.createRequest.copy(name = "theme-${System.currentTimeMillis()}"))
+                body(ThemeFixture.createRequest.copy(name = "theme-${System.currentTimeMillis()}"))
             } When {
                 post("/admin/themes")
             } Extract {
diff --git a/src/test/kotlin/roomescape/theme/ThemeApiTest.kt b/src/test/kotlin/roomescape/theme/ThemeApiTest.kt
index d397f659..e6aee6d0 100644
--- a/src/test/kotlin/roomescape/theme/ThemeApiTest.kt
+++ b/src/test/kotlin/roomescape/theme/ThemeApiTest.kt
@@ -4,36 +4,32 @@ import io.kotest.matchers.date.shouldBeAfter
 import io.kotest.matchers.nulls.shouldNotBeNull
 import io.kotest.matchers.shouldBe
 import io.kotest.matchers.shouldNotBe
-import io.restassured.module.kotlin.extensions.Extract
-import io.restassured.module.kotlin.extensions.Given
-import io.restassured.module.kotlin.extensions.When
 import io.restassured.response.ValidatableResponse
 import org.hamcrest.CoreMatchers.equalTo
 import org.hamcrest.CoreMatchers.notNullValue
 import org.springframework.data.repository.findByIdOrNull
 import org.springframework.http.HttpStatus
-import org.springframework.http.MediaType
 import roomescape.auth.exception.AuthErrorCode
 import roomescape.member.infrastructure.persistence.Role
 import roomescape.theme.business.MIN_DURATION
 import roomescape.theme.business.MIN_PARTICIPANTS
 import roomescape.theme.business.MIN_PRICE
 import roomescape.theme.exception.ThemeErrorCode
-import roomescape.theme.infrastructure.persistence.v2.ThemeEntityV2
-import roomescape.theme.infrastructure.persistence.v2.ThemeRepositoryV2
-import roomescape.theme.web.ThemeCreateRequestV2
+import roomescape.theme.infrastructure.persistence.ThemeEntity
+import roomescape.theme.infrastructure.persistence.ThemeRepository
+import roomescape.theme.web.ThemeListRetrieveRequest
 import roomescape.theme.web.ThemeUpdateRequest
 import roomescape.util.FunSpecSpringbootTest
-import roomescape.util.ThemeFixtureV2.createRequest
+import roomescape.util.INVALID_PK
+import roomescape.util.ThemeFixture.createRequest
 import roomescape.util.assertProperties
 import roomescape.util.runTest
 import kotlin.random.Random
 
 class ThemeApiTest(
-    private val themeRepository: ThemeRepositoryV2
+    private val themeRepository: ThemeRepository
 ) : FunSpecSpringbootTest() {
 
-
     init {
         context("관리자가 아니면 접근할 수 없다.") {
             lateinit var token: String
@@ -74,7 +70,7 @@ class ThemeApiTest(
                 runTest(
                     token = token,
                     on = {
-                        get("/admin/themes/1")
+                        get("/admin/themes/$INVALID_PK")
                     },
                     expect = commonAssertion
                 )
@@ -87,7 +83,7 @@ class ThemeApiTest(
                         body(createRequest)
                     },
                     on = {
-                        patch("/admin/themes/1")
+                        patch("/admin/themes/$INVALID_PK")
                     },
                     expect = commonAssertion
                 )
@@ -97,7 +93,7 @@ class ThemeApiTest(
                 runTest(
                     token = token,
                     on = {
-                        delete("/admin/themes/1")
+                        delete("/admin/themes/$INVALID_PK")
                     },
                     expect = commonAssertion
                 )
@@ -106,10 +102,15 @@ class ThemeApiTest(
 
         context("일반 회원도 접근할 수 있다.") {
             test("테마 조회: GET /v2/themes") {
-                createDummyTheme(createRequest.copy(name = "test123", isOpen = true))
+                val token = loginUtil.loginAsUser()
+
+                dummyInitializer.createTheme(
+                    adminToken = loginUtil.loginAsAdmin(),
+                    request = createRequest.copy(name = "test123", isOpen = true)
+                )
 
                 runTest(
-                    token = loginUtil.loginAsUser(),
+                    token = token,
                     on = {
                         get("/v2/themes")
                     },
@@ -146,7 +147,7 @@ class ThemeApiTest(
                     }
                 ).also {
                     val createdThemeId: Long = it.extract().path("data.id")
-                    val createdTheme: ThemeEntityV2 = themeRepository.findByIdOrNull(createdThemeId)
+                    val createdTheme: ThemeEntity = themeRepository.findByIdOrNull(createdThemeId)
                         ?: throw AssertionError("Unexpected Exception Occurred.")
 
                     createdTheme.name shouldBe createRequest.name
@@ -159,7 +160,10 @@ class ThemeApiTest(
 
             test("이미 동일한 이름의 테마가 있으면 실패한다.") {
                 val commonName = "test123"
-                createDummyTheme(createRequest.copy(name = commonName))
+                dummyInitializer.createTheme(
+                    adminToken = token,
+                    request = createRequest.copy(name = commonName)
+                )
 
                 runTest(
                     token = token,
@@ -330,15 +334,77 @@ class ThemeApiTest(
             }
         }
 
-        context("모든 테마를 조회한다.") {
+        context("입력된 모든 ID에 대한 테마를 조회한다.") {
+            val themeIds = mutableListOf<Long>()
+
             beforeTest {
-                createDummyTheme(createRequest.copy(name = "open", isOpen = true))
-                createDummyTheme(createRequest.copy(name = "close", isOpen = false))
+                for (i in 1..3) {
+                    dummyInitializer.createTheme(
+                        adminToken = loginUtil.loginAsAdmin(),
+                        request = createRequest.copy(name = "test$i")
+                    ).also {
+                        themeIds.add(it.id)
+                    }
+                }
+            }
+
+            afterTest {
+                themeIds.clear()
+            }
+
+            test("정상 응답") {
+                runTest(
+                    token = loginUtil.loginAsUser(),
+                    using = {
+                        body(ThemeListRetrieveRequest(themeIds))
+                    },
+                    on = {
+                        post("/themes/retrieve")
+                    },
+                    expect = {
+                        statusCode(HttpStatus.OK.value())
+                        body("data.themes.size()", equalTo(3))
+                    }
+                )
+            }
+
+            test("없는 테마가 있으면 생략한다.") {
+                themeIds.add(INVALID_PK)
+
+                runTest(
+                    token = loginUtil.loginAsUser(),
+                    using = {
+                        body(ThemeListRetrieveRequest(themeIds))
+                    },
+                    on = {
+                        post("/themes/retrieve")
+                    },
+                    expect = {
+                        statusCode(HttpStatus.OK.value())
+                        body("data.themes.size()", equalTo(3))
+                    }
+                )
+            }
+        }
+
+        context("모든 테마를 조회한다.") {
+            lateinit var token: String
+
+            beforeTest {
+                token = loginUtil.loginAsAdmin()
+                dummyInitializer.createTheme(
+                    adminToken = token,
+                    request = createRequest.copy(name = "open", isOpen = true)
+                )
+                dummyInitializer.createTheme(
+                    adminToken = token,
+                    request = createRequest.copy(name = "close", isOpen = false)
+                )
             }
 
             test("관리자 페이지에서는 비공개 테마까지 포함하여 간단한 정보만 조회된다.") {
                 runTest(
-                    token = loginUtil.loginAsAdmin(),
+                    token = token,
                     on = {
                         get("/admin/themes")
                     },
@@ -376,10 +442,14 @@ class ThemeApiTest(
 
         context("관리자 페이지에서 특정 테마의 상세 정보를 조회한다.") {
             test("정상 응답") {
-                val createdTheme: ThemeEntityV2 = createDummyTheme(createRequest)
+                val token = loginUtil.loginAsAdmin()
+                val createdTheme = dummyInitializer.createTheme(
+                    adminToken = token,
+                    request = createRequest
+                )
 
                 runTest(
-                    token = loginUtil.loginAsAdmin(),
+                    token = token,
                     on = {
                         get("/admin/themes/${createdTheme.id}")
                     },
@@ -402,7 +472,7 @@ class ThemeApiTest(
                 runTest(
                     token = loginUtil.loginAsAdmin(),
                     on = {
-                        get("/admin/themes/1")
+                        get("/admin/themes/$INVALID_PK")
                     },
                     expect = {
                         statusCode(HttpStatus.NOT_FOUND.value())
@@ -414,10 +484,14 @@ class ThemeApiTest(
 
         context("테마를 삭제한다.") {
             test("정상 삭제") {
-                val createdTheme = createDummyTheme(createRequest)
+                val token = loginUtil.loginAsAdmin()
+                val createdTheme = dummyInitializer.createTheme(
+                    adminToken = token,
+                    request = createRequest
+                )
 
                 runTest(
-                    token = loginUtil.loginAsAdmin(),
+                    token = token,
                     on = {
                         delete("/admin/themes/${createdTheme.id}")
                     },
@@ -433,7 +507,7 @@ class ThemeApiTest(
                 runTest(
                     token = loginUtil.loginAsAdmin(),
                     on = {
-                        delete("/admin/themes/1")
+                        delete("/admin/themes/$INVALID_PK")
                     },
                     expect = {
                         statusCode(HttpStatus.NOT_FOUND.value())
@@ -445,14 +519,17 @@ class ThemeApiTest(
 
         context("테마를 수정한다.") {
             lateinit var token: String
-            lateinit var createdTheme: ThemeEntityV2
+            lateinit var createdTheme: ThemeEntity
             lateinit var apiPath: String
 
             val updateRequest = ThemeUpdateRequest(name = "modified")
 
             beforeTest {
                 token = loginUtil.loginAsAdmin()
-                createdTheme = createDummyTheme(createRequest.copy(name = "theme-${Random.nextInt()}"))
+                createdTheme = dummyInitializer.createTheme(
+                    adminToken = token,
+                    request = createRequest.copy(name = "theme-${Random.nextInt()}")
+                )
                 apiPath = "/admin/themes/${createdTheme.id}"
             }
 
@@ -507,7 +584,7 @@ class ThemeApiTest(
                         body(updateRequest)
                     },
                     on = {
-                        patch("/admin/themes/1")
+                        patch("/admin/themes/$INVALID_PK")
                     },
                     expect = {
                         statusCode(HttpStatus.NOT_FOUND.value())
@@ -670,19 +747,4 @@ class ThemeApiTest(
             }
         }
     }
-
-    fun createDummyTheme(request: ThemeCreateRequestV2): ThemeEntityV2 {
-        val createdThemeId: Long = Given {
-            contentType(MediaType.APPLICATION_JSON_VALUE)
-            header("Authorization", "Bearer ${loginUtil.loginAsAdmin()}")
-            body(request)
-        } When {
-            post("/admin/themes")
-        } Extract {
-            path("data.id")
-        }
-
-        return themeRepository.findByIdOrNull(createdThemeId)
-            ?: throw RuntimeException("unreachable line")
-    }
 }
diff --git a/src/test/kotlin/roomescape/theme/business/ThemeServiceTest.kt b/src/test/kotlin/roomescape/theme/business/ThemeServiceTest.kt
deleted file mode 100644
index b576c26b..00000000
--- a/src/test/kotlin/roomescape/theme/business/ThemeServiceTest.kt
+++ /dev/null
@@ -1,162 +0,0 @@
-package roomescape.theme.business
-
-import io.kotest.assertions.assertSoftly
-import io.kotest.assertions.throwables.shouldNotThrow
-import io.kotest.assertions.throwables.shouldThrow
-import io.kotest.core.spec.style.FunSpec
-import io.kotest.matchers.collections.shouldContainExactly
-import io.kotest.matchers.shouldBe
-import io.mockk.*
-import roomescape.theme.exception.ThemeErrorCode
-import roomescape.theme.exception.ThemeException
-import roomescape.theme.implement.ThemeFinder
-import roomescape.theme.implement.ThemeWriter
-import roomescape.theme.infrastructure.persistence.ThemeEntity
-import roomescape.theme.web.ThemeCreateRequest
-import roomescape.theme.web.ThemeCreateResponse
-import roomescape.util.ThemeFixture
-import java.time.LocalDate
-
-class ThemeServiceTest : FunSpec({
-    val themeFinder: ThemeFinder = mockk()
-    val themeWriter: ThemeWriter = mockk()
-
-    val themeService = ThemeService(themeFinder, themeWriter)
-
-    context("findThemeById") {
-        val themeId = 1L
-
-        test("정상 응답") {
-            val theme: ThemeEntity = ThemeFixture.create(id = themeId)
-            every {
-                themeFinder.findById(themeId)
-            } returns theme
-
-            theme.id shouldBe themeId
-        }
-
-        test("테마를 찾을 수 없으면 예외 응답") {
-            every {
-                themeFinder.findById(themeId)
-            } throws ThemeException(ThemeErrorCode.THEME_NOT_FOUND)
-
-            shouldThrow<ThemeException> {
-                themeService.findById(themeId)
-            }.also {
-                it.errorCode shouldBe ThemeErrorCode.THEME_NOT_FOUND
-            }
-        }
-    }
-
-    context("findThemes") {
-        test("정상 응답") {
-            val themes = listOf(
-                ThemeFixture.create(id = 1, name = "t1"),
-                ThemeFixture.create(id = 2, name = "t2")
-            )
-
-            every {
-                themeFinder.findAll()
-            } returns themes
-
-            val response = themeService.findThemes()
-
-            assertSoftly(response.themes) {
-                this.size shouldBe themes.size
-                it.map { theme -> theme.name } shouldContainExactly themes.map { theme -> theme.name }
-            }
-        }
-    }
-
-    context("findMostReservedThemes") {
-        test("7일 전 부터 1일 전 까지 조회") {
-            val count = 10
-            val startFrom = slot<LocalDate>()
-            val endAt = slot<LocalDate>()
-
-            every {
-                themeFinder.findMostReservedThemes(count, capture(startFrom), capture(endAt))
-            } returns emptyList()
-
-            themeService.findMostReservedThemes(count)
-
-            startFrom.captured shouldBe LocalDate.now().minusDays(7)
-            endAt.captured shouldBe LocalDate.now().minusDays(1)
-        }
-    }
-
-    context("createTheme") {
-        val request = ThemeCreateRequest(
-            name = "New Theme",
-            description = "Description",
-            thumbnail = "http://example.com/thumbnail.jpg"
-        )
-
-        test("정상 저장") {
-            every {
-                themeWriter.create(request.name, request.description, request.thumbnail)
-            } returns ThemeFixture.create(
-                id = 1,
-                name = request.name,
-                description = request.description,
-                thumbnail = request.thumbnail
-            )
-
-            val response: ThemeCreateResponse = themeService.createTheme(request)
-
-            assertSoftly(response) {
-                this.id shouldBe 1L
-                this.name shouldBe request.name
-                this.description shouldBe request.description
-                this.thumbnail shouldBe request.thumbnail
-            }
-        }
-
-        test("중복된 이름이 있으면 예외 응답") {
-            every {
-                themeWriter.create(request.name, request.description, request.thumbnail)
-            } throws ThemeException(ThemeErrorCode.THEME_NAME_DUPLICATED)
-
-            shouldThrow<ThemeException> {
-                themeService.createTheme(request)
-            }.also {
-                it.errorCode shouldBe ThemeErrorCode.THEME_NAME_DUPLICATED
-            }
-        }
-    }
-
-    context("deleteById") {
-        val themeId = 1L
-        val theme: ThemeEntity = ThemeFixture.create(id = themeId)
-
-        test("정상 응답") {
-            every { themeFinder.findById(themeId) } returns theme
-            every { themeWriter.delete(theme) } just Runs
-
-            shouldNotThrow<ThemeException> {
-                themeService.deleteTheme(themeId)
-            }
-        }
-
-        test("테마를 찾을 수 없으면 예외 응답") {
-            every { themeFinder.findById(themeId) } throws ThemeException(ThemeErrorCode.THEME_NOT_FOUND)
-
-            shouldThrow<ThemeException> {
-                themeService.deleteTheme(themeId)
-            }.also {
-                it.errorCode shouldBe ThemeErrorCode.THEME_NOT_FOUND
-            }
-        }
-
-        test("예약이 있는 테마이면 예외 응답") {
-            every { themeFinder.findById(themeId) } returns theme
-            every { themeWriter.delete(theme) } throws ThemeException(ThemeErrorCode.THEME_ALREADY_RESERVED)
-
-            shouldThrow<ThemeException> {
-                themeService.deleteTheme(themeId)
-            }.also {
-                it.errorCode shouldBe ThemeErrorCode.THEME_ALREADY_RESERVED
-            }
-        }
-    }
-})
diff --git a/src/test/kotlin/roomescape/theme/implement/ThemeFinderTest.kt b/src/test/kotlin/roomescape/theme/implement/ThemeFinderTest.kt
deleted file mode 100644
index c41ef15a..00000000
--- a/src/test/kotlin/roomescape/theme/implement/ThemeFinderTest.kt
+++ /dev/null
@@ -1,76 +0,0 @@
-package roomescape.theme.implement
-
-import io.kotest.assertions.throwables.shouldThrow
-import io.kotest.core.spec.style.FunSpec
-import io.kotest.matchers.collections.shouldHaveSize
-import io.kotest.matchers.shouldBe
-import io.mockk.every
-import io.mockk.mockk
-import io.mockk.verify
-import org.springframework.data.repository.findByIdOrNull
-import roomescape.theme.exception.ThemeErrorCode
-import roomescape.theme.exception.ThemeException
-import roomescape.theme.infrastructure.persistence.ThemeRepository
-import roomescape.util.ThemeFixture
-import java.time.LocalDate
-
-class ThemeFinderTest : FunSpec({
-    val themeRepository: ThemeRepository = mockk()
-
-    val themeFinder = ThemeFinder(themeRepository)
-
-    context("findAll") {
-        test("모든 테마를 조회한다.") {
-            every {
-                themeRepository.findAll()
-            } returns listOf(mockk(), mockk(), mockk())
-
-            themeRepository.findAll() shouldHaveSize 3
-        }
-    }
-
-    context("findById") {
-        val timeId = 1L
-        test("동일한 ID인 테마를 찾아 응답한다.") {
-            every {
-                themeRepository.findByIdOrNull(timeId)
-            } returns mockk()
-
-            themeFinder.findById(timeId)
-
-            verify(exactly = 1) {
-                themeRepository.findByIdOrNull(timeId)
-            }
-        }
-
-        test("동일한 ID인 테마가 없으면 실패한다.") {
-            every {
-                themeRepository.findByIdOrNull(timeId)
-            } returns null
-
-            shouldThrow<ThemeException> {
-                themeFinder.findById(timeId)
-            }.also {
-                it.errorCode shouldBe ThemeErrorCode.THEME_NOT_FOUND
-            }
-        }
-    }
-
-    context("findMostReservedThemes") {
-        test("입력된 개수보다 조회된 개수가 작으면 조회된 개수만큼 반환한다.") {
-            val count = 10
-            val startFrom = LocalDate.now().minusDays(7)
-            val endAt = LocalDate.now().minusDays(1)
-
-            every {
-                themeRepository.findPopularThemes(startFrom, endAt, count)
-            } returns listOf(
-                ThemeFixture.create(id = 1, name = "name1"),
-                ThemeFixture.create(id = 2, name = "name2"),
-                ThemeFixture.create(id = 3, name = "name3"),
-            )
-
-            themeFinder.findMostReservedThemes(count, startFrom, endAt) shouldHaveSize 3
-        }
-    }
-})
diff --git a/src/test/kotlin/roomescape/theme/implement/ThemeValidatorTest.kt b/src/test/kotlin/roomescape/theme/implement/ThemeValidatorTest.kt
deleted file mode 100644
index 175028dd..00000000
--- a/src/test/kotlin/roomescape/theme/implement/ThemeValidatorTest.kt
+++ /dev/null
@@ -1,79 +0,0 @@
-package roomescape.theme.implement
-
-import io.kotest.assertions.throwables.shouldNotThrow
-import io.kotest.assertions.throwables.shouldThrow
-import io.kotest.core.spec.style.FunSpec
-import io.kotest.matchers.shouldBe
-import io.mockk.every
-import io.mockk.mockk
-import roomescape.theme.exception.ThemeErrorCode
-import roomescape.theme.exception.ThemeException
-import roomescape.theme.infrastructure.persistence.ThemeEntity
-import roomescape.theme.infrastructure.persistence.ThemeRepository
-import roomescape.util.ThemeFixture
-
-class ThemeValidatorTest : FunSpec({
-    val themeRepository: ThemeRepository = mockk()
-
-    val themeValidator = ThemeValidator(themeRepository)
-
-    context("validateNameAlreadyExists") {
-        val name = "name"
-
-        test("같은 이름을 가진 테마가 있으면 예외를 던진다.") {
-            every {
-                themeRepository.existsByName(name)
-            } returns true
-
-            shouldThrow<ThemeException> {
-                themeValidator.validateNameAlreadyExists(name)
-            }.also {
-                it.errorCode shouldBe ThemeErrorCode.THEME_NAME_DUPLICATED
-            }
-        }
-
-        test("같은 이름을 가진 테마가 없으면 종료한다.") {
-            every {
-                themeRepository.existsByName(name)
-            } returns false
-
-            shouldNotThrow<ThemeException> {
-                themeValidator.validateNameAlreadyExists(name)
-            }
-        }
-    }
-
-    context("validateIsReserved") {
-        test("입력된 id가 null 이면 예외를 던진다.") {
-            shouldThrow<ThemeException> {
-                themeValidator.validateIsReserved(ThemeFixture.create(id = null))
-            }.also {
-                it.errorCode shouldBe ThemeErrorCode.INVALID_REQUEST_VALUE
-            }
-        }
-
-        val theme: ThemeEntity = ThemeFixture.create(id = 1L, name = "name")
-
-        test("예약이 있는 테마이면 예외를 던진다.") {
-            every {
-                themeRepository.isReservedTheme(theme.id!!)
-            } returns true
-
-            shouldThrow<ThemeException> {
-                themeValidator.validateIsReserved(theme)
-            }.also {
-                it.errorCode shouldBe ThemeErrorCode.THEME_ALREADY_RESERVED
-            }
-        }
-
-        test("예약이 없는 테마이면 종료한다.") {
-            every {
-                themeRepository.isReservedTheme(theme.id!!)
-            } returns false
-
-            shouldNotThrow<ThemeException> {
-                themeValidator.validateIsReserved(theme)
-            }
-        }
-    }
-})
diff --git a/src/test/kotlin/roomescape/theme/implement/ThemeWriterTest.kt b/src/test/kotlin/roomescape/theme/implement/ThemeWriterTest.kt
deleted file mode 100644
index eacfd714..00000000
--- a/src/test/kotlin/roomescape/theme/implement/ThemeWriterTest.kt
+++ /dev/null
@@ -1,86 +0,0 @@
-package roomescape.theme.implement
-
-import io.kotest.assertions.throwables.shouldThrow
-import io.kotest.core.spec.style.FunSpec
-import io.kotest.matchers.shouldBe
-import io.mockk.*
-import roomescape.common.config.next
-import roomescape.theme.exception.ThemeErrorCode
-import roomescape.theme.exception.ThemeException
-import roomescape.theme.infrastructure.persistence.ThemeEntity
-import roomescape.theme.infrastructure.persistence.ThemeRepository
-import roomescape.util.ThemeFixture
-import roomescape.util.TsidFactory
-
-class ThemeWriterTest : FunSpec({
-
-    val themeValidator: ThemeValidator = mockk()
-    val themeRepository: ThemeRepository = mockk()
-
-    val themeWriter = ThemeWriter(themeValidator, themeRepository, TsidFactory)
-
-    context("create") {
-        val name = "name"
-        val description = "description"
-        val thumbnail = "thumbnail"
-
-        test("중복된 이름이 있으면 실패한다.") {
-            every {
-                themeValidator.validateNameAlreadyExists(name)
-            } throws ThemeException(ThemeErrorCode.THEME_NAME_DUPLICATED)
-
-            shouldThrow<ThemeException> {
-                themeWriter.create(name, description, thumbnail)
-            }.also {
-                it.errorCode shouldBe ThemeErrorCode.THEME_NAME_DUPLICATED
-            }
-        }
-
-        test("중복된 이름이 없으면 저장한다.") {
-            every {
-                themeValidator.validateNameAlreadyExists(name)
-            } just Runs
-
-            every {
-                themeRepository.save(any())
-            } returns ThemeFixture.create(name = name, description = description, thumbnail = thumbnail)
-
-            themeWriter.create(name, description, thumbnail)
-
-            verify(exactly = 1) {
-                themeRepository.save(any())
-            }
-        }
-    }
-
-    context("delete") {
-        val theme: ThemeEntity = ThemeFixture.create(id = TsidFactory.next())
-        test("예약이 있는 테마이면 실패한다.") {
-            every {
-                themeValidator.validateIsReserved(theme)
-            } throws ThemeException(ThemeErrorCode.THEME_ALREADY_RESERVED)
-
-            shouldThrow<ThemeException> {
-                themeWriter.delete(theme)
-            }.also {
-                it.errorCode shouldBe ThemeErrorCode.THEME_ALREADY_RESERVED
-            }
-        }
-
-        test("예약이 없는 테마이면 제거한다.") {
-            every {
-                themeValidator.validateIsReserved(theme)
-            } just Runs
-
-            every {
-                themeRepository.delete(theme)
-            } just Runs
-
-            themeWriter.delete(theme)
-
-            verify(exactly = 1) {
-                themeRepository.delete(theme)
-            }
-        }
-    }
-})
diff --git a/src/test/kotlin/roomescape/theme/infrastructure/persistence/ThemeRepositoryTest.kt b/src/test/kotlin/roomescape/theme/infrastructure/persistence/ThemeRepositoryTest.kt
deleted file mode 100644
index 6b8e6aa8..00000000
--- a/src/test/kotlin/roomescape/theme/infrastructure/persistence/ThemeRepositoryTest.kt
+++ /dev/null
@@ -1,144 +0,0 @@
-package roomescape.theme.infrastructure.persistence
-
-import io.kotest.core.spec.style.FunSpec
-import io.kotest.matchers.collections.shouldContainInOrder
-import io.kotest.matchers.shouldBe
-import jakarta.persistence.EntityManager
-import org.springframework.boot.test.autoconfigure.orm.jpa.DataJpaTest
-import roomescape.theme.util.TestThemeDataHelper
-import java.time.LocalDate
-
-@DataJpaTest(showSql = false)
-class ThemeRepositoryTest(
-    val themeRepository: ThemeRepository,
-    val entityManager: EntityManager
-) : FunSpec() {
-
-    val helper = TestThemeDataHelper(entityManager, transactionTemplate = null)
-
-    init {
-        context("findTopNThemeBetweenStartDateAndEndDate") {
-            beforeTest {
-                for (i in 1..10) {
-                    helper.createThemeWithReservations(
-                        name = "테마$i",
-                        reservedCount = i,
-                        date = LocalDate.now().minusDays(i.toLong()),
-                    )
-                }
-            }
-
-            test("지난 10일간 예약 수가 가장 많은 테마 5개를 조회") {
-                themeRepository.findPopularThemes(
-                    LocalDate.now().minusDays(10),
-                    LocalDate.now().minusDays(1),
-                    5
-                ).also { themes ->
-                    themes.size shouldBe 5
-                    themes.map { it.name } shouldContainInOrder listOf(
-                        "테마10", "테마9", "테마8", "테마7", "테마6"
-                    )
-                }
-            }
-
-            test("8일 전부터 5일 전까지 예약 수가 가장 많은 테마 3개를 조회") {
-                themeRepository.findPopularThemes(
-                    LocalDate.now().minusDays(8),
-                    LocalDate.now().minusDays(5),
-                    3
-                ).also { themes ->
-                    themes.size shouldBe 3
-                    themes.map { it.name } shouldContainInOrder listOf(
-                        "테마8", "테마7", "테마6"
-                    )
-                }
-            }
-
-            test("예약 수가 동일하면 먼저 생성된 테마를 우선 조회") {
-                helper.createThemeWithReservations(
-                    name = "테마11",
-                    reservedCount = 5,
-                    date = LocalDate.now().minusDays(5),
-                )
-
-                themeRepository.findPopularThemes(
-                    LocalDate.now().minusDays(6),
-                    LocalDate.now().minusDays(4),
-                    5
-                ).also { themes ->
-                    themes.size shouldBe 4
-                    themes.map { it.name } shouldContainInOrder listOf(
-                        "테마6", "테마5", "테마11", "테마4"
-                    )
-                }
-            }
-
-            test("입력된 갯수보다 조회된 갯수가 작으면, 조회된 갯수만큼 반환") {
-                themeRepository.findPopularThemes(
-                    LocalDate.now().minusDays(10),
-                    LocalDate.now().minusDays(6),
-                    10
-                ).also { themes ->
-                    themes.size shouldBe 5
-                }
-            }
-
-            test("입력된 갯수보다 조회된 갯수가 많으면, 입력된 갯수만큼 반환") {
-                themeRepository.findPopularThemes(
-                    LocalDate.now().minusDays(10),
-                    LocalDate.now().minusDays(1),
-                    15
-                ).also { themes ->
-                    themes.size shouldBe 10
-                }
-            }
-
-            test("입력된 날짜 범위에 예약된 테마가 없을 경우 빈 리스트 반환") {
-                themeRepository.findPopularThemes(
-                    LocalDate.now().plusDays(1),
-                    LocalDate.now().plusDays(10),
-                    5
-                ).also { themes ->
-                    themes.size shouldBe 0
-                }
-            }
-        }
-        context("existsByName ") {
-            val themeName = "test-theme"
-            beforeTest {
-                helper.createThemeWithReservations(
-                    name = themeName,
-                    reservedCount = 0,
-                    date = LocalDate.now()
-                )
-            }
-            test("테마 이름이 존재하면 true 반환") {
-                themeRepository.existsByName(themeName) shouldBe true
-            }
-
-            test("테마 이름이 존재하지 않으면 false 반환") {
-                themeRepository.existsByName(themeName.repeat(2)) shouldBe false
-            }
-        }
-
-        context("isReservedTheme") {
-            test("테마가 예약 중이면 true 반환") {
-                val theme = helper.createThemeWithReservations(
-                    name = "예약된 테마",
-                    reservedCount = 1,
-                    date = LocalDate.now()
-                )
-                themeRepository.isReservedTheme(theme.id!!) shouldBe true
-            }
-
-            test("테마가 예약 중이 아니면 false 반환") {
-                val theme = helper.createThemeWithReservations(
-                    name = "예약되지 않은 테마",
-                    reservedCount = 0,
-                    date = LocalDate.now()
-                )
-                themeRepository.isReservedTheme(theme.id!!) shouldBe false
-            }
-        }
-    }
-}
diff --git a/src/test/kotlin/roomescape/theme/util/TestThemeDataHelper.kt b/src/test/kotlin/roomescape/theme/util/TestThemeDataHelper.kt
deleted file mode 100644
index 9df5f6a3..00000000
--- a/src/test/kotlin/roomescape/theme/util/TestThemeDataHelper.kt
+++ /dev/null
@@ -1,57 +0,0 @@
-package roomescape.theme.util
-
-import jakarta.persistence.EntityManager
-import org.springframework.transaction.support.TransactionTemplate
-import roomescape.member.infrastructure.persistence.MemberEntity
-import roomescape.reservation.infrastructure.persistence.ReservationStatus
-import roomescape.theme.infrastructure.persistence.ThemeEntity
-import roomescape.time.infrastructure.persistence.TimeEntity
-import roomescape.util.MemberFixture
-import roomescape.util.ReservationFixture
-import roomescape.util.ThemeFixture
-import roomescape.util.TimeFixture
-import java.time.LocalDate
-import java.time.LocalTime
-
-class TestThemeDataHelper(
-    val entityManager: EntityManager,
-    val transactionTemplate: TransactionTemplate?
-) {
-    /**
-     * GET /themes/most-reserved-last-week API와 관련 Repository 테스트에 사용
-     * @param name: 테마 이름
-     * @param reservedCount: 이 테마가 예약된 횟수
-     * @param date: reservedCount 개의 예약을 만들 때 사용할 날짜
-     */
-    fun createThemeWithReservations(name: String, reservedCount: Int, date: LocalDate): ThemeEntity =
-        if (transactionTemplate == null) {
-            createAndGet(name, reservedCount, date)
-        } else {
-            transactionTemplate.execute { createAndGet(name, reservedCount, date) }!!
-        }
-
-
-    fun createAndGet(name: String, reservedCount: Int, date: LocalDate): ThemeEntity {
-        val themeEntity: ThemeEntity = ThemeFixture.create(name = name).also { entityManager.persist(it) }
-        val member: MemberEntity = MemberFixture.create().also { entityManager.persist(it) }
-
-        for (i in 1..reservedCount) {
-            val time: TimeEntity = TimeFixture.create(
-                startAt = LocalTime.now().plusMinutes(i.toLong())
-            ).also { entityManager.persist(it) }
-
-            ReservationFixture.create(
-                date = date,
-                theme = themeEntity,
-                member = member,
-                time = time,
-                status = ReservationStatus.entries.random()
-            ).also { entityManager.persist(it) }
-        }
-
-        entityManager.flush()
-        entityManager.clear()
-
-        return themeEntity
-    }
-}
diff --git a/src/test/kotlin/roomescape/theme/web/MostReservedThemeApiTest.kt b/src/test/kotlin/roomescape/theme/web/MostReservedThemeApiTest.kt
deleted file mode 100644
index b29a4bba..00000000
--- a/src/test/kotlin/roomescape/theme/web/MostReservedThemeApiTest.kt
+++ /dev/null
@@ -1,110 +0,0 @@
-package roomescape.theme.web
-
-import io.kotest.core.spec.style.FunSpec
-import io.restassured.module.kotlin.extensions.Given
-import io.restassured.module.kotlin.extensions.Then
-import io.restassured.module.kotlin.extensions.When
-import jakarta.persistence.EntityManager
-import org.hamcrest.Matchers.equalTo
-import org.springframework.boot.test.context.SpringBootTest
-import org.springframework.boot.test.web.server.LocalServerPort
-import org.springframework.transaction.support.TransactionTemplate
-import roomescape.theme.util.TestThemeDataHelper
-import roomescape.util.CleanerMode
-import roomescape.util.DatabaseCleanerExtension
-import java.time.LocalDate
-import kotlin.random.Random
-
-@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT)
-class MostReservedThemeApiTest(
-    @LocalServerPort val port: Int,
-    val transactionTemplate: TransactionTemplate,
-    val entityManager: EntityManager,
-) : FunSpec({ extension(DatabaseCleanerExtension(mode = CleanerMode.AFTER_SPEC)) }) {
-
-    val helper = TestThemeDataHelper(entityManager, transactionTemplate)
-
-    init {
-        beforeSpec {
-            transactionTemplate.executeWithoutResult {
-                // 7일 전 ~ 1일 전 예약된 테마 10개 생성
-                for (i in 1..10) {
-                    helper.createThemeWithReservations(
-                        name = "테마$i",
-                        reservedCount = 1,
-                        date = LocalDate.now().minusDays(Random.nextLong(1, 7))
-                    )
-                }
-
-                // 8일 전 예약된 테마 1개 생성
-                helper.createThemeWithReservations(
-                    name = "테마11",
-                    reservedCount = 1,
-                    date = LocalDate.now().minusDays(8)
-                )
-
-                // 당일 예약된 테마 1개 생성
-                helper.createThemeWithReservations(
-                    name = "테마12",
-                    reservedCount = 1,
-                    date = LocalDate.now()
-                )
-            }
-        }
-
-        context("GET /themes/most-reserved-last-week") {
-            val endpoint = "/themes/most-reserved-last-week"
-
-            test("count 파라미터가 없으면 10개를 반환한다") {
-                Given {
-                    port(port)
-                } When {
-                    get(endpoint)
-                } Then {
-                    statusCode(200)
-                    body("data.themes.size()", equalTo(10))
-                }
-            }
-
-            test("조회된 테마가 count보다 적으면 조회된 만큼 반환한다") {
-                val count = 15
-                Given {
-                    port(port)
-                    param("count", count)
-                } When {
-                    get(endpoint)
-                } Then {
-                    statusCode(200)
-                    body("data.themes.size()", equalTo(10))
-                }
-            }
-
-            test("조회된 테마가 count보다 많으면 count만큼 반환한다") {
-                val count = 5
-                Given {
-                    port(port)
-                    param("count", count)
-                } When {
-                    get(endpoint)
-                } Then {
-                    statusCode(200)
-                    body("data.themes.size()", equalTo(count))
-                }
-            }
-
-            test("지난 7일 동안의 예약만 집계한다") {
-                // beforeSpec 에서 정의한 테스트 데이터 중, 8일 전 / 당일 예약 테마는 제외되어야 한다.
-                val count = 12
-                Given {
-                    port(port)
-                    param("count", count)
-                } When {
-                    get(endpoint)
-                } Then {
-                    statusCode(200)
-                    body("data.themes.size()", equalTo(10))
-                }
-            }
-        }
-    }
-}
diff --git a/src/test/kotlin/roomescape/theme/web/ThemeControllerTest.kt b/src/test/kotlin/roomescape/theme/web/ThemeControllerTest.kt
deleted file mode 100644
index 8fb1745a..00000000
--- a/src/test/kotlin/roomescape/theme/web/ThemeControllerTest.kt
+++ /dev/null
@@ -1,278 +0,0 @@
-package roomescape.theme.web
-
-import com.ninjasquad.springmockk.MockkBean
-import io.mockk.every
-import org.hamcrest.Matchers.equalTo
-import org.springframework.boot.test.autoconfigure.web.servlet.WebMvcTest
-import org.springframework.http.MediaType
-import org.springframework.test.web.servlet.MockMvc
-import roomescape.auth.exception.AuthErrorCode
-import roomescape.common.exception.CommonErrorCode
-import roomescape.theme.business.ThemeService
-import roomescape.theme.exception.ThemeErrorCode
-import roomescape.theme.exception.ThemeException
-import roomescape.util.RoomescapeApiTest
-import roomescape.util.ThemeFixture
-
-@WebMvcTest(ThemeController::class)
-class ThemeControllerTest(val mockMvc: MockMvc) : RoomescapeApiTest() {
-    @MockkBean
-    private lateinit var themeService: ThemeService
-
-    init {
-        Given("GET /themes 요청을") {
-            val endpoint = "/themes"
-
-            When("로그인 하지 않은 사용자가 보내면") {
-                doNotLogin()
-
-                Then("예외 응답") {
-                    val expectedError = AuthErrorCode.MEMBER_NOT_FOUND
-                    runGetTest(
-                        mockMvc = mockMvc,
-                        endpoint = endpoint,
-                    ) {
-                        status { isEqualTo(expectedError.httpStatus.value()) }
-                    }.andExpect {
-                        jsonPath("$.code") { value(expectedError.errorCode) }
-                    }
-                }
-            }
-
-            When("로그인 상태라면") {
-                loginAsUser()
-
-                Then("정상 응답") {
-                    every {
-                        themeService.findThemes()
-                    } returns listOf(
-                        ThemeFixture.create(id = 1, name = "theme1"),
-                        ThemeFixture.create(id = 2, name = "theme2"),
-                        ThemeFixture.create(id = 3, name = "theme3")
-                    ).toRetrieveListResponse()
-
-                    runGetTest(
-                        mockMvc = mockMvc,
-                        endpoint = endpoint,
-                    ) {
-                        status { isOk() }
-                        content {
-                            contentType(MediaType.APPLICATION_JSON)
-                            jsonPath("$.data.themes[0].id") { value(1) }
-                            jsonPath("$.data.themes[1].id") { value(2) }
-                            jsonPath("$.data.themes[2].id") { value(3) }
-                        }
-                    }
-                }
-            }
-        }
-
-        Given("POST /themes 요청을") {
-            val endpoint = "/themes"
-            val request = ThemeCreateRequest(
-                name = "theme1",
-                description = "description1",
-                thumbnail = "http://example.com/thumbnail1.jpg"
-            )
-
-            When("로그인 하지 않은 사용자가 보내면") {
-                doNotLogin()
-
-                Then("예외 응답") {
-                    val expectedError = AuthErrorCode.MEMBER_NOT_FOUND
-                    runPostTest(
-                        mockMvc = mockMvc,
-                        endpoint = endpoint,
-                        body = request,
-                    ) {
-                        status { isEqualTo(expectedError.httpStatus.value()) }
-                        jsonPath("$.code", equalTo(expectedError.errorCode))
-                    }
-                }
-            }
-
-            When("관리자가 아닌 사용자가 보내면") {
-                loginAsUser()
-
-                Then("예외 응답") {
-                    val expectedError = AuthErrorCode.ACCESS_DENIED
-                    runPostTest(
-                        mockMvc = mockMvc,
-                        endpoint = endpoint,
-                        body = request,
-                    ) {
-                        status { isEqualTo(expectedError.httpStatus.value()) }
-                        jsonPath("$.code") { value(expectedError.errorCode) }
-                    }
-                }
-            }
-
-            When("관리자가 보낼 때") {
-                beforeTest {
-                    loginAsAdmin()
-                }
-
-                Then("동일한 이름의 테마가 있으면 예외 응답") {
-                    val expectedError = ThemeErrorCode.THEME_NAME_DUPLICATED
-
-                    every {
-                        themeService.createTheme(request)
-                    } throws ThemeException(expectedError)
-
-                    runPostTest(
-                        mockMvc = mockMvc,
-                        endpoint = endpoint,
-                        body = request,
-                    ) {
-                        status { isEqualTo(expectedError.httpStatus.value()) }
-                        jsonPath("$.code") { value(expectedError.errorCode) }
-                    }
-                }
-
-                When("입력 값의 형식이 잘못되면 예외 응답") {
-                    val request = ThemeCreateRequest(
-                        name = "theme1",
-                        description = "description1",
-                        thumbnail = "http://example.com/thumbnail1.jpg"
-                    )
-
-                    fun runTest(request: ThemeCreateRequest) {
-                        val expectedError = CommonErrorCode.INVALID_INPUT_VALUE
-
-                        runPostTest(
-                            mockMvc = mockMvc,
-                            endpoint = endpoint,
-                            body = request,
-                        ) {
-                            status { isEqualTo(expectedError.httpStatus.value()) }
-                            jsonPath("$.code") { value(expectedError.errorCode) }
-                        }
-                    }
-
-                    Then("이름이 공백인 경우") {
-                        val invalidRequest = request.copy(name = " ")
-                        runTest(invalidRequest)
-                    }
-
-                    Then("이름이 20글자를 초과하는 경우") {
-                        val invalidRequest = request.copy(name = "a".repeat(21))
-                        runTest(invalidRequest)
-                    }
-
-                    Then("설명이 공백인 경우") {
-                        val invalidRequest = request.copy(description = " ")
-                        runTest(invalidRequest)
-                    }
-
-                    Then("설명이 100글자를 초과하는 경우") {
-                        val invalidRequest = request.copy(description = "a".repeat(101))
-                        runTest(invalidRequest)
-                    }
-
-                    Then("썸네일이 공백인 경우") {
-                        val invalidRequest = request.copy(thumbnail = " ")
-                        runTest(invalidRequest)
-                    }
-
-                    Then("썸네일이 URL 형식이 아닌 경우") {
-                        val invalidRequest = request.copy(thumbnail = "invalid-url")
-                        runTest(invalidRequest)
-                    }
-                }
-
-                Then("정상 응답") {
-                    val theme = ThemeFixture.create(
-                        id = 1,
-                        name = request.name,
-                        description = request.description,
-                        thumbnail = request.thumbnail
-                    )
-
-                    every {
-                        themeService.createTheme(request)
-                    } returns theme.toCreateResponse()
-
-                    runPostTest(
-                        mockMvc = mockMvc,
-                        endpoint = endpoint,
-                        body = request,
-                    ) {
-                        status { isCreated() }
-                        header {
-                            string("Location", "/themes/${theme.id}")
-                        }
-                        jsonPath("$.data.id") { value(theme.id) }
-                        jsonPath("$.data.name") { value(theme.name) }
-                        jsonPath("$.data.description") { value(theme.description) }
-                        jsonPath("$.data.thumbnail") { value(theme.thumbnail) }
-                    }
-                }
-            }
-        }
-
-        Given("DELETE /themes/{id} 요청을") {
-            val themeId = 1L
-            val endpoint = "/themes/$themeId"
-
-            When("관리자가 아닌 사용자가 보내면 예외 응답") {
-                Then("로그인 하지 않은 경우") {
-                    doNotLogin()
-
-                    val expectedError = AuthErrorCode.MEMBER_NOT_FOUND
-                    runDeleteTest(
-                        mockMvc = mockMvc,
-                        endpoint = endpoint,
-                    ) {
-                        status { isEqualTo(expectedError.httpStatus.value()) }
-                        jsonPath("$.code", equalTo(expectedError.errorCode))
-                    }
-                }
-
-                Then("로그인은 하였으나 관리자가 아닌 경우") {
-                    loginAsUser()
-
-                    val expectedError = AuthErrorCode.ACCESS_DENIED
-                    runDeleteTest(
-                        mockMvc = mockMvc,
-                        endpoint = endpoint,
-                    ) {
-                        status { isEqualTo(expectedError.httpStatus.value()) }
-                        jsonPath("$.code", equalTo(expectedError.errorCode))
-                    }
-                }
-            }
-
-            When("관리자가 보낼 때") {
-                beforeTest {
-                    loginAsAdmin()
-                }
-
-                Then("이미 예약된 테마이면 예외 응답") {
-                    val expectedError = ThemeErrorCode.THEME_ALREADY_RESERVED
-                    every {
-                        themeService.deleteTheme(themeId)
-                    } throws ThemeException(expectedError)
-
-                    runDeleteTest(
-                        mockMvc = mockMvc,
-                        endpoint = endpoint,
-                    ) {
-                        status { isEqualTo(expectedError.httpStatus.value()) }
-                        jsonPath("$.code") { value(expectedError.errorCode) }
-                    }
-                }
-
-                Then("정상 응답") {
-                    every { themeService.deleteTheme(themeId) } returns Unit
-
-                    runDeleteTest(
-                        mockMvc = mockMvc,
-                        endpoint = endpoint,
-                    ) {
-                        status { isNoContent() }
-                    }
-                }
-            }
-        }
-    }
-}
diff --git a/src/test/kotlin/roomescape/time/business/TimeServiceTest.kt b/src/test/kotlin/roomescape/time/business/TimeServiceTest.kt
deleted file mode 100644
index 95add3b7..00000000
--- a/src/test/kotlin/roomescape/time/business/TimeServiceTest.kt
+++ /dev/null
@@ -1,180 +0,0 @@
-package roomescape.time.business
-
-import io.kotest.assertions.assertSoftly
-import io.kotest.assertions.throwables.shouldNotThrow
-import io.kotest.assertions.throwables.shouldThrow
-import io.kotest.core.spec.style.FunSpec
-import io.kotest.matchers.collections.shouldContainExactly
-import io.kotest.matchers.collections.shouldHaveSize
-import io.kotest.matchers.shouldBe
-import io.mockk.Runs
-import io.mockk.every
-import io.mockk.just
-import io.mockk.mockk
-import roomescape.time.business.domain.TimeWithAvailability
-import roomescape.theme.exception.ThemeErrorCode
-import roomescape.theme.exception.ThemeException
-import roomescape.time.exception.TimeErrorCode
-import roomescape.time.exception.TimeException
-import roomescape.time.implement.TimeFinder
-import roomescape.time.implement.TimeWriter
-import roomescape.time.infrastructure.persistence.TimeEntity
-import roomescape.time.web.TimeCreateRequest
-import roomescape.util.TimeFixture
-import java.time.LocalDate
-import java.time.LocalTime
-
-class TimeServiceTest : FunSpec({
-    val timeFinder: TimeFinder = mockk()
-    val timeWriter: TimeWriter = mockk()
-
-    val timeService = TimeService(timeFinder, timeWriter)
-
-    context("findById") {
-        val id = 1L
-
-        test("정상 응답") {
-            every {
-                timeFinder.findById(id)
-            } returns TimeFixture.create(id = id)
-
-            timeService.findById(id).id shouldBe id
-        }
-
-        test("시간을 찾을 수 없으면 예외 응답") {
-            every {
-                timeFinder.findById(id)
-            } throws TimeException(TimeErrorCode.TIME_NOT_FOUND)
-
-            shouldThrow<TimeException> {
-                timeService.findById(id)
-            }.also {
-                it.errorCode shouldBe TimeErrorCode.TIME_NOT_FOUND
-            }
-        }
-    }
-
-    context("findTimes") {
-        test("정상 응답") {
-            val times: List<TimeEntity> = listOf(
-                TimeFixture.create(startAt = LocalTime.now()),
-                TimeFixture.create(startAt = LocalTime.now().plusMinutes(1)),
-                TimeFixture.create(startAt = LocalTime.now().plusMinutes(2))
-            )
-
-            every {
-                timeFinder.findAll()
-            } returns times
-
-            val response = timeService.findTimes()
-
-            assertSoftly(response.times) {
-                it shouldHaveSize times.size
-                it.map { time -> time.startAt } shouldContainExactly times.map { time -> time.startAt }
-            }
-        }
-    }
-
-    context("findTimesWithAvailability") {
-        val date = LocalDate.now()
-        val themeId = 1L
-
-        test("정상 응답") {
-            val times: List<TimeWithAvailability> = listOf(
-                TimeWithAvailability(1, LocalTime.now(), date, themeId, true),
-                TimeWithAvailability(2, LocalTime.now().plusMinutes(1), date, themeId, false),
-                TimeWithAvailability(3, LocalTime.now().plusMinutes(2), date, themeId, true)
-            )
-
-            every {
-                timeFinder.findAllWithAvailabilityByDateAndThemeId(date, themeId)
-            } returns times
-
-            val response = timeService.findTimesWithAvailability(date, themeId)
-
-            assertSoftly(response.times) {
-                it shouldHaveSize times.size
-                it.map { time -> time.isAvailable } shouldContainExactly times.map { time -> time.isReservable }
-            }
-        }
-
-        test("테마를 찾을 수 없으면 예외 응답") {
-            every {
-                timeFinder.findAllWithAvailabilityByDateAndThemeId(date, themeId)
-            } throws ThemeException(ThemeErrorCode.THEME_NOT_FOUND)
-
-            shouldThrow<ThemeException> {
-                timeService.findTimesWithAvailability(date, themeId)
-            }.also {
-                it.errorCode shouldBe ThemeErrorCode.THEME_NOT_FOUND
-            }
-        }
-    }
-
-    context("createTime") {
-        val request = TimeCreateRequest(startAt = LocalTime.of(10, 0))
-
-        test("정상 응답") {
-            val time: TimeEntity = TimeFixture.create(startAt = request.startAt)
-
-            every {
-                timeWriter.create(request.startAt)
-            } returns time
-
-            val response = timeService.createTime(request)
-            response.id shouldBe time.id
-        }
-
-        test("중복된 시간이 있으면 예외 응답") {
-            every {
-                timeWriter.create(request.startAt)
-            } throws TimeException(TimeErrorCode.TIME_DUPLICATED)
-
-            shouldThrow<TimeException> {
-                timeService.createTime(request)
-            }.also {
-                it.errorCode shouldBe TimeErrorCode.TIME_DUPLICATED
-            }
-        }
-    }
-
-    context("deleteTime") {
-        test("정상 응답") {
-            val id = 1L
-            val time = TimeFixture.create(id = id)
-
-            every { timeFinder.findById(id) } returns time
-            every { timeWriter.delete(time) } just Runs
-
-            shouldNotThrow<Exception> {
-                timeService.deleteTime(id)
-            }
-        }
-
-        test("시간을 찾을 수 없으면 예외 응답") {
-            val id = 1L
-
-            every { timeFinder.findById(id) } throws TimeException(TimeErrorCode.TIME_NOT_FOUND)
-
-            shouldThrow<TimeException> {
-                timeService.deleteTime(id)
-            }.also {
-                it.errorCode shouldBe TimeErrorCode.TIME_NOT_FOUND
-            }
-        }
-
-        test("예약이 있는 시간이면 예외 응답") {
-            val id = 1L
-            val time = TimeFixture.create()
-
-            every { timeFinder.findById(id) } returns time
-            every { timeWriter.delete(time) } throws TimeException(TimeErrorCode.TIME_ALREADY_RESERVED)
-
-            shouldThrow<TimeException> {
-                timeService.deleteTime(id)
-            }.also {
-                it.errorCode shouldBe TimeErrorCode.TIME_ALREADY_RESERVED
-            }
-        }
-    }
-})
diff --git a/src/test/kotlin/roomescape/time/implement/TimeFinderTest.kt b/src/test/kotlin/roomescape/time/implement/TimeFinderTest.kt
deleted file mode 100644
index ba6014a9..00000000
--- a/src/test/kotlin/roomescape/time/implement/TimeFinderTest.kt
+++ /dev/null
@@ -1,144 +0,0 @@
-package roomescape.time.implement
-
-import io.kotest.assertions.assertSoftly
-import io.kotest.assertions.throwables.shouldThrow
-import io.kotest.core.spec.style.FunSpec
-import io.kotest.matchers.collections.shouldHaveSize
-import io.kotest.matchers.shouldBe
-import io.mockk.every
-import io.mockk.mockk
-import io.mockk.verify
-import org.springframework.data.repository.findByIdOrNull
-import roomescape.reservation.implement.ReservationFinder
-import roomescape.reservation.infrastructure.persistence.ReservationEntity
-import roomescape.time.business.domain.TimeWithAvailability
-import roomescape.theme.exception.ThemeErrorCode
-import roomescape.theme.exception.ThemeException
-import roomescape.theme.implement.ThemeFinder
-import roomescape.time.exception.TimeErrorCode
-import roomescape.time.exception.TimeException
-import roomescape.time.infrastructure.persistence.TimeRepository
-import roomescape.util.TimeFixture
-import java.time.LocalDate
-import java.time.LocalTime
-
-class TimeFinderTest : FunSpec({
-    val timeRepository: TimeRepository = mockk()
-    val reservationFinder: ReservationFinder = mockk()
-    val themeFinder: ThemeFinder = mockk()
-
-    val timeFinder = TimeFinder(timeRepository, reservationFinder, themeFinder)
-
-    context("findAll") {
-        test("모든 시간을 조회한다.") {
-            every {
-                timeRepository.findAll()
-            } returns listOf(mockk(), mockk(), mockk())
-
-            timeFinder.findAll() shouldHaveSize 3
-        }
-    }
-
-    context("findById") {
-        val timeId = 1L
-        test("동일한 ID인 시간을 찾아 응답한다.") {
-            every {
-                timeRepository.findByIdOrNull(timeId)
-            } returns mockk()
-
-            timeFinder.findById(timeId)
-
-            verify(exactly = 1) {
-                timeRepository.findByIdOrNull(timeId)
-            }
-        }
-
-        test("동일한 ID인 시간이 없으면 실패한다.") {
-            every {
-                timeRepository.findByIdOrNull(timeId)
-            } returns null
-
-            shouldThrow<TimeException> {
-                timeFinder.findById(timeId)
-            }.also {
-                it.errorCode shouldBe TimeErrorCode.TIME_NOT_FOUND
-            }
-        }
-    }
-
-    context("findAllWithAvailabilityByDateAndThemeId") {
-        val date = LocalDate.now()
-        val themeId = 1L
-
-        test("테마를 찾을 수 없으면 실패한다.") {
-            every {
-                themeFinder.findById(themeId)
-            } throws ThemeException(ThemeErrorCode.THEME_NOT_FOUND)
-
-            shouldThrow<ThemeException> {
-                timeFinder.findAllWithAvailabilityByDateAndThemeId(date, themeId)
-            }.also {
-                it.errorCode shouldBe ThemeErrorCode.THEME_NOT_FOUND
-            }
-        }
-
-        test("날짜, 테마에 맞는 예약 자체가 없으면 모든 시간이 예약 가능하다.") {
-            every {
-                themeFinder.findById(themeId)
-            } returns mockk()
-
-            every {
-                reservationFinder.findAllByDateAndTheme(date, any())
-            } returns emptyList()
-
-            every {
-                timeRepository.findAll()
-            } returns listOf(
-                TimeFixture.create(startAt = LocalTime.now()),
-                TimeFixture.create(startAt = LocalTime.now().plusMinutes(30))
-            )
-
-            val result: List<TimeWithAvailability> =
-                timeFinder.findAllWithAvailabilityByDateAndThemeId(date, themeId)
-
-            assertSoftly(result) {
-                it shouldHaveSize 2
-                it.all { time -> time.isReservable }
-            }
-        }
-
-        test("날짜, 테마에 맞는 예약이 있으면 예약할 수 없다.") {
-            val times = listOf(
-                TimeFixture.create(startAt = LocalTime.now()),
-                TimeFixture.create(startAt = LocalTime.now().plusMinutes(30))
-            )
-            every {
-                themeFinder.findById(themeId)
-            } returns mockk()
-
-            every {
-                timeRepository.findAll()
-            } returns times
-
-            every {
-                reservationFinder.findAllByDateAndTheme(date, any())
-            } returns listOf(
-                mockk<ReservationEntity>().apply {
-                    every { time.id } returns times[0].id
-                },
-                mockk<ReservationEntity>().apply {
-                    every { time.id } returns 0
-                }
-            )
-
-            val result: List<TimeWithAvailability> =
-                timeFinder.findAllWithAvailabilityByDateAndThemeId(date, themeId)
-
-            assertSoftly(result) {
-                it shouldHaveSize 2
-                it[0].isReservable shouldBe false
-                it[1].isReservable shouldBe true
-            }
-        }
-    }
-})
diff --git a/src/test/kotlin/roomescape/time/implement/TimeValidatorTest.kt b/src/test/kotlin/roomescape/time/implement/TimeValidatorTest.kt
deleted file mode 100644
index ff835923..00000000
--- a/src/test/kotlin/roomescape/time/implement/TimeValidatorTest.kt
+++ /dev/null
@@ -1,74 +0,0 @@
-package roomescape.time.implement
-
-import io.kotest.assertions.throwables.shouldNotThrow
-import io.kotest.assertions.throwables.shouldThrow
-import io.kotest.core.spec.style.FunSpec
-import io.kotest.matchers.shouldBe
-import io.mockk.every
-import io.mockk.mockk
-import roomescape.reservation.implement.ReservationFinder
-import roomescape.time.exception.TimeErrorCode
-import roomescape.time.exception.TimeException
-import roomescape.time.infrastructure.persistence.TimeEntity
-import roomescape.time.infrastructure.persistence.TimeRepository
-import roomescape.util.TimeFixture
-import java.time.LocalTime
-
-class TimeValidatorTest : FunSpec({
-    val timeRepository: TimeRepository = mockk()
-    val reservationFinder: ReservationFinder = mockk()
-
-    val timeValidator = TimeValidator(timeRepository, reservationFinder)
-
-    context("validateIsAlreadyExists") {
-        val startAt = LocalTime.now()
-
-        test("같은 이메일을 가진 회원이 있으면 예외를 던진다.") {
-            every {
-                timeRepository.existsByStartAt(startAt)
-            } returns true
-
-            shouldThrow<TimeException> {
-                timeValidator.validateIsAlreadyExists(startAt)
-            }.also {
-                it.errorCode shouldBe TimeErrorCode.TIME_DUPLICATED
-            }
-        }
-
-        test("같은 이메일을 가진 회원이 없으면 종료한다.") {
-            every {
-                timeRepository.existsByStartAt(startAt)
-            } returns false
-
-            shouldNotThrow<TimeException> {
-                timeValidator.validateIsAlreadyExists(startAt)
-            }
-        }
-    }
-
-    context("validateIsReserved") {
-        val time: TimeEntity = TimeFixture.create(startAt = LocalTime.now())
-
-        test("해당 시간에 예약이 있으면 예외를 던진다.") {
-            every {
-                reservationFinder.isTimeReserved(time)
-            } returns true
-
-            shouldThrow<TimeException> {
-                timeValidator.validateIsReserved(time)
-            }.also {
-                it.errorCode shouldBe TimeErrorCode.TIME_ALREADY_RESERVED
-            }
-        }
-
-        test("해당 시간에 예약이 없으면 종료한다.") {
-            every {
-                reservationFinder.isTimeReserved(time)
-            } returns false
-
-            shouldNotThrow<TimeException> {
-                timeValidator.validateIsReserved(time)
-            }
-        }
-    }
-})
diff --git a/src/test/kotlin/roomescape/time/implement/TimeWriterTest.kt b/src/test/kotlin/roomescape/time/implement/TimeWriterTest.kt
deleted file mode 100644
index 017e7047..00000000
--- a/src/test/kotlin/roomescape/time/implement/TimeWriterTest.kt
+++ /dev/null
@@ -1,84 +0,0 @@
-package roomescape.time.implement
-
-import io.kotest.assertions.throwables.shouldThrow
-import io.kotest.core.spec.style.FunSpec
-import io.kotest.matchers.shouldBe
-import io.mockk.*
-import roomescape.time.exception.TimeErrorCode
-import roomescape.time.exception.TimeException
-import roomescape.time.infrastructure.persistence.TimeEntity
-import roomescape.time.infrastructure.persistence.TimeRepository
-import roomescape.util.TimeFixture
-import roomescape.util.TsidFactory
-import java.time.LocalTime
-
-class TimeWriterTest : FunSpec({
-
-    val timeValidator: TimeValidator = mockk()
-    val timeRepository: TimeRepository = mockk()
-
-    val timeWriter = TimeWriter(timeValidator, timeRepository, TsidFactory)
-
-    context("create") {
-        val startAt = LocalTime.now()
-
-        test("중복된 시간이 있으면 실패한다.") {
-            every {
-                timeValidator.validateIsAlreadyExists(startAt)
-            } throws TimeException(TimeErrorCode.TIME_DUPLICATED)
-
-            shouldThrow<TimeException> {
-                timeWriter.create(startAt)
-            }.also {
-                it.errorCode shouldBe TimeErrorCode.TIME_DUPLICATED
-            }
-        }
-
-        test("중복된 시간이 없으면 저장한다.") {
-            every {
-                timeValidator.validateIsAlreadyExists(startAt)
-            } just Runs
-
-            every {
-                timeRepository.save(any())
-            } returns TimeFixture.create(startAt = startAt)
-
-            timeWriter.create(startAt)
-
-            verify(exactly = 1) {
-                timeRepository.save(any())
-            }
-        }
-    }
-
-    context("delete") {
-        val time: TimeEntity = TimeFixture.create()
-        test("예약이 있는 시간이면 실패한다.") {
-            every {
-                timeValidator.validateIsReserved(time)
-            } throws TimeException(TimeErrorCode.TIME_ALREADY_RESERVED)
-
-            shouldThrow<TimeException> {
-                timeWriter.delete(time)
-            }.also {
-                it.errorCode shouldBe TimeErrorCode.TIME_ALREADY_RESERVED
-            }
-        }
-
-        test("예약이 없는 시간이면 제거한다.") {
-            every {
-                timeValidator.validateIsReserved(time)
-            } just Runs
-
-            every {
-                timeRepository.delete(time)
-            } just Runs
-
-            timeWriter.delete(time)
-
-            verify(exactly = 1) {
-                timeRepository.delete(time)
-            }
-        }
-    }
-})
diff --git a/src/test/kotlin/roomescape/time/infrastructure/persistence/TimeRepositoryTest.kt b/src/test/kotlin/roomescape/time/infrastructure/persistence/TimeRepositoryTest.kt
deleted file mode 100644
index bc79357b..00000000
--- a/src/test/kotlin/roomescape/time/infrastructure/persistence/TimeRepositoryTest.kt
+++ /dev/null
@@ -1,33 +0,0 @@
-package roomescape.time.infrastructure.persistence
-
-import io.kotest.core.spec.style.FunSpec
-import io.kotest.matchers.shouldBe
-import jakarta.persistence.EntityManager
-import org.springframework.boot.test.autoconfigure.orm.jpa.DataJpaTest
-import roomescape.util.TimeFixture
-import java.time.LocalTime
-
-@DataJpaTest(showSql = false)
-class TimeRepositoryTest(
-    val entityManager: EntityManager,
-    val timeRepository: TimeRepository,
-) : FunSpec({
-
-    context("existsByStartAt") {
-        val startAt = LocalTime.of(10, 0)
-
-        beforeTest {
-            entityManager.persist(TimeFixture.create(startAt = startAt))
-            entityManager.flush()
-            entityManager.clear()
-        }
-
-        test("동일한 시간이 있으면 true 반환") {
-            timeRepository.existsByStartAt(startAt) shouldBe true
-        }
-
-        test("동일한 시간이 없으면 false 반환") {
-            timeRepository.existsByStartAt(startAt.plusSeconds(1)) shouldBe false
-        }
-    }
-})
\ No newline at end of file
diff --git a/src/test/kotlin/roomescape/time/web/TimeControllerTest.kt b/src/test/kotlin/roomescape/time/web/TimeControllerTest.kt
deleted file mode 100644
index 42543d34..00000000
--- a/src/test/kotlin/roomescape/time/web/TimeControllerTest.kt
+++ /dev/null
@@ -1,312 +0,0 @@
-package roomescape.time.web
-
-import com.ninjasquad.springmockk.MockkBean
-import io.kotest.assertions.assertSoftly
-import io.kotest.matchers.collections.shouldHaveSize
-import io.kotest.matchers.shouldBe
-import io.mockk.every
-import org.hamcrest.Matchers.equalTo
-import org.springframework.boot.test.autoconfigure.web.servlet.WebMvcTest
-import org.springframework.http.MediaType
-import org.springframework.test.web.servlet.MockMvc
-import roomescape.auth.exception.AuthErrorCode
-import roomescape.theme.exception.ThemeErrorCode
-import roomescape.theme.exception.ThemeException
-import roomescape.time.business.TimeService
-import roomescape.time.exception.TimeErrorCode
-import roomescape.time.exception.TimeException
-import roomescape.util.RoomescapeApiTest
-import roomescape.util.TimeFixture
-import java.time.LocalDate
-import java.time.LocalTime
-
-@WebMvcTest(TimeController::class)
-class TimeControllerTest(val mockMvc: MockMvc) : RoomescapeApiTest() {
-    @MockkBean
-    private lateinit var timeService: TimeService
-
-    init {
-        Given("GET /times 요청을") {
-            val endpoint = "/times"
-
-            When("관리자가 보내면") {
-                beforeTest {
-                    loginAsAdmin()
-                }
-
-                Then("정상 응답") {
-                    every {
-                        timeService.findTimes()
-                    } returns listOf(
-                        TimeFixture.create(id = 1L),
-                        TimeFixture.create(id = 2L)
-                    ).toResponse()
-
-                    runGetTest(
-                        mockMvc = mockMvc,
-                        endpoint = endpoint,
-                    ) {
-                        status { isOk() }
-                        content {
-                            contentType(MediaType.APPLICATION_JSON)
-                            jsonPath("$.data.times[0].id") { value(1) }
-                            jsonPath("$.data.times[1].id") { value(2) }
-                        }
-                    }
-                }
-            }
-
-            When("관리자가 보내지 않았다면") {
-                loginAsUser()
-                val expectedError = AuthErrorCode.ACCESS_DENIED
-
-                Then("예외 응답") {
-                    runGetTest(
-                        mockMvc = mockMvc,
-                        endpoint = endpoint,
-                    ) {
-                        status { isEqualTo(expectedError.httpStatus.value()) }
-                    }.andExpect {
-                        content {
-                            contentType(MediaType.APPLICATION_JSON)
-                            jsonPath("$.code") { equalTo(expectedError.errorCode) }
-                        }
-                    }
-                }
-            }
-        }
-
-        Given("POST /times 요청을") {
-            val endpoint = "/times"
-
-            When("관리자가 보낼 때") {
-                beforeTest {
-                    loginAsAdmin()
-                }
-                val time = LocalTime.of(10, 0)
-                val request = TimeCreateRequest(startAt = time)
-
-                Then("시간 형식이 HH:mm이 아니거나, 범위를 벗어나면 400 응답") {
-                    listOf(
-                        "{\"startAt\": \"23:30:30\"}",
-                        "{\"startAt\": \"24:59\"}",
-                    ).forEach {
-                        runPostTest(
-                            mockMvc = mockMvc,
-                            endpoint = endpoint,
-                            body = it,
-                        ) {
-                            status { isBadRequest() }
-                        }
-                    }
-                }
-
-                Then("정상 응답") {
-                    every {
-                        timeService.createTime(request)
-                    } returns TimeCreateResponse(id = 1, startAt = time)
-
-                    runPostTest(
-                        mockMvc = mockMvc,
-                        endpoint = endpoint,
-                        body = request,
-                    ) {
-                        status { isCreated() }
-                        content {
-                            contentType(MediaType.APPLICATION_JSON)
-                            jsonPath("$.data.id") { value(1) }
-                            jsonPath("$.data.startAt") { value("10:00") }
-                        }
-                    }
-                }
-
-                Then("동일한 시간이 존재하면 예외 응답") {
-                    val expectedError = TimeErrorCode.TIME_DUPLICATED
-                    every {
-                        timeService.createTime(request)
-                    } throws TimeException(expectedError)
-
-                    runPostTest(
-                        mockMvc = mockMvc,
-                        endpoint = endpoint,
-                        body = request,
-                    ) {
-                        status { isEqualTo(expectedError.httpStatus.value()) }
-                        content {
-                            contentType(MediaType.APPLICATION_JSON)
-                            jsonPath("$.code") { equalTo(expectedError.errorCode) }
-                        }
-                    }
-                }
-            }
-
-            When("관리자가 보내지 않았다면") {
-                loginAsUser()
-
-                Then("예외 응답") {
-                    val expectedError = AuthErrorCode.ACCESS_DENIED
-                    runPostTest(
-                        mockMvc = mockMvc,
-                        endpoint = endpoint,
-                        body = TimeFixture.create(),
-                    ) {
-                        status { isEqualTo(expectedError.httpStatus.value()) }
-                        jsonPath("$.code", equalTo(expectedError.errorCode))
-                    }
-                }
-            }
-        }
-
-        Given("DELETE /times/{id} 요청을") {
-            val endpoint = "/times/1"
-
-            When("관리자가 보낼 때") {
-                beforeTest {
-                    loginAsAdmin()
-                }
-
-                Then("정상 응답") {
-                    every {
-                        timeService.deleteTime(1L)
-                    } returns Unit
-
-                    runDeleteTest(
-                        mockMvc = mockMvc,
-                        endpoint = endpoint,
-                    ) {
-                        status { isNoContent() }
-                    }
-                }
-
-                Then("없는 시간을 조회하면 예외 응답") {
-                    val id = 1L
-                    val expectedError = TimeErrorCode.TIME_NOT_FOUND
-
-                    every {
-                        timeService.deleteTime(id)
-                    } throws TimeException(expectedError)
-
-                    runDeleteTest(
-                        mockMvc = mockMvc,
-                        endpoint = "/times/$id",
-                    ) {
-                        status { isEqualTo(expectedError.httpStatus.value()) }
-                        content {
-                            contentType(MediaType.APPLICATION_JSON)
-                            jsonPath("$.code") { equalTo(expectedError.errorCode) }
-                        }
-                    }
-                }
-
-                Then("예약이 있는 시간을 삭제하면 예외 응답") {
-                    val id = 1L
-                    val expectedError = TimeErrorCode.TIME_ALREADY_RESERVED
-
-                    every {
-                        timeService.deleteTime(id)
-                    } throws TimeException(expectedError)
-
-                    runDeleteTest(
-                        mockMvc = mockMvc,
-                        endpoint = "/times/$id",
-                    ) {
-                        status { isEqualTo(expectedError.httpStatus.value()) }
-                        content {
-                            contentType(MediaType.APPLICATION_JSON)
-                            jsonPath("$.code") { equalTo(expectedError.errorCode) }
-                        }
-                    }
-                }
-            }
-
-            When("관리자가 보내지 않았다면") {
-                loginAsUser()
-
-                Then("예외 응답") {
-                    val expectedError = AuthErrorCode.ACCESS_DENIED
-                    runDeleteTest(
-                        mockMvc = mockMvc,
-                        endpoint = endpoint,
-                    ) {
-                        status { isEqualTo(expectedError.httpStatus.value()) }
-                        jsonPath("$.code", equalTo(expectedError.errorCode))
-                    }
-                }
-            }
-        }
-
-        Given("GET /times/search?date={date}&themeId={themeId} 요청을 ") {
-            val date: LocalDate = LocalDate.now()
-            val themeId = 1L
-
-            When("회원이 보낼 때") {
-                beforeTest {
-                    loginAsUser()
-                }
-
-                Then("정상 응답") {
-                    val response = TimeWithAvailabilityListResponse(
-                        listOf(
-                            TimeWithAvailabilityResponse(1L, LocalTime.of(10, 0), true),
-                            TimeWithAvailabilityResponse(2L, LocalTime.of(10, 1), false),
-                            TimeWithAvailabilityResponse(3L, LocalTime.of(10, 2), true)
-                        )
-                    )
-                    every {
-                        timeService.findTimesWithAvailability(date, themeId)
-                    } returns response
-
-                    val result = runGetTest(
-                        mockMvc = mockMvc,
-                        endpoint = "/times/search?date=$date&themeId=$themeId",
-                    ) {
-                        status { isOk() }
-                        content {
-                            contentType(MediaType.APPLICATION_JSON)
-                        }
-                    }.andReturn().readValue(TimeWithAvailabilityListResponse::class.java)
-
-                    assertSoftly(result.times) {
-                        this shouldHaveSize response.times.size
-                        this[0].id shouldBe response.times[0].id
-                        this[0].isAvailable shouldBe response.times[0].isAvailable
-
-                        this[1].id shouldBe response.times[1].id
-                        this[1].isAvailable shouldBe response.times[1].isAvailable
-                    }
-                }
-                Then("테마를 찾을 수 없으면 예외 응답") {
-                    val expectedError = ThemeErrorCode.THEME_NOT_FOUND
-                    every {
-                        timeService.findTimesWithAvailability(date, themeId)
-                    } throws ThemeException(expectedError)
-
-                    runGetTest(
-                        mockMvc = mockMvc,
-                        endpoint = "/times/search?date=$date&themeId=$themeId",
-                    ) {
-                        status { isNotFound() }
-                        jsonPath("$.code", equalTo(expectedError.errorCode))
-                    }
-                }
-            }
-
-            When("비회원이 보내면") {
-                doNotLogin()
-
-                Then("예외 응답") {
-                    val expectedError = AuthErrorCode.MEMBER_NOT_FOUND
-
-                    runGetTest(
-                        mockMvc = mockMvc,
-                        endpoint = "/times/search?date=$date&themeId=$themeId",
-                    ) {
-                        status { isEqualTo(expectedError.httpStatus.value()) }
-                        jsonPath("$.code", equalTo(expectedError.errorCode))
-                    }
-
-                }
-            }
-        }
-    }
-}
diff --git a/src/test/kotlin/roomescape/util/DummyInitializer.kt b/src/test/kotlin/roomescape/util/DummyInitializer.kt
new file mode 100644
index 00000000..cef0eab6
--- /dev/null
+++ b/src/test/kotlin/roomescape/util/DummyInitializer.kt
@@ -0,0 +1,224 @@
+package roomescape.util
+
+import io.restassured.module.kotlin.extensions.Extract
+import io.restassured.module.kotlin.extensions.Given
+import io.restassured.module.kotlin.extensions.When
+import org.springframework.data.repository.findByIdOrNull
+import org.springframework.http.MediaType
+import roomescape.payment.business.PaymentWriter
+import roomescape.payment.infrastructure.client.CardDetail
+import roomescape.payment.infrastructure.client.EasyPayDetail
+import roomescape.payment.infrastructure.client.TransferDetail
+import roomescape.payment.infrastructure.common.PaymentMethod
+import roomescape.payment.infrastructure.persistence.CanceledPaymentEntity
+import roomescape.payment.infrastructure.persistence.PaymentEntity
+import roomescape.payment.infrastructure.persistence.PaymentRepository
+import roomescape.payment.web.PaymentConfirmRequest
+import roomescape.payment.web.PaymentRetrieveResponse
+import roomescape.payment.web.toPaymentDetailResponse
+import roomescape.payment.web.toRetrieveResponse
+import roomescape.reservation.infrastructure.persistence.ReservationEntity
+import roomescape.reservation.infrastructure.persistence.ReservationRepository
+import roomescape.reservation.web.PendingReservationCreateRequest
+import roomescape.schedule.infrastructure.persistence.ScheduleEntity
+import roomescape.schedule.infrastructure.persistence.ScheduleRepository
+import roomescape.schedule.infrastructure.persistence.ScheduleStatus
+import roomescape.schedule.web.ScheduleCreateRequest
+import roomescape.schedule.web.ScheduleUpdateRequest
+import roomescape.theme.infrastructure.persistence.ThemeEntity
+import roomescape.theme.infrastructure.persistence.ThemeRepository
+import roomescape.theme.web.ThemeCreateRequest
+import java.time.LocalDateTime
+
+class DummyInitializer(
+    private val themeRepository: ThemeRepository,
+    private val scheduleRepository: ScheduleRepository,
+    private val reservationRepository: ReservationRepository,
+    private val paymentRepository: PaymentRepository,
+    private val paymentWriter: PaymentWriter
+) {
+    fun createTheme(adminToken: String, request: ThemeCreateRequest): ThemeEntity {
+        val createdThemeId: Long = Given {
+            contentType(MediaType.APPLICATION_JSON_VALUE)
+            header("Authorization", "Bearer $adminToken")
+            body(request)
+        } When {
+            post("/admin/themes")
+        } Extract {
+            path("data.id")
+        }
+
+        return themeRepository.findByIdOrNull(createdThemeId)
+            ?: throw RuntimeException("unexpected error occurred")
+    }
+
+    fun createSchedule(
+        adminToken: String,
+        request: ScheduleCreateRequest,
+        status: ScheduleStatus = ScheduleStatus.AVAILABLE
+    ): ScheduleEntity {
+        val themeId: Long = if (request.themeId > 1L) {
+            request.themeId
+        } else {
+            createTheme(
+                adminToken = adminToken,
+                request = ThemeFixture.createRequest.copy(name = "theme-${System.currentTimeMillis()}")
+            ).id
+        }
+        val createdScheduleId: Long = Given {
+            contentType(MediaType.APPLICATION_JSON_VALUE)
+            header("Authorization", "Bearer $adminToken")
+            body(request.copy(themeId = themeId))
+        } When {
+            post("/schedules")
+        } Extract {
+            path("data.id")
+        }
+
+        Given {
+            contentType(MediaType.APPLICATION_JSON_VALUE)
+            header("Authorization", "Bearer $adminToken")
+            body(ScheduleUpdateRequest(status = status))
+        } When {
+            patch("/schedules/$createdScheduleId")
+        }
+
+        return scheduleRepository.findByIdOrNull(createdScheduleId)
+            ?: throw RuntimeException("unexpected error occurred")
+    }
+
+    fun createPendingReservation(
+        adminToken: String,
+        reserverToken: String,
+        themeRequest: ThemeCreateRequest = ThemeFixture.createRequest,
+        scheduleRequest: ScheduleCreateRequest = ScheduleFixture.createRequest,
+        reservationRequest: PendingReservationCreateRequest = ReservationFixture.pendingCreateRequest,
+    ): ReservationEntity {
+        val themeId: Long = createTheme(
+            adminToken = adminToken,
+            request = themeRequest
+        ).id
+
+        val scheduleId: Long = createSchedule(
+            adminToken = adminToken,
+            request = scheduleRequest.copy(themeId = themeId),
+            status = ScheduleStatus.HOLD
+        ).id
+
+        return createPendingReservation(
+            reserverToken = reserverToken,
+            request = reservationRequest.copy(scheduleId = scheduleId)
+        )
+    }
+
+    fun createConfirmReservation(
+        adminToken: String,
+        reserverToken: String,
+        themeRequest: ThemeCreateRequest = ThemeFixture.createRequest,
+        scheduleRequest: ScheduleCreateRequest = ScheduleFixture.createRequest,
+        reservationRequest: PendingReservationCreateRequest = ReservationFixture.pendingCreateRequest,
+    ): ReservationEntity {
+        val themeId: Long = createTheme(
+            adminToken = adminToken,
+            request = themeRequest
+        ).id
+
+        val schedule: ScheduleEntity = createSchedule(
+            adminToken = adminToken,
+            request = scheduleRequest.copy(themeId = themeId),
+            status = ScheduleStatus.HOLD
+        )
+
+        val reservation = createPendingReservation(
+            reserverToken = reserverToken,
+            request = reservationRequest.copy(scheduleId = schedule.id)
+        )
+
+        Given {
+            contentType(MediaType.APPLICATION_JSON_VALUE)
+            header("Authorization", "Bearer $reserverToken")
+        } When {
+            post("/reservations/${reservation.id}/confirm")
+        }
+
+        return reservationRepository.findByIdOrNull(reservation.id)
+            ?: throw RuntimeException("unexpected error occurred")
+    }
+
+    fun createPayment(
+        reservationId: Long,
+        request: PaymentConfirmRequest = PaymentFixture.confirmRequest,
+        cardDetail: CardDetail? = null,
+        easyPayDetail: EasyPayDetail? = null,
+        transferDetail: TransferDetail? = null,
+    ): PaymentRetrieveResponse {
+        val method = if (easyPayDetail != null) {
+            PaymentMethod.EASY_PAY
+        } else if (cardDetail != null) {
+            PaymentMethod.CARD
+        } else if (transferDetail != null) {
+            PaymentMethod.TRANSFER
+        } else {
+            throw AssertionError("결제타입 확인 필요.")
+        }
+
+        val clientConfirmResponse = PaymentFixture.confirmResponse(
+            paymentKey = request.paymentKey,
+            amount = request.amount,
+            method = method,
+            cardDetail = cardDetail,
+            easyPayDetail = easyPayDetail,
+            transferDetail = transferDetail
+        )
+
+        val payment = paymentWriter.createPayment(
+            reservationId = reservationId,
+            orderId = request.orderId,
+            paymentType = request.paymentType,
+            paymentClientConfirmResponse = clientConfirmResponse
+        )
+
+        val detail = paymentWriter.createDetail(clientConfirmResponse, payment.id)
+
+        return payment.toRetrieveResponse(detail = detail.toPaymentDetailResponse(), cancel = null)
+    }
+
+    fun cancelPayment(
+        memberId: Long,
+        reservationId: Long,
+        cancelReason: String,
+    ): CanceledPaymentEntity {
+        val payment: PaymentEntity = paymentRepository.findByReservationId(reservationId)
+            ?: throw AssertionError("Unexpected Exception Occurred.")
+
+        val clientCancelResponse = PaymentFixture.cancelResponse(
+            amount = payment.totalAmount,
+            cancelReason = cancelReason,
+        )
+
+        return paymentWriter.cancel(
+            memberId,
+            payment,
+            requestedAt = LocalDateTime.now(),
+            clientCancelResponse
+        )
+    }
+
+    private fun createPendingReservation(
+        reserverToken: String,
+        request: PendingReservationCreateRequest,
+    ): ReservationEntity {
+        val createdReservationId: Long = Given {
+            contentType(MediaType.APPLICATION_JSON_VALUE)
+            header("Authorization", "Bearer $reserverToken")
+            body(request.copy(scheduleId = request.scheduleId))
+        } When {
+            post("/reservations/pending")
+        } Extract {
+            path("data.id")
+        }
+
+        return reservationRepository.findByIdOrNull(createdReservationId)
+            ?: throw RuntimeException("unexpected error occurred")
+    }
+}
diff --git a/src/test/kotlin/roomescape/util/Fixtures.kt b/src/test/kotlin/roomescape/util/Fixtures.kt
index 8c74a3da..a4eb0d8a 100644
--- a/src/test/kotlin/roomescape/util/Fixtures.kt
+++ b/src/test/kotlin/roomescape/util/Fixtures.kt
@@ -1,204 +1,155 @@
 package roomescape.util
 
 import com.github.f4b6a3.tsid.TsidFactory
-import roomescape.auth.infrastructure.jwt.JwtHandler
-import roomescape.auth.web.LoginRequest
-import roomescape.common.config.next
 import roomescape.member.infrastructure.persistence.MemberEntity
 import roomescape.member.infrastructure.persistence.Role
-import roomescape.payment.infrastructure.client.PaymentApproveRequest
-import roomescape.payment.infrastructure.client.PaymentApproveResponse
-import roomescape.payment.infrastructure.persistence.CanceledPaymentEntity
-import roomescape.payment.infrastructure.persistence.PaymentEntity
+import roomescape.payment.infrastructure.client.*
+import roomescape.payment.infrastructure.common.*
 import roomescape.payment.web.PaymentCancelRequest
-import roomescape.payment.web.PaymentCancelResponse
-import roomescape.reservation.infrastructure.persistence.ReservationEntity
-import roomescape.reservation.infrastructure.persistence.ReservationStatus
-import roomescape.reservation.web.AdminReservationCreateRequest
-import roomescape.reservation.web.ReservationCreateWithPaymentRequest
-import roomescape.reservation.web.WaitingCreateRequest
-import roomescape.theme.infrastructure.persistence.ThemeEntity
-import roomescape.time.infrastructure.persistence.TimeEntity
+import roomescape.payment.web.PaymentConfirmRequest
+import roomescape.reservation.web.PendingReservationCreateRequest
+import roomescape.schedule.web.ScheduleCreateRequest
+import roomescape.theme.infrastructure.persistence.Difficulty
+import roomescape.theme.web.ThemeCreateRequest
 import java.time.LocalDate
 import java.time.LocalTime
 import java.time.OffsetDateTime
 
-val TsidFactory: TsidFactory = TsidFactory(0)
+const val INVALID_PK: Long = 9999L
+val tsidFactory = TsidFactory(0)
 
 object MemberFixture {
-    const val NOT_LOGGED_IN_USERID: Long = 0
-
-    fun create(
-        id: Long? = TsidFactory.next(),
-        name: String = "sangdol",
-        account: String = "default",
-        password: String = "password",
-        role: Role = Role.ADMIN
-    ): MemberEntity = MemberEntity(id, name, "$account@email.com", password, role)
-
-    fun admin(): MemberEntity = create(
-        id = 2L,
-        account = "admin",
+    val admin: MemberEntity = MemberEntity(
+        _id = 9304,
+        name = "ADMIN",
+        email = "admin@example.com",
+        password = "adminPassword",
         role = Role.ADMIN
     )
 
-    fun adminLoginRequest(): LoginRequest = LoginRequest(
-        email = admin().email,
-        password = admin().password
-    )
-
-    fun user(): MemberEntity = create(
-        id = 1L,
-        account = "user",
+    val user: MemberEntity = MemberEntity(
+        _id = 9305,
+        name = "USER",
+        email = "user@example.com",
+        password = "userPassword",
         role = Role.MEMBER
     )
-
-    fun userLoginRequest(): LoginRequest = LoginRequest(
-        email = user().email,
-        password = user().password
-    )
-}
-
-object TimeFixture {
-    fun create(
-        id: Long? = TsidFactory.next(),
-        startAt: LocalTime = LocalTime.now().plusHours(1),
-    ): TimeEntity = TimeEntity(id, startAt)
 }
 
 object ThemeFixture {
-    fun create(
-        id: Long? = TsidFactory.next(),
-        name: String = "Default Theme",
-        description: String = "Default Description",
-        thumbnail: String = "https://example.com/default-thumbnail.jpg"
-    ): ThemeEntity = ThemeEntity(id, name, description, thumbnail)
-}
-
-object ReservationFixture {
-    fun create(
-        id: Long? = TsidFactory.next(),
-        date: LocalDate = LocalDate.now().plusWeeks(1),
-        theme: ThemeEntity = ThemeFixture.create(),
-        time: TimeEntity = TimeFixture.create(),
-        member: MemberEntity = MemberFixture.create(),
-        status: ReservationStatus = ReservationStatus.CONFIRMED_PAYMENT_REQUIRED
-    ): ReservationEntity = ReservationEntity(id, date, time, theme, member, status)
-
-    fun createRequest(
-        date: LocalDate = LocalDate.now().plusWeeks(1),
-        themeId: Long = 1L,
-        timeId: Long = 1L,
-        paymentKey: String = "paymentKey",
-        orderId: String = "orderId",
-        amount: Long = 10000L,
-        paymentType: String = "NORMAL",
-    ): ReservationCreateWithPaymentRequest = ReservationCreateWithPaymentRequest(
-        date = date,
-        timeId = timeId,
-        themeId = themeId,
-        paymentKey = paymentKey,
-        orderId = orderId,
-        amount = amount,
-        paymentType = paymentType
-    )
-
-    fun createAdminRequest(
-        date: LocalDate = LocalDate.now().plusWeeks(1),
-        themeId: Long = 1L,
-        timeId: Long = 1L,
-        memberId: Long = 1L
-    ): AdminReservationCreateRequest = AdminReservationCreateRequest(
-        date = date,
-        timeId = timeId,
-        themeId = themeId,
-        memberId = memberId
-    )
-
-    fun createWaitingRequest(
-        date: LocalDate = LocalDate.now().plusWeeks(1),
-        themeId: Long = 1L,
-        timeId: Long = 1L
-    ): WaitingCreateRequest = WaitingCreateRequest(
-        date = date,
-        timeId = timeId,
-        themeId = themeId
+    val createRequest: ThemeCreateRequest = ThemeCreateRequest(
+        name = "Matilda Green",
+        description = "constituto",
+        thumbnailUrl = "https://duckduckgo.com/?q=mediocrem",
+        difficulty = Difficulty.VERY_EASY,
+        price = 10000,
+        minParticipants = 3,
+        maxParticipants = 5,
+        availableMinutes = 80,
+        expectedMinutesFrom = 60,
+        expectedMinutesTo = 70,
+        isOpen = true
     )
 }
 
-object JwtFixture {
-    const val SECRET_KEY_STRING: String = "daijawligagaf@LIJ$@U)9nagnalkkgalijaddljfi"
-    const val EXPIRATION_TIME: Long = 1000 * 60 * 60
-
-    fun create(
-        secretKey: String = SECRET_KEY_STRING,
-        expirationTime: Long = EXPIRATION_TIME
-    ): JwtHandler = JwtHandler(secretKey, expirationTime)
+object ScheduleFixture {
+    val createRequest: ScheduleCreateRequest = ScheduleCreateRequest(
+        date = LocalDate.now().plusDays(1),
+        time = LocalTime.now(),
+        themeId = 1L
+    )
 }
 
 object PaymentFixture {
-    const val PAYMENT_KEY: String = "paymentKey"
-    const val ORDER_ID: String = "orderId"
-    const val AMOUNT: Long = 10000L
+    val confirmRequest: PaymentConfirmRequest = PaymentConfirmRequest(
+        paymentKey = "paymentKey",
+        orderId = "orderId",
+        amount = 10000,
+        paymentType = PaymentType.NORMAL
+    )
 
-    fun create(
-        id: Long? = TsidFactory.next(),
-        orderId: String = ORDER_ID,
-        paymentKey: String = PAYMENT_KEY,
-        totalAmount: Long = AMOUNT,
-        reservation: ReservationEntity = ReservationFixture.create(id = 1L),
-        approvedAt: OffsetDateTime = OffsetDateTime.now()
-    ): PaymentEntity = PaymentEntity(
-        _id = id,
-        orderId = orderId,
+    val cancelRequest: PaymentCancelRequest = PaymentCancelRequest(
+        reservationId = 1L,
+        cancelReason = "cancelReason",
+    )
+
+    fun cardDetail(
+        amount: Int,
+        issuerCode: CardIssuerCode = CardIssuerCode.SHINHAN,
+        cardType: CardType = CardType.CREDIT,
+        ownerType: CardOwnerType = CardOwnerType.PERSONAL,
+        installmentPlanMonths: Int = 0,
+    ): CardDetail = CardDetail(
+        issuerCode = issuerCode,
+        number = "429335*********",
+        amount = amount,
+        cardType = cardType,
+        ownerType = ownerType,
+        isInterestFree = false,
+        approveNo = "1828382",
+        installmentPlanMonths = installmentPlanMonths
+    )
+
+    fun easypayDetail(
+        amount: Int,
+        provider: EasyPayCompanyCode = EasyPayCompanyCode.TOSSPAY,
+        discountAmount: Int = 0
+    ): EasyPayDetail = EasyPayDetail(provider, amount, discountAmount)
+
+    fun transferDetail(
+        bankCode: BankCode = BankCode.SHINHAN,
+        settlementStatus: String = "COMPLETED"
+    ): TransferDetail = TransferDetail(
+        bankCode = bankCode,
+        settlementStatus = settlementStatus
+    )
+
+    fun confirmResponse(
+        paymentKey: String,
+        amount: Int,
+        method: PaymentMethod,
+        cardDetail: CardDetail?,
+        easyPayDetail: EasyPayDetail?,
+        transferDetail: TransferDetail?
+    ) = PaymentClientConfirmResponse(
         paymentKey = paymentKey,
-        totalAmount = totalAmount,
-        reservation = reservation,
-        approvedAt = approvedAt
+        status = PaymentStatus.DONE,
+        totalAmount = amount,
+        vat = (amount * 0.1).toInt(),
+        suppliedAmount = (amount * 0.9).toInt(),
+        method = method,
+        card = cardDetail,
+        easyPay = easyPayDetail,
+        transfer = transferDetail,
+        requestedAt = OffsetDateTime.now(),
+        approvedAt = OffsetDateTime.now().plusSeconds(5)
     )
 
-    fun createCanceled(
-        id: Long? = TsidFactory.next(),
-        paymentKey: String = PAYMENT_KEY,
-        cancelReason: String = "Test Cancel",
-        cancelAmount: Long = AMOUNT,
-        approvedAt: OffsetDateTime = OffsetDateTime.now(),
-        canceledAt: OffsetDateTime = approvedAt.plusHours(1)
-    ): CanceledPaymentEntity = CanceledPaymentEntity(
-        _id = id,
-        paymentKey = paymentKey,
-        cancelReason = cancelReason,
-        cancelAmount = cancelAmount,
-        approvedAt = approvedAt,
-        canceledAt = canceledAt
-
-    )
-
-    fun createApproveRequest(): PaymentApproveRequest = PaymentApproveRequest(
-        paymentKey = PAYMENT_KEY,
-        orderId = ORDER_ID,
-        amount = AMOUNT,
-        paymentType = "CARD"
-    )
-
-    fun createApproveResponse(): PaymentApproveResponse = PaymentApproveResponse(
-        paymentKey = PAYMENT_KEY,
-        orderId = ORDER_ID,
-        approvedAt = OffsetDateTime.now(),
-        totalAmount = AMOUNT
-    )
-
-    fun createCancelRequest(): PaymentCancelRequest = PaymentCancelRequest(
-        paymentKey = PAYMENT_KEY,
-        amount = AMOUNT,
-        cancelReason = "Test Cancel"
-    )
-
-    fun createCancelResponse(): PaymentCancelResponse = PaymentCancelResponse(
-        cancelStatus = "SUCCESS",
-        cancelReason = "Test Cancel",
-        cancelAmount = AMOUNT,
-        canceledAt = OffsetDateTime.now().plusMinutes(1)
+    fun cancelResponse(
+        amount: Int,
+        cardDiscountAmount: Int = 0,
+        transferDiscountAmount: Int = 0,
+        easypayDiscountAmount: Int = 0,
+        cancelReason: String = "cancelReason"
+    ) = PaymentClientCancelResponse(
+        status = PaymentStatus.CANCELED,
+        cancels = CancelDetail(
+            cancelAmount = amount,
+            cardDiscountAmount = cardDiscountAmount,
+            transferDiscountAmount = transferDiscountAmount,
+            easyPayDiscountAmount = easypayDiscountAmount,
+            canceledAt = OffsetDateTime.now().plusSeconds(5),
+            cancelReason = cancelReason
+        ),
     )
 }
 
+object ReservationFixture {
+    val pendingCreateRequest: PendingReservationCreateRequest = PendingReservationCreateRequest(
+        scheduleId = 1L,
+        reserverName = "Wilbur Stuart",
+        reserverContact = "wilbur@example.com",
+        participantCount = 5,
+        requirement = "Hello, Nice to meet you!"
+    )
+}
diff --git a/src/test/kotlin/roomescape/util/FixturesV2.kt b/src/test/kotlin/roomescape/util/FixturesV2.kt
deleted file mode 100644
index d1a738d5..00000000
--- a/src/test/kotlin/roomescape/util/FixturesV2.kt
+++ /dev/null
@@ -1,51 +0,0 @@
-package roomescape.util
-
-import roomescape.member.infrastructure.persistence.MemberEntity
-import roomescape.member.infrastructure.persistence.Role
-import roomescape.schedule.web.ScheduleCreateRequest
-import roomescape.theme.infrastructure.persistence.v2.Difficulty
-import roomescape.theme.web.ThemeCreateRequestV2
-import java.time.LocalDate
-import java.time.LocalTime
-
-object MemberFixtureV2 {
-    val admin: MemberEntity = MemberEntity(
-        _id = 9304,
-        name = "ADMIN",
-        email = "admin@example.com",
-        password = "adminPassword",
-        role = Role.ADMIN
-    )
-
-    val user: MemberEntity = MemberEntity(
-        _id = 9305,
-        name = "USER",
-        email = "user@example.com",
-        password = "userPassword",
-        role = Role.MEMBER
-    )
-}
-
-object ThemeFixtureV2 {
-    val createRequest: ThemeCreateRequestV2 = ThemeCreateRequestV2(
-        name = "Matilda Green",
-        description = "constituto",
-        thumbnailUrl = "https://duckduckgo.com/?q=mediocrem",
-        difficulty = Difficulty.VERY_EASY,
-        price = 10000,
-        minParticipants = 3,
-        maxParticipants = 5,
-        availableMinutes = 80,
-        expectedMinutesFrom = 60,
-        expectedMinutesTo = 70,
-        isOpen = true
-    )
-}
-
-object ScheduleFixture {
-    val createRequest: ScheduleCreateRequest = ScheduleCreateRequest(
-        date = LocalDate.now().plusDays(1),
-        time = LocalTime.now(),
-        themeId = 1L
-    )
-}
diff --git a/src/test/kotlin/roomescape/util/KotestConfig.kt b/src/test/kotlin/roomescape/util/KotestConfig.kt
index a808def5..6833fe8e 100644
--- a/src/test/kotlin/roomescape/util/KotestConfig.kt
+++ b/src/test/kotlin/roomescape/util/KotestConfig.kt
@@ -2,22 +2,29 @@ package roomescape.util
 
 import io.kotest.core.config.AbstractProjectConfig
 import io.kotest.core.spec.Spec
-import io.kotest.core.spec.style.BehaviorSpec
 import io.kotest.core.spec.style.FunSpec
-import io.kotest.core.spec.style.StringSpec
 import io.kotest.extensions.spring.SpringExtension
 import io.kotest.extensions.spring.SpringTestExtension
 import io.restassured.RestAssured
 import org.springframework.beans.factory.annotation.Autowired
 import org.springframework.boot.test.context.SpringBootTest
+import org.springframework.boot.test.context.TestConfiguration
 import org.springframework.boot.test.web.server.LocalServerPort
+import org.springframework.context.annotation.Bean
+import org.springframework.context.annotation.Import
 import roomescape.member.infrastructure.persistence.MemberRepository
+import roomescape.payment.business.PaymentWriter
+import roomescape.payment.infrastructure.persistence.PaymentRepository
+import roomescape.reservation.infrastructure.persistence.ReservationRepository
+import roomescape.schedule.infrastructure.persistence.ScheduleRepository
+import roomescape.theme.infrastructure.persistence.ThemeRepository
 import roomescape.util.CleanerMode.AFTER_EACH_TEST
 
 object KotestConfig : AbstractProjectConfig() {
     override fun extensions(): List<SpringTestExtension> = listOf(SpringExtension)
 }
 
+@Import(TestConfig::class)
 @SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT)
 abstract class FunSpecSpringbootTest : FunSpec({
     extension(DatabaseCleanerExtension(mode = AFTER_EACH_TEST))
@@ -25,23 +32,8 @@ abstract class FunSpecSpringbootTest : FunSpec({
     @Autowired
     private lateinit var memberRepository: MemberRepository
 
-    @LocalServerPort
-    var port: Int = 0
-
-    lateinit var loginUtil: LoginUtil
-
-    override suspend fun beforeSpec(spec: Spec) {
-        RestAssured.port = port
-        loginUtil = LoginUtil(memberRepository)
-    }
-}
-
-@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT)
-abstract class StringSpecSpringbootTest : StringSpec({
-    extension(DatabaseCleanerExtension(mode = AFTER_EACH_TEST))
-}) {
     @Autowired
-    private lateinit var memberRepository: MemberRepository
+    lateinit var dummyInitializer: DummyInitializer
 
     @LocalServerPort
     var port: Int = 0
@@ -54,20 +46,22 @@ abstract class StringSpecSpringbootTest : StringSpec({
     }
 }
 
-@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT)
-abstract class BehaviorSpecSpringbootTest : BehaviorSpec({
-    extension(DatabaseCleanerExtension(mode = AFTER_EACH_TEST))
-}) {
-    @Autowired
-    private lateinit var memberRepository: MemberRepository
-
-    @LocalServerPort
-    var port: Int = 0
-
-    lateinit var loginUtil: LoginUtil
-
-    override suspend fun beforeSpec(spec: Spec) {
-        RestAssured.port = port
-        loginUtil = LoginUtil(memberRepository)
+@TestConfiguration
+class TestConfig {
+    @Bean
+    fun dummyInitializer(
+        themeRepository: ThemeRepository,
+        scheduleRepository: ScheduleRepository,
+        reservationRepository: ReservationRepository,
+        paymentWriter: PaymentWriter,
+        paymentRepository: PaymentRepository
+    ): DummyInitializer {
+        return DummyInitializer(
+            themeRepository = themeRepository,
+            scheduleRepository = scheduleRepository,
+            reservationRepository = reservationRepository,
+            paymentWriter = paymentWriter,
+            paymentRepository = paymentRepository
+        )
     }
 }
diff --git a/src/test/kotlin/roomescape/util/RestAssuredUtils.kt b/src/test/kotlin/roomescape/util/RestAssuredUtils.kt
index 78c77e16..64b6e6e4 100644
--- a/src/test/kotlin/roomescape/util/RestAssuredUtils.kt
+++ b/src/test/kotlin/roomescape/util/RestAssuredUtils.kt
@@ -21,7 +21,7 @@ class LoginUtil(
         if (!memberRepository.existsByEmail(email)) {
             memberRepository.save(
                 MemberEntity(
-                    _id = TsidFactory.next(),
+                    _id = tsidFactory.next(),
                     email = email,
                     password = password,
                     name = email.split("@").first(),
@@ -43,12 +43,17 @@ class LoginUtil(
     }
 
     fun loginAsAdmin(): String {
-        return login(MemberFixtureV2.admin.email, MemberFixtureV2.admin.password, Role.ADMIN)
+        return login(MemberFixture.admin.email, MemberFixture.admin.password, Role.ADMIN)
     }
 
     fun loginAsUser(): String {
-        return login(MemberFixtureV2.user.email, MemberFixtureV2.user.password)
+        return login(MemberFixture.user.email, MemberFixture.user.password)
     }
+
+    fun getUser(): MemberEntity = memberRepository.findByEmailAndPassword(
+        MemberFixture.user.email,
+        MemberFixture.user.password
+    ) ?: throw AssertionError("Unexpected Exception Occurred.")
 }
 
 fun runTest(
diff --git a/src/test/kotlin/roomescape/util/RoomescapeApiTest.kt b/src/test/kotlin/roomescape/util/RoomescapeApiTest.kt
deleted file mode 100644
index aaa2af4c..00000000
--- a/src/test/kotlin/roomescape/util/RoomescapeApiTest.kt
+++ /dev/null
@@ -1,145 +0,0 @@
-package roomescape.util
-
-import com.fasterxml.jackson.databind.ObjectMapper
-import com.github.f4b6a3.tsid.TsidFactory
-import com.ninjasquad.springmockk.MockkBean
-import com.ninjasquad.springmockk.SpykBean
-import io.kotest.core.spec.style.BehaviorSpec
-import io.mockk.every
-import org.springframework.boot.test.context.TestConfiguration
-import org.springframework.context.annotation.Bean
-import org.springframework.context.annotation.Import
-import org.springframework.context.annotation.Primary
-import org.springframework.data.jpa.mapping.JpaMetamodelMappingContext
-import org.springframework.http.HttpHeaders
-import org.springframework.http.MediaType
-import org.springframework.test.web.servlet.*
-import roomescape.auth.exception.AuthErrorCode
-import roomescape.auth.exception.AuthException
-import roomescape.auth.infrastructure.jwt.JwtHandler
-import roomescape.auth.web.support.AuthInterceptor
-import roomescape.auth.web.support.MemberIdResolver
-import roomescape.common.config.JacksonConfig
-import roomescape.common.log.ApiLogMessageConverter
-import roomescape.member.exception.MemberErrorCode
-import roomescape.member.exception.MemberException
-import roomescape.member.implement.MemberFinder
-import roomescape.member.infrastructure.persistence.MemberEntity
-import roomescape.member.infrastructure.persistence.MemberRepository
-import roomescape.util.MemberFixture.NOT_LOGGED_IN_USERID
-
-@Import(TestConfig::class, JacksonConfig::class)
-@MockkBean(JpaMetamodelMappingContext::class)
-abstract class RoomescapeApiTest : BehaviorSpec() {
-
-    @SpykBean
-    private lateinit var authInterceptor: AuthInterceptor
-
-    @SpykBean
-    private lateinit var memberIdResolver: MemberIdResolver
-
-    @MockkBean
-    private lateinit var memberRepository: MemberRepository
-
-    @SpykBean
-    lateinit var apiLogMessageConverter: ApiLogMessageConverter
-
-    @SpykBean
-    lateinit var memberFinder: MemberFinder
-
-    @MockkBean
-    lateinit var jwtHandler: JwtHandler
-
-    val objectMapper: ObjectMapper = JacksonConfig().objectMapper()
-    val admin: MemberEntity = MemberFixture.admin()
-    val user: MemberEntity = MemberFixture.user()
-
-    fun runGetTest(
-        mockMvc: MockMvc,
-        endpoint: String,
-        log: Boolean = false,
-        assert: MockMvcResultMatchersDsl.() -> Unit
-    ): ResultActionsDsl = mockMvc.get(endpoint) {
-        header(HttpHeaders.AUTHORIZATION, "Bearer token")
-    }.apply {
-        log.takeIf { it }?.let { this.andDo { print() } }
-    }.andExpect(assert)
-
-    fun runPostTest(
-        mockMvc: MockMvc,
-        endpoint: String,
-        body: Any? = null,
-        log: Boolean = false,
-        assert: MockMvcResultMatchersDsl.() -> Unit
-    ): ResultActionsDsl = mockMvc.post(endpoint) {
-        this.header(HttpHeaders.AUTHORIZATION, "Bearer token")
-        body?.let {
-            this.contentType = MediaType.APPLICATION_JSON
-            this.content = objectMapper.writeValueAsString(it)
-        }
-    }.apply {
-        log.takeIf { it }?.let { this.andDo { print() } }
-    }.andExpect(assert)
-
-    fun runDeleteTest(
-        mockMvc: MockMvc,
-        endpoint: String,
-        log: Boolean = false,
-        assert: MockMvcResultMatchersDsl.() -> Unit
-    ): ResultActionsDsl = mockMvc.delete(endpoint) {
-        header(HttpHeaders.AUTHORIZATION, "Bearer token")
-    }.apply {
-        log.takeIf { it }?.let { this.andDo { print() } }
-    }.andExpect(assert)
-
-    fun loginAsAdmin() {
-        every {
-            jwtHandler.getMemberIdFromToken(any())
-        } returns admin.id!!
-
-        every { memberFinder.findById(admin.id!!) } returns admin
-    }
-
-    fun loginAsUser() {
-        every {
-            jwtHandler.getMemberIdFromToken(any())
-        } returns user.id!!
-
-        every { memberFinder.findById(user.id!!) } returns user
-    }
-
-    fun doNotLogin() {
-        every {
-            jwtHandler.getMemberIdFromToken(any())
-        } throws AuthException(AuthErrorCode.INVALID_TOKEN)
-
-        every {
-            memberFinder.findById(NOT_LOGGED_IN_USERID)
-        } throws MemberException(MemberErrorCode.MEMBER_NOT_FOUND)
-    }
-
-    fun <T> MvcResult.readValue(valueType: Class<T>): T = this.response.contentAsString
-        .takeIf { it.isNotBlank() }
-        ?.let { readValue(it, valueType) }
-        ?: throw RuntimeException(
-            """
-                [Test] Exception occurred while reading response json: ${this.response.contentAsString} with value type: $valueType
-            """.trimIndent()
-        )
-
-    fun <T> readValue(responseJson: String, valueType: Class<T>): T = objectMapper
-        .readTree(responseJson)["data"]
-        ?.let { objectMapper.convertValue(it, valueType) }
-        ?: throw RuntimeException(
-            """
-                [Test] Exception occurred while reading response json: $responseJson with value type: $valueType
-            """.trimIndent()
-        )
-}
-
-@TestConfiguration
-class TestConfig {
-    @Bean
-    @Primary
-    fun tsidFactory(): TsidFactory = TsidFactory
-}
\ No newline at end of file