From ac44b85f0b5a18ade404989a944c1f4528414528 Mon Sep 17 00:00:00 2001 From: chjpooh2002 Date: Mon, 16 Nov 2026 16:55:36 +0900 Subject: [PATCH 1/3] =?UTF-8?q?feat:=20=EC=8B=9C=EB=93=9C=EC=97=90=20?= =?UTF-8?q?=EC=82=AC=EC=9D=B4=ED=81=B4=201=20=EC=A0=95=EC=82=B0=20?= =?UTF-8?q?=EB=A6=AC=ED=8F=AC=ED=8A=B8=20=EC=83=9D=EC=84=B1=20=EB=B0=8F=20?= =?UTF-8?q?=EC=B2=AD=EA=B5=AC=20=EC=97=B0=EA=B2=B0=20=EC=B6=94=EA=B0=80=20?= =?UTF-8?q?(#41)?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - 수입 카드 과외 4개의 사이클 1에 회차 · 기록 · 진도를 깔고, 실제 정산 순서(정산 → 다음 사이클 → 리포트 → 청구)로 SettlementReportCreator를 불러 리포트를 만든다. - 사이클 2 선불 청구의 reportId에 사이클 1 리포트 ID를 연결한다. - 학생마다 이해도 분포를 다르게 둔 기록 노트를 추가하고, 기록 수가 정산 회차와 다르면 카드를 만들 수 없게 했다. --- .../com/sudam/global/seed/DemoIncomeCard.java | 86 +++++++-- .../com/sudam/global/seed/DemoLessonPlan.java | 17 ++ .../sudam/global/seed/DemoSeedService.java | 34 +++- .../sudam/global/seed/DemoIncomeCardTest.java | 69 ++++++- .../global/seed/DemoSeedServiceTest.java | 176 +++++++++++++++++- 5 files changed, 360 insertions(+), 22 deletions(-) diff --git a/src/main/java/com/sudam/global/seed/DemoIncomeCard.java b/src/main/java/com/sudam/global/seed/DemoIncomeCard.java index 7fdf2f2..05298d0 100644 --- a/src/main/java/com/sudam/global/seed/DemoIncomeCard.java +++ b/src/main/java/com/sudam/global/seed/DemoIncomeCard.java @@ -4,7 +4,10 @@ import com.sudam.domain.invoice.entity.InvoiceSnapshot; import com.sudam.domain.invoice.enums.InvoiceKind; import com.sudam.domain.participant.entity.Participant; +import com.sudam.domain.record.enums.HomeworkResult; +import com.sudam.domain.record.enums.Understanding; import com.sudam.domain.tutoring.entity.TutoringPolicy; +import com.sudam.global.seed.DemoLessonPlan.LessonNote; import java.time.DayOfWeek; import java.time.LocalDate; @@ -20,8 +23,10 @@ import static java.time.DayOfWeek.WEDNESDAY; /** - * 수입 화면(T-15) 카드 1장이 될 선불 과외. 회차 · 기록은 만들지 않고 사이클 2 청구 하나만 만든다. + * 수입 화면(T-15) 카드 1장이 될 선불 과외. 사이클 1을 정산하고 사이클 2를 청구한 상태로 만든다. * 네 장을 합치면 요약이 1,200,000 / 400,000 / 800,000이 되도록 금액 · 상태를 맞췄다. + * 사이클 1에 회차 · 기록 · 진도를 깔고 정산 리포트를 만들어 청구에 연결한다 (T-13 · T-14). + * 실제 정산은 사이클을 닫을 때 항상 리포트를 만들므로, 시드도 모든 카드에 리포트를 둔다. * * @param studentName 학생 이름 * @param gradeLevel 학년 (1~12 = 초1~고3) @@ -32,6 +37,7 @@ * @param lessonDays 수업 요일 * @param lessonStart 수업 시작 시각 (90분 수업) * @param textbookName 교재 1권 이름 + * @param notes 사이클 1 회차 기록 (정산 회차만큼, 오래된 순) */ record DemoIncomeCard( String studentName, @@ -42,37 +48,95 @@ record DemoIncomeCard( boolean unpaidReminderEnabled, List lessonDays, LocalTime lessonStart, - String textbookName + String textbookName, + List notes ) { static final int PARTIAL_PAID_AMOUNT = 120_000; + // 회차를 다 채워 정산했다고 두므로 (인정 회차 = 정산 회차) 기록 수가 정산 회차와 같아야 한다. + DemoIncomeCard { + if (notes.size() != settlementSessionCount) { + throw new IllegalArgumentException( + "기록 수가 정산 회차와 다릅니다. student=" + studentName + ", notes=" + notes.size()); + } + } + + // 학생마다 이해도 분포를 다르게 둔다 (T-14에서 박지후 상 · 윤서아 중 · 이도윤 하로 보이도록). + private static final List JIHU_NOTES = List.of( + new LessonNote(Understanding.HIGH, null, "Unit 1~2 구문 복습", "주어 · 동사 찾기를 빠르게 함"), + new LessonNote(Understanding.HIGH, HomeworkResult.DONE, "Unit 3~4 예문 해석", "to부정사 용법 구분이 정확함"), + new LessonNote(Understanding.MEDIUM, HomeworkResult.DONE, "Unit 5~6 오답 정리", "분사구문에서 의미상 주어를 헷갈려함"), + new LessonNote(Understanding.HIGH, HomeworkResult.DONE, "Unit 7~8 예습", "지난 시간 오답을 스스로 고쳐 옴"), + new LessonNote(Understanding.HIGH, HomeworkResult.PARTIAL, "Unit 9~10 문장 쓰기", "관계대명사 문장 만들기를 잘함"), + new LessonNote(Understanding.HIGH, HomeworkResult.DONE, "Unit 11~12 해석 연습", "긴 문장도 끊어 읽기가 안정적임"), + new LessonNote(Understanding.MEDIUM, HomeworkResult.DONE, "Unit 13~14 복습", "가정법 시제 바꾸기에서 실수가 있음"), + new LessonNote(Understanding.HIGH, HomeworkResult.DONE, "Unit 15~16 예습", "가정법 실수가 줄고 설명을 바로 이해함") + ); + private static final List SEOA_NOTES = List.of( + new LessonNote(Understanding.MEDIUM, null, "Unit 1~2 단어 정리", "지문은 이해하지만 단어를 자주 물어봄"), + new LessonNote(Understanding.MEDIUM, HomeworkResult.DONE, "Unit 3~4 요약 쓰기", "주제문 찾기는 맞히고 세부 내용에서 틀림"), + new LessonNote(Understanding.HIGH, HomeworkResult.DONE, "Unit 5~6 지문 복습", "관심 있는 과학 지문이라 집중이 좋았음"), + new LessonNote(Understanding.MEDIUM, HomeworkResult.PARTIAL, "Unit 7~8 단어 암기", "단어 시험 18/25"), + new LessonNote(Understanding.LOW, HomeworkResult.NOT_DONE, "Unit 9~10 다시 읽기", "숙제를 못 해 와서 지문 이해가 늦었음"), + new LessonNote(Understanding.MEDIUM, HomeworkResult.DONE, "Unit 11~12 요약 쓰기", "요약 문장이 짧아졌지만 핵심은 잡음"), + new LessonNote(Understanding.MEDIUM, HomeworkResult.PARTIAL, "Unit 13~14 오답 정리", "추론 문제 근거 찾기를 연습 중"), + new LessonNote(Understanding.HIGH, HomeworkResult.DONE, "Unit 15~16 예습", "단어 시험 23/25로 올라감") + ); + private static final List DOYUN_NOTES = List.of( + new LessonNote(Understanding.LOW, null, "Unit 1~2 개념 다시 보기", "시제 개념이 많이 비어 있어 기초부터 다시 설명"), + new LessonNote(Understanding.LOW, HomeworkResult.PARTIAL, "Unit 3~4 문제 풀기", "완료시제와 과거시제를 계속 헷갈려함"), + new LessonNote(Understanding.MEDIUM, HomeworkResult.DONE, "Unit 5~6 오답 정리", "조동사는 비교적 잘 따라옴"), + new LessonNote(Understanding.LOW, HomeworkResult.NOT_DONE, "Unit 7~8 다시 풀기", "학원 시험 기간이라 숙제를 못 함. 수동태 다시 설명") + ); + private static final List HARIN_NOTES = List.of( + new LessonNote(Understanding.MEDIUM, null, "Unit 1~2 단어 암기", "첫 수업. 발음은 좋고 철자를 자주 틀림"), + new LessonNote(Understanding.HIGH, HomeworkResult.DONE, "Unit 3~4 단어 암기", "단어 시험 27/30"), + new LessonNote(Understanding.HIGH, HomeworkResult.DONE, "Unit 5~6 예문 만들기", "새 단어로 문장을 스스로 만듦"), + new LessonNote(Understanding.MEDIUM, HomeworkResult.PARTIAL, "Unit 7~8 단어 암기", "비슷한 뜻 단어를 헷갈려함"), + new LessonNote(Understanding.HIGH, HomeworkResult.DONE, "Unit 9~10 누적 복습", "단어 시험 29/30"), + new LessonNote(Understanding.MEDIUM, HomeworkResult.DONE, "Unit 11~12 예문 만들기", "접두사 뜻 정리를 어려워함"), + new LessonNote(Understanding.HIGH, HomeworkResult.DONE, "Unit 13~14 단어 암기", "접두사로 처음 보는 단어 뜻을 추측함"), + new LessonNote(Understanding.HIGH, HomeworkResult.DONE, "Unit 15~16 누적 복습", "누적 시험 56/60") + ); + // 카드 표시 순서(확인 대기 → 입금 대기 → 일부 입금 → 입금 완료)와 같은 순서로 둔다. 시간은 김서아(18:00~19:30)와 겹치지 않게 골랐다. static final List ALL = List.of( new DemoIncomeCard("박지후", 8, 8, 360_000, PaymentState.CONFIRM_REQUESTED, false, - List.of(TUESDAY, THURSDAY), LocalTime.of(16, 0), "천일문 기본"), + List.of(TUESDAY, THURSDAY), LocalTime.of(16, 0), "천일문 기본", JIHU_NOTES), new DemoIncomeCard("윤서아", 9, 8, 360_000, PaymentState.PENDING, true, - List.of(MONDAY, WEDNESDAY), LocalTime.of(16, 0), "리딩튜터 중급"), + List.of(MONDAY, WEDNESDAY), LocalTime.of(16, 0), "리딩튜터 중급", SEOA_NOTES), new DemoIncomeCard("이도윤", 11, 4, 200_000, PaymentState.PARTIAL, false, - List.of(SATURDAY), LocalTime.of(10, 0), "Grammar Zone 기본"), + List.of(SATURDAY), LocalTime.of(10, 0), "Grammar Zone 기본", DOYUN_NOTES), new DemoIncomeCard("김하린", 7, 8, 280_000, PaymentState.PAID, false, - List.of(TUESDAY, FRIDAY), LocalTime.of(20, 0), "능률 VOCA 중학") + List.of(TUESDAY, FRIDAY), LocalTime.of(20, 0), "능률 VOCA 중학", HARIN_NOTES) ); + /*** + * 함수 기능: 사이클 1 회차 날짜를 고른다. 사이클 시작일부터 수업 요일을 앞으로 세어 기록 수만큼. + * 사이클 1은 4주(28일)이므로 주 2회 8개 · 주 1회 4개가 정산일 전에 모두 들어간다. + * @param cycleStartDate 사이클 1 시작일 + * @return 오래된 순 회차 날짜 (기록 수만큼) + */ + List firstCycleLessonDates(LocalDate cycleStartDate) { + return DemoLessonPlan.lessonDatesFrom(cycleStartDate, lessonDays, notes.size()); + } + /*** * 함수 기능: 사이클 2를 청구하는 선불 '다음 N회차' 청구를 만들고 카드에 맞는 상태로 바꾼다. - * 정산 서비스의 선불 청구와 같은 모양으로 만든다: 리포트 없음(시드는 리포트를 만들지 않음), - * 스냅샷의 인정 회차 · 시작일은 방금 정산한 사이클 1 기준 (회차를 다 채워 정산했으므로 인정 회차 = 정산 회차), 휴강 없음. + * 정산 서비스의 선불 청구와 같은 모양으로 만든다: 방금 정산한 사이클 1의 리포트를 연결하고, + * 스냅샷의 인정 회차 · 시작일은 사이클 1 기준 (회차를 다 채워 정산했으므로 인정 회차 = 정산 회차), 휴강 없음. * @param policy 이 과외의 정책 (사이클 1부터 적용 = 사이클 2에도 적용) * @param billedCycleId 청구 대상 사이클(사이클 2) ID + * @param reportId 사이클 1 정산 리포트 ID * @param settledCycleStart 정산한 사이클 1의 시작일 * @param parent 확인 요청을 누른 학부모 (CONFIRM_REQUESTED일 때만 쓴다) * @param now 실행 시각 * @return 저장 전 Invoice */ - Invoice issueInvoice(TutoringPolicy policy, Long billedCycleId, LocalDate settledCycleStart, Participant parent, - LocalDateTime now) { - Invoice invoice = Invoice.issue(policy, billedCycleId, null, InvoiceKind.NEXT, policy.getTuitionFee(), + Invoice issueInvoice(TutoringPolicy policy, Long billedCycleId, Long reportId, LocalDate settledCycleStart, + Participant parent, LocalDateTime now) { + Invoice invoice = Invoice.issue(policy, billedCycleId, reportId, InvoiceKind.NEXT, policy.getTuitionFee(), InvoiceSnapshot.of(policy, settlementSessionCount, settledCycleStart, List.of())); switch (paymentState) { case CONFIRM_REQUESTED -> invoice.requestConfirm(parent, now.minusHours(2)); diff --git a/src/main/java/com/sudam/global/seed/DemoLessonPlan.java b/src/main/java/com/sudam/global/seed/DemoLessonPlan.java index 5b9d794..2d80ccf 100644 --- a/src/main/java/com/sudam/global/seed/DemoLessonPlan.java +++ b/src/main/java/com/sudam/global/seed/DemoLessonPlan.java @@ -83,6 +83,23 @@ static List pastLessonDates(LocalDate today, Collection da return List.copyOf(dates); } + /*** + * 함수 기능: 시작일(포함)부터 앞으로 가며 수업일을 count개 고른다. + * @param from 시작일 (수업 요일이면 포함) + * @param days 수업 요일 + * @param count 고를 개수 + * @return 오래된 날짜부터 정렬한 수업일 + */ + static List lessonDatesFrom(LocalDate from, Collection days, int count) { + List dates = new ArrayList<>(); + for (LocalDate date = from; dates.size() < count; date = date.plusDays(1)) { + if (days.contains(date.getDayOfWeek())) { + dates.add(date); + } + } + return List.copyOf(dates); + } + /*** * 함수 기능: 학년도를 구한다. 한국 학년도는 3월에 시작하므로 1 · 2월은 전년도다. * @param today 실행일 diff --git a/src/main/java/com/sudam/global/seed/DemoSeedService.java b/src/main/java/com/sudam/global/seed/DemoSeedService.java index 4e0dd89..d0744a1 100644 --- a/src/main/java/com/sudam/global/seed/DemoSeedService.java +++ b/src/main/java/com/sudam/global/seed/DemoSeedService.java @@ -12,6 +12,7 @@ import com.sudam.domain.record.repository.SessionRecordRepository; import com.sudam.domain.session.entity.Session; import com.sudam.domain.session.repository.SessionRepository; +import com.sudam.domain.settlement.port.SettlementReportCreator; import com.sudam.domain.tutoring.entity.Textbook; import com.sudam.domain.tutoring.entity.Tutoring; import com.sudam.domain.tutoring.entity.TutoringPolicy; @@ -60,6 +61,7 @@ /** * 시연용 가상 데이터를 만든다. 정산 서비스를 거치지 않고 엔티티를 직접 만들어 저장한다. + * 정산 리포트만은 실제 리포트 생성기(SettlementReportCreator)로 만들어 통계 계산을 정산과 맞춘다. * sudam.seed.enabled = true일 때만 빈이 생긴다 (실행기와 같은 조건). */ @Service @@ -94,6 +96,7 @@ public class DemoSeedService { private final SessionRepository sessionRepository; private final SessionRecordRepository sessionRecordRepository; private final SessionProgressRepository sessionProgressRepository; + private final SettlementReportCreator settlementReportCreator; private final Clock clock; private final SecureRandom secureRandom = new SecureRandom(); @@ -150,20 +153,28 @@ private void agreeCurrentRequiredTerms(User user, LocalDateTime now) { .toList()); } - // 수입 화면 카드 1장: 사이클 1 SETTLED · 사이클 2 IN_PROGRESS, 사이클 2를 청구하는 선불 청구. 회차 · 기록은 만들지 않는다. + /*** + * 함수 기능: 수입 화면 카드 1장을 만든다. 사이클 1 SETTLED · 사이클 2 IN_PROGRESS, 사이클 2를 청구하는 선불 청구. + * 사이클 1에 회차 · 기록 · 진도를 깔고, 실제 정산과 같은 순서 + * (사이클 1 정산 → 사이클 2 열기 → 리포트 생성 → 청구 발행)로 리포트를 만들어 청구에 연결한다. + * 리포트를 직접 만들지 않고 생성기를 쓰는 이유는 통계 · 진도 표가 실제 정산과 같은 계산으로 나오게 하기 위해서다. + */ private void createIncomeTutoring(TeacherProfile teacher, DemoIncomeCard card, int seq, LocalDateTime now) { LocalDate cycleStartDate = now.toLocalDate().minusWeeks(INCOME_CYCLE_START_WEEKS_AGO); DemoTutoring base = createBase(teacher, card.studentName(), card.gradeLevel(), card.lessonDays(), card.lessonStart(), cycleStartDate, card.textbookName(), card.settlementSessionCount(), card.tuitionFee(), card.unpaidReminderEnabled(), seq, now); + Cycle first = cycleRepository.save(Cycle.open(base.tutoring(), 1, cycleStartDate.atStartOfDay())); + createRecordedSessions(base, first, card.firstCycleLessonDates(cycleStartDate), card.notes()); + LocalDateTime settledAt = now.minusDays(INCOME_CYCLE_SETTLED_DAYS_AGO); - Cycle first = Cycle.open(base.tutoring(), 1, cycleStartDate.atStartOfDay()); first.settle(settledAt); - cycleRepository.save(first); Cycle second = cycleRepository.save(Cycle.open(base.tutoring(), 2, settledAt)); - invoiceRepository.save(card.issueInvoice(base.policy(), second.getId(), cycleStartDate, base.parent(), now)); + Long reportId = settlementReportCreator.create(base.tutoring().getId(), first.getId()); + invoiceRepository.save(card.issueInvoice(base.policy(), second.getId(), reportId, cycleStartDate, + base.parent(), now)); } // 김서아: 사이클 1 IN_PROGRESS에 오늘 전 7회 기록. 오늘 회차 · 청구는 만들지 않는다 (오늘 기록하면 8/8로 정산). @@ -177,18 +188,23 @@ private DemoTutoring createDemoTutoring(TeacherProfile teacher, int seq, LocalDa DemoLessonPlan.LESSON_START, firstDate, DemoLessonPlan.TEXTBOOK_NAME, DemoLessonPlan.SETTLEMENT_SESSION_COUNT, DemoLessonPlan.TUITION_FEE, false, seq, now); Cycle cycle = cycleRepository.save(Cycle.open(demo.tutoring(), 1, firstDate.atStartOfDay())); + createRecordedSessions(demo, cycle, dates, DemoLessonPlan.NOTES); + return demo; + } + // 날짜마다 완료한 정규 회차 + 기록 + 진도(회차마다 2단원씩)를 만든다. dates와 notes는 같은 길이 · 같은 순서다. + private void createRecordedSessions(DemoTutoring tutoring, Cycle cycle, List dates, + List notes) { for (int i = 0; i < dates.size(); i++) { LocalDate date = dates.get(i); - DemoLessonPlan.LessonNote note = DemoLessonPlan.NOTES.get(i); - Session session = sessionRepository.save(Session.completeRegular(demo.tutoring(), cycle, - demo.schedules().get(date.getDayOfWeek()), date)); + DemoLessonPlan.LessonNote note = notes.get(i); + Session session = sessionRepository.save(Session.completeRegular(tutoring.tutoring(), cycle, + tutoring.schedules().get(date.getDayOfWeek()), date)); sessionRecordRepository.save(SessionRecord.create(session, note.understanding(), note.previousHomeworkResult(), note.nextHomework(), note.observationMemo())); - sessionProgressRepository.save(SessionProgress.create(session, demo.textbook(), + sessionProgressRepository.save(SessionProgress.create(session, tutoring.textbook(), DemoLessonPlan.progressStart(i), DemoLessonPlan.progressEnd(i))); } - return demo; } // 과외마다 공통: 과외 · 수업 일정 · 교재 1권 · 정책 · 공유 설정 · 학부모(링크 토큰 발급). diff --git a/src/test/java/com/sudam/global/seed/DemoIncomeCardTest.java b/src/test/java/com/sudam/global/seed/DemoIncomeCardTest.java index 9f6f833..b3c08de 100644 --- a/src/test/java/com/sudam/global/seed/DemoIncomeCardTest.java +++ b/src/test/java/com/sudam/global/seed/DemoIncomeCardTest.java @@ -14,16 +14,22 @@ import com.sudam.domain.user.entity.User; import com.sudam.domain.user.enums.Provider; import com.sudam.domain.user.enums.Subject; +import com.sudam.global.seed.DemoLessonPlan.LessonNote; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.DisplayName; import org.junit.jupiter.api.Test; +import java.time.DayOfWeek; import java.time.LocalDate; import java.time.LocalDateTime; +import java.time.LocalTime; import java.util.ArrayList; import java.util.List; +import java.util.Map; +import java.util.stream.Collectors; import static org.assertj.core.api.Assertions.assertThat; +import static org.assertj.core.api.Assertions.assertThatThrownBy; class DemoIncomeCardTest { @@ -50,7 +56,7 @@ void setUp() { .bankCode("004").bankName("국민은행").accountNumber("000000-00-000001") .accountHolder("한서윤").build(); Participant parent = Participant.createParent(tutoring, ParticipantLabel.MOTHER, "01000000001"); - Invoice invoice = card.issueInvoice(policy, 2L, CYCLE1_START, parent, NOW); + Invoice invoice = card.issueInvoice(policy, 2L, null, CYCLE1_START, parent, NOW); invoices.add(invoice); return InvoiceItemResponse.of(invoice, 0, card.unpaidReminderEnabled()); }) @@ -74,6 +80,67 @@ void setUp() { }); } + @Test + @DisplayName("카드마다 기록 수는 정산 회차와 같고, 첫 기록의 지난 숙제만 비어 있다") + void 카드의_기록_구성() { + // given: DemoIncomeCard.ALL + + // when & then + assertThat(DemoIncomeCard.ALL).allSatisfy(card -> { + assertThat(card.notes()).hasSize(card.settlementSessionCount()); + assertThat(card.notes().getFirst().previousHomeworkResult()).isNull(); + assertThat(card.notes().subList(1, card.notes().size())).allSatisfy(note -> assertThat(note.previousHomeworkResult()).isNotNull()); + }); + } + + @Test + @DisplayName("이해도 가중평균(상3 · 중2 · 하1)이 박지후 2.5 이상, 윤서아 1.5 이상 2.5 미만, 이도윤 1.5 미만이다") + void 학생별_이해도_분포() { + // given + Map averages = DemoIncomeCard.ALL.stream() + .collect(Collectors.toMap(DemoIncomeCard::studentName, card -> card.notes().stream() + .mapToInt(note -> switch (note.understanding()) { + case HIGH -> 3; + case MEDIUM -> 2; + case LOW -> 1; + }) + .average().orElseThrow())); + + // when & then + assertThat(averages.get("박지후")).isGreaterThanOrEqualTo(2.5); + assertThat(averages.get("윤서아")).isGreaterThanOrEqualTo(1.5).isLessThan(2.5); + assertThat(averages.get("이도윤")).isLessThan(1.5); + } + + @Test + @DisplayName("기록 수가 정산 회차와 다른 카드는 만들 수 없다") + void 기록_수가_정산_회차와_다르면_예외() { + // given + List threeNotes = DemoIncomeCard.ALL.get(2).notes().subList(0, 3); + + // when & then + assertThatThrownBy(() -> new DemoIncomeCard("테스트", 7, 4, 200_000, DemoIncomeCard.PaymentState.PENDING, + false, List.of(DayOfWeek.MONDAY), LocalTime.of(16, 0), "교재", threeNotes)) + .isInstanceOf(IllegalArgumentException.class); + } + + @Test + @DisplayName("사이클 1 회차 날짜는 시작일부터 수업 요일로 세어 4주(정산일 전) 안에 모두 들어간다") + void 사이클_1_회차_날짜() { + // given + LocalDate settledDate = CYCLE1_START.plusWeeks(4); + + // when & then + for (DemoIncomeCard card : DemoIncomeCard.ALL) { + List dates = card.firstCycleLessonDates(CYCLE1_START); + assertThat(dates).hasSize(card.notes().size()).isSorted().doesNotHaveDuplicates(); + assertThat(dates).allSatisfy(date -> { + assertThat(date).isAfterOrEqualTo(CYCLE1_START).isBefore(settledDate); + assertThat(card.lessonDays()).contains(date.getDayOfWeek()); + }); + } + } + @Test @DisplayName("수입 화면 카드 4장의 요약은 1,200,000 / 400,000 / 800,000이다") void 요약_금액() { diff --git a/src/test/java/com/sudam/global/seed/DemoSeedServiceTest.java b/src/test/java/com/sudam/global/seed/DemoSeedServiceTest.java index ab0e3d6..55298ca 100644 --- a/src/test/java/com/sudam/global/seed/DemoSeedServiceTest.java +++ b/src/test/java/com/sudam/global/seed/DemoSeedServiceTest.java @@ -1,11 +1,16 @@ package com.sudam.global.seed; +import com.sudam.domain.cycle.entity.Cycle; +import com.sudam.domain.cycle.enums.CycleStatus; import com.sudam.domain.cycle.repository.CycleRepository; +import com.sudam.domain.invoice.entity.Invoice; import com.sudam.domain.invoice.repository.InvoiceRepository; import com.sudam.domain.participant.repository.ParticipantRepository; import com.sudam.domain.record.repository.SessionProgressRepository; import com.sudam.domain.record.repository.SessionRecordRepository; +import com.sudam.domain.session.entity.Session; import com.sudam.domain.session.repository.SessionRepository; +import com.sudam.domain.settlement.port.SettlementReportCreator; import com.sudam.domain.tutoring.repository.TextbookRepository; import com.sudam.domain.tutoring.repository.TutoringPolicyRepository; import com.sudam.domain.tutoring.repository.TutoringRepository; @@ -20,16 +25,31 @@ import org.junit.jupiter.api.DisplayName; import org.junit.jupiter.api.Test; import org.junit.jupiter.api.extension.ExtendWith; +import org.mockito.ArgumentCaptor; import org.mockito.InjectMocks; import org.mockito.Mock; import org.mockito.junit.jupiter.MockitoExtension; +import org.springframework.data.repository.CrudRepository; import org.springframework.test.util.ReflectionTestUtils; +import org.springframework.util.ReflectionUtils; import java.time.Clock; +import java.time.LocalDate; +import java.time.LocalDateTime; +import java.time.ZoneId; +import java.util.ArrayList; +import java.util.HashMap; +import java.util.List; +import java.util.Map; import java.util.Optional; +import java.util.concurrent.atomic.AtomicLong; +import java.util.stream.Collectors; import static org.assertj.core.api.Assertions.assertThat; +import static org.mockito.ArgumentMatchers.any; +import static org.mockito.ArgumentMatchers.anyLong; import static org.mockito.BDDMockito.given; +import static org.mockito.Mockito.times; import static org.mockito.Mockito.verify; import static org.mockito.Mockito.verifyNoInteractions; import static org.mockito.Mockito.verifyNoMoreInteractions; @@ -37,6 +57,14 @@ @ExtendWith(MockitoExtension.class) class DemoSeedServiceTest { + // 2026-11-16(월) 10:00 실행 → 수입 카드 사이클 1은 10/12 시작, 11/09 10:00 정산. + private static final ZoneId ZONE = ZoneId.of("Asia/Seoul"); + private static final LocalDateTime NOW = LocalDateTime.of(2026, 11, 16, 10, 0); + private static final LocalDate INCOME_CYCLE_START = LocalDate.of(2026, 10, 12); + private static final LocalDate INCOME_SETTLED_DATE = LocalDate.of(2026, 11, 9); + private static final long REPORT_ID_OFFSET = 1_000L; + private static final List STUDENTS = DemoIncomeCard.ALL.stream().map(DemoIncomeCard::studentName).toList(); + @Mock private UserRepository userRepository; @Mock private TeacherProfileRepository teacherProfileRepository; @Mock private TermsRepository termsRepository; @@ -52,6 +80,7 @@ class DemoSeedServiceTest { @Mock private SessionRepository sessionRepository; @Mock private SessionRecordRepository sessionRecordRepository; @Mock private SessionProgressRepository sessionProgressRepository; + @Mock private SettlementReportCreator settlementReportCreator; @Mock private Clock clock; @InjectMocks @@ -79,6 +108,151 @@ class DemoSeedServiceTest { verifyNoInteractions(teacherProfileRepository, termsRepository, userTermsAgreementRepository, tutoringScheduleRepository, textbookRepository, tutoringPolicyRepository, tutoringSettingRepository, participantRepository, cycleRepository, invoiceRepository, sessionRepository, - sessionRecordRepository, sessionProgressRepository); + sessionRecordRepository, sessionProgressRepository, settlementReportCreator); + } + + @Test + @DisplayName("수입 카드 4명 모두 정산한 사이클 1로 리포트 생성기를 부른다 (실제 정산은 사이클을 닫을 때 항상 리포트를 만든다)") + void 리포트_생성기는_카드마다_사이클_1로_호출() { + // given + SeedCapture capture = seedAll(); + + // when + Map firstCycles = capture.firstCycles(); + + // then + assertThat(firstCycles).containsOnlyKeys(STUDENTS.toArray(String[]::new)); + verify(settlementReportCreator, times(STUDENTS.size())).create(anyLong(), anyLong()); + for (Cycle first : firstCycles.values()) { + verify(settlementReportCreator).create(first.getTutoring().getId(), first.getId()); + } + } + + @Test + @DisplayName("리포트 생성기는 사이클 1이 SETTLED로 바뀐 뒤에 불린다 (실제 정산과 같은 순서)") + void 리포트는_정산_뒤에_생성() { + // given + SeedCapture capture = seedAll(); + + // when + Map statuses = capture.statusAtReportCreation(); + + // then + assertThat(statuses).hasSize(STUDENTS.size()); + assertThat(statuses.values()).containsOnly(CycleStatus.SETTLED); + } + + @Test + @DisplayName("사이클 2 청구의 reportId는 생성기가 그 과외의 사이클 1로 돌려준 ID다") + void 청구에_리포트_ID_연결() { + // given + SeedCapture capture = seedAll(); + + // when + Map invoices = capture.invoices().stream() + .collect(Collectors.toMap(invoice -> invoice.getTutoring().getStudentName(), invoice -> invoice)); + Map firstCycles = capture.firstCycles(); + + // then + assertThat(invoices).containsOnlyKeys(STUDENTS.toArray(String[]::new)); + for (String student : STUDENTS) { + assertThat(invoices.get(student).getReportId()) + .isEqualTo(firstCycles.get(student).getId() + REPORT_ID_OFFSET); + } + } + + @Test + @DisplayName("수입 카드의 사이클 1 회차 수는 정산 회차와 같고, 날짜는 사이클 시작일 ~ 정산 전날의 수업 요일이다") + void 사이클_1_회차_수는_정산_회차() { + // given + SeedCapture capture = seedAll(); + + // when + Map> firstCycleSessions = capture.sessions().stream() + .filter(session -> session.getCycle().getCycleNo() == 1) + .filter(session -> !session.getTutoring().getStudentName().equals(DemoLessonPlan.STUDENT_NAME)) + .collect(Collectors.groupingBy(session -> session.getTutoring().getStudentName())); + + // then + assertThat(firstCycleSessions).containsOnlyKeys(STUDENTS.toArray(String[]::new)); + for (DemoIncomeCard card : DemoIncomeCard.ALL) { + List sessions = firstCycleSessions.get(card.studentName()); + assertThat(sessions).hasSize(card.settlementSessionCount()); + assertThat(sessions).allSatisfy(session -> { + assertThat(session.getOriginalDate()).isBetween(INCOME_CYCLE_START, INCOME_SETTLED_DATE.minusDays(1)); + assertThat(card.lessonDays()).contains(session.getOriginalDate().getDayOfWeek()); + }); + } + } + + /*** + * 함수 기능: 저장소 목이 저장할 때 ID를 붙여 돌려주게 하고 전체 시드를 실행한 뒤, 저장된 사이클 · 회차 · 청구를 모은다. + * 리포트 생성기 목은 "사이클 ID + 1000"을 리포트 ID로 돌려주고, 불린 시점의 사이클 상태를 기록한다. + * @return 저장된 엔티티 모음 + */ + private SeedCapture seedAll() { + User teacher = User.createTeacher(Provider.KAKAO, "seed-teacher-1", "seed-teacher@sudam.test"); + ReflectionTestUtils.setField(teacher, "id", 1L); + given(userRepository.findByProviderAndProviderId(Provider.KAKAO, "seed-teacher-1")) + .willReturn(Optional.of(teacher)); + given(clock.instant()).willReturn(NOW.atZone(ZONE).toInstant()); + given(clock.getZone()).willReturn(ZONE); + + AtomicLong ids = new AtomicLong(100); + List cycles = new ArrayList<>(); + List sessions = new ArrayList<>(); + assignIdOnSave(teacherProfileRepository, ids, null); + assignIdOnSave(tutoringRepository, ids, null); + assignIdOnSave(tutoringScheduleRepository, ids, null); + assignIdOnSave(textbookRepository, ids, null); + assignIdOnSave(tutoringPolicyRepository, ids, null); + assignIdOnSave(tutoringSettingRepository, ids, null); + assignIdOnSave(participantRepository, ids, null); + assignIdOnSave(cycleRepository, ids, cycles); + assignIdOnSave(sessionRepository, ids, sessions); + assignIdOnSave(sessionRecordRepository, ids, null); + assignIdOnSave(sessionProgressRepository, ids, null); + assignIdOnSave(invoiceRepository, ids, null); + + Map statusAtReportCreation = new HashMap<>(); + given(settlementReportCreator.create(anyLong(), anyLong())).willAnswer(invocation -> { + Long cycleId = invocation.getArgument(1); + cycles.stream().filter(cycle -> cycle.getId().equals(cycleId)).findFirst() + .ifPresent(cycle -> statusAtReportCreation.put(cycleId, cycle.getStatus())); + return cycleId + REPORT_ID_OFFSET; + }); + + DemoSeedResult result = demoSeedService.seed("seed-teacher-1"); + assertThat(result.created()).isTrue(); + + ArgumentCaptor invoiceCaptor = ArgumentCaptor.forClass(Invoice.class); + verify(invoiceRepository, times(DemoIncomeCard.ALL.size())).save(invoiceCaptor.capture()); + return new SeedCapture(cycles, sessions, invoiceCaptor.getAllValues(), statusAtReportCreation); + } + + // 저장할 때 IDENTITY처럼 ID를 붙인다. ID 필드가 따로 없는 엔티티(@MapsId)는 그대로 둔다. + private static void assignIdOnSave(CrudRepository repository, AtomicLong ids, List saved) { + given(repository.save(any())).willAnswer(invocation -> { + T entity = invocation.getArgument(0); + if (ReflectionUtils.findField(entity.getClass(), "id") != null) { + ReflectionTestUtils.setField(entity, "id", ids.incrementAndGet()); + } + if (saved != null) { + saved.add(entity); + } + return entity; + }); + } + + private record SeedCapture(List cycles, List sessions, List invoices, + Map statusAtReportCreation) { + + // 수입 카드 과외의 사이클 1 (학생 이름 → 사이클). 김서아는 뺀다. + Map firstCycles() { + return cycles.stream() + .filter(cycle -> cycle.getCycleNo() == 1) + .filter(cycle -> !cycle.getTutoring().getStudentName().equals(DemoLessonPlan.STUDENT_NAME)) + .collect(Collectors.toMap(cycle -> cycle.getTutoring().getStudentName(), cycle -> cycle)); + } } } From 8d8ca22d442a7bb56c3f5290785aaadc03f6a2cf Mon Sep 17 00:00:00 2001 From: chjpooh2002 Date: Mon, 16 Nov 2026 17:50:31 +0900 Subject: [PATCH 2/3] =?UTF-8?q?feat:=20=EC=8B=9C=EB=93=9C=20=EB=A6=AC?= =?UTF-8?q?=EC=85=8B=20=ED=94=8C=EB=9E=98=EA=B7=B8=20=EC=B6=94=EA=B0=80=20?= =?UTF-8?q?(#41)?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - sudam.seed.reset(SUDAM_SEED_RESET)과 sudam.seed.enabled가 모두 true면 재기동 때 시드 선생님의 과외와 그 아래 데이터를 지우고 다시 만든다. - DemoSeedResetter가 JPQL 일괄 삭제를 FK 역순으로 실행한다. 참여자의 같은 테이블 참조(guardian_consent_by)는 지우기 전에 비운다. - 삭제는 seed() 트랜잭션에 MANDATORY로 참여해, 다시 만들다 실패하면 삭제도 롤백된다. User · TeacherProfile · 약관 동의는 남긴다. - 리셋 모드로 부팅하면 끄라는 경고를 로그로 크게 남긴다. --- .env.example | 2 + .../sudam/global/seed/DemoSeedResetter.java | 76 +++++++++++++++++ .../com/sudam/global/seed/DemoSeedRunner.java | 17 +++- .../sudam/global/seed/DemoSeedService.java | 8 +- src/main/resources/application.yaml | 1 + .../global/seed/DemoSeedResetterTest.java | 84 +++++++++++++++++++ .../seed/DemoSeedRunnerConditionTest.java | 10 +++ .../sudam/global/seed/DemoSeedRunnerTest.java | 36 ++++++++ .../global/seed/DemoSeedServiceTest.java | 29 ++++++- 9 files changed, 257 insertions(+), 6 deletions(-) create mode 100644 src/main/java/com/sudam/global/seed/DemoSeedResetter.java create mode 100644 src/test/java/com/sudam/global/seed/DemoSeedResetterTest.java create mode 100644 src/test/java/com/sudam/global/seed/DemoSeedRunnerTest.java diff --git a/.env.example b/.env.example index 716aa56..19f7bab 100644 --- a/.env.example +++ b/.env.example @@ -15,3 +15,5 @@ FRONT_BASE_URL= SUDAM_SEED_ENABLED= # 시드 선생님 카카오 회원번호. 비우면 가짜 계정 seed-teacher-1 SUDAM_SEED_TEACHER_KAKAO_ID= +# true면 재기동 때 시드 선생님의 과외를 지우고 처음 상태로 다시 만든다 (SUDAM_SEED_ENABLED도 true여야 함). 리셋 후 다시 비운다 +SUDAM_SEED_RESET= diff --git a/src/main/java/com/sudam/global/seed/DemoSeedResetter.java b/src/main/java/com/sudam/global/seed/DemoSeedResetter.java new file mode 100644 index 0000000..12afaf7 --- /dev/null +++ b/src/main/java/com/sudam/global/seed/DemoSeedResetter.java @@ -0,0 +1,76 @@ +package com.sudam.global.seed; + +import jakarta.persistence.EntityManager; +import lombok.RequiredArgsConstructor; +import lombok.extern.slf4j.Slf4j; +import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty; +import org.springframework.stereotype.Component; +import org.springframework.transaction.annotation.Propagation; +import org.springframework.transaction.annotation.Transactional; + +import java.util.List; + +/** + * 시드 선생님의 과외와 그 아래 데이터를 지운다 (sudam.seed.reset = true로 재기동할 때, UT 리허설 뒤 처음 상태로 되돌리기). + * 도메인 레포지토리에 시드 전용 삭제 메서드를 늘리지 않으려고 JPQL 일괄 삭제를 여기 모아 둔다. + * User · TeacherProfile · 약관 동의는 지우지 않는다 (카카오 로그인 상태를 유지하기 위해서). + * 시드 생성과 같은 트랜잭션에서만 돈다 (MANDATORY). 다시 만들다 실패하면 삭제까지 롤백되어 원래 데이터가 남는다. + */ +@Slf4j +@Component +@RequiredArgsConstructor +@ConditionalOnProperty(prefix = "sudam.seed", name = "enabled", havingValue = "true") +@Transactional(propagation = Propagation.MANDATORY) +public class DemoSeedResetter { + + private static final String INVOICE_IDS = "(select i.id from Invoice i where i.tutoring.id in :ids)"; + private static final String REPORT_IDS = "(select r.id from SettlementReport r where r.tutoring.id in :ids)"; + private static final String SESSION_IDS = "(select s.id from Session s where s.tutoring.id in :ids)"; + + // FK 역순 (자식 → 부모). 테이블이 늘면 여기에 추가한다 (예: settlement_report_views는 SettlementReport 앞). + private static final List STATEMENTS = List.of( + "delete from InvoiceAmountAdjustment a where a.invoice.id in " + INVOICE_IDS, + "delete from InvoicePayment p where p.invoice.id in " + INVOICE_IDS, + "delete from Invoice i where i.tutoring.id in :ids", + "delete from SettlementReportProgress p where p.report.id in " + REPORT_IDS, + "delete from SettlementReport r where r.tutoring.id in :ids", + "delete from SessionProgress p where p.session.id in " + SESSION_IDS, + "delete from SessionRecord r where r.session.id in " + SESSION_IDS, + "delete from Session s where s.tutoring.id in :ids", + "delete from Cycle c where c.tutoring.id in :ids", + // 학생 행이 같은 테이블의 학부모 행(guardian_consent_by)을 가리키므로, 한 번에 지우기 전에 참조를 비운다. + "update Participant p set p.guardianConsentBy = null where p.tutoring.id in :ids", + "delete from Participant p where p.tutoring.id in :ids", + "delete from TutoringSetting s where s.tutoring.id in :ids", + "delete from TutoringPolicy p where p.tutoring.id in :ids", + "delete from Textbook t where t.tutoring.id in :ids", + "delete from TutoringSchedule s where s.tutoring.id in :ids", + "delete from Tutoring t where t.id in :ids" + ); + + private final EntityManager entityManager; + + /*** + * 함수 기능: 선생님의 과외 전부와 그 아래 데이터(일정 · 교재 · 정책 · 설정 · 참여자 · 사이클 · 회차 · 기록 · 진도 · 리포트 · 청구)를 지운다. + * 일괄 삭제는 영속성 컨텍스트를 거치지 않는다. 시드는 이 호출 전에 과외 쪽 엔티티를 불러오지 않으므로 + * 낡은 엔티티가 남지 않는다 (불러온 것은 지우지 않는 User뿐). + * @param teacherId 시드 선생님 회원 ID + * @return 지운 과외 수 (0이면 아무것도 지우지 않았다) + */ + public int deleteTutoringsOf(Long teacherId) { + List tutoringIds = entityManager + .createQuery("select t.id from Tutoring t where t.teacher.id = :teacherId", Long.class) + .setParameter("teacherId", teacherId) + .getResultList(); + if (tutoringIds.isEmpty()) { + return 0; + } + + for (String jpql : STATEMENTS) { + entityManager.createQuery(jpql).setParameter("ids", tutoringIds).executeUpdate(); + } + log.warn("[가상 데이터] 리셋: 시드 선생님의 과외 {}개와 그 아래 데이터를 지웠습니다. teacherId={}, tutoringIds={}", + tutoringIds.size(), teacherId, tutoringIds); + return tutoringIds.size(); + } +} diff --git a/src/main/java/com/sudam/global/seed/DemoSeedRunner.java b/src/main/java/com/sudam/global/seed/DemoSeedRunner.java index 1e0b603..dc89008 100644 --- a/src/main/java/com/sudam/global/seed/DemoSeedRunner.java +++ b/src/main/java/com/sudam/global/seed/DemoSeedRunner.java @@ -22,25 +22,38 @@ public class DemoSeedRunner implements ApplicationRunner { private final DemoSeedService demoSeedService; private final JwtUtil jwtUtil; private final String teacherKakaoId; + private final boolean reset; public DemoSeedRunner(DemoSeedService demoSeedService, JwtUtil jwtUtil, - @Value("${sudam.seed.teacher-kakao-id:}") String teacherKakaoId) { + @Value("${sudam.seed.teacher-kakao-id:}") String teacherKakaoId, + @Value("${sudam.seed.reset:false}") boolean reset) { this.demoSeedService = demoSeedService; this.jwtUtil = jwtUtil; this.teacherKakaoId = teacherKakaoId == null || teacherKakaoId.isBlank() ? DEFAULT_TEACHER_KAKAO_ID : teacherKakaoId.trim(); + this.reset = reset; } /*** * 함수 기능: 가상 데이터를 만들고 시연에 필요한 값을 로그로 남긴다. + * sudam.seed.reset = true면 시드 선생님의 과외를 지우고 다시 만든다 (삭제 · 생성은 한 트랜잭션). * 기본 회원번호(가짜 계정)일 때만 액세스 토큰을 콘솔 로그에 한 번 출력한다. * 카카오 회원번호를 넣었으면 실제 사람 계정이므로 토큰을 출력하지 않는다. 토큰은 파일 · DB · 응답에 남기지 않는다. * @param args 실행 인자 (쓰지 않음) */ @Override public void run(ApplicationArguments args) { - DemoSeedResult result = demoSeedService.seed(teacherKakaoId); + if (reset) { + // 켜 둔 채 두면 재기동할 때마다 리허설 데이터가 지워지므로 크게 알린다. + log.warn(""" + + ================================================================== + [가상 데이터] 리셋 모드(SUDAM_SEED_RESET=true): 시드 선생님의 과외를 지우고 다시 만듭니다. + 리셋이 끝나면 SUDAM_SEED_RESET을 끄세요. 켜 두면 재기동할 때마다 데이터가 지워집니다. + =================================================================="""); + } + DemoSeedResult result = demoSeedService.seed(teacherKakaoId, reset); if (!result.created()) { log.info("[가상 데이터] 가상 데이터가 이미 있어 건너뜀. teacherUserId={}", result.teacherUserId()); return; diff --git a/src/main/java/com/sudam/global/seed/DemoSeedService.java b/src/main/java/com/sudam/global/seed/DemoSeedService.java index d0744a1..53a319a 100644 --- a/src/main/java/com/sudam/global/seed/DemoSeedService.java +++ b/src/main/java/com/sudam/global/seed/DemoSeedService.java @@ -97,6 +97,7 @@ public class DemoSeedService { private final SessionRecordRepository sessionRecordRepository; private final SessionProgressRepository sessionProgressRepository; private final SettlementReportCreator settlementReportCreator; + private final DemoSeedResetter demoSeedResetter; private final Clock clock; private final SecureRandom secureRandom = new SecureRandom(); @@ -104,13 +105,18 @@ public class DemoSeedService { /*** * 함수 기능: 시드 선생님 · 온보딩(프로필 · 약관) · 과외 5개를 한 트랜잭션에서 만든다. 중간에 실패하면 전부 롤백된다. * 시드 선생님에게 과외가 하나라도 있으면 아무것도 만들지 않는다 (ddl-auto: update에서 반복 부팅해도 한 번만 생김). + * reset이면 그 확인 전에 시드 선생님의 과외를 먼저 지운다. 같은 트랜잭션이라 다시 만들다 실패하면 삭제도 롤백된다. * @param teacherKakaoId 시드 선생님의 카카오 회원번호 (같은 회원이 있으면 그 회원을 쓴다) + * @param reset true면 시드 선생님의 과외를 지우고 처음 상태로 다시 만든다 (sudam.seed.reset) * @return 만들었는지 여부와 시연에 필요한 ID */ @Transactional - public DemoSeedResult seed(String teacherKakaoId) { + public DemoSeedResult seed(String teacherKakaoId, boolean reset) { User teacherUser = userRepository.findByProviderAndProviderId(Provider.KAKAO, teacherKakaoId) .orElseGet(() -> userRepository.save(User.createTeacher(Provider.KAKAO, teacherKakaoId, TEACHER_EMAIL))); + if (reset) { + demoSeedResetter.deleteTutoringsOf(teacherUser.getId()); + } if (tutoringRepository.existsByTeacherId(teacherUser.getId())) { return DemoSeedResult.skipped(teacherUser.getId(), teacherUser.getRole()); } diff --git a/src/main/resources/application.yaml b/src/main/resources/application.yaml index fd95104..714493a 100644 --- a/src/main/resources/application.yaml +++ b/src/main/resources/application.yaml @@ -61,3 +61,4 @@ sudam: seed: enabled: ${SUDAM_SEED_ENABLED:false} teacher-kakao-id: ${SUDAM_SEED_TEACHER_KAKAO_ID:} # 비우면 seed-teacher-1 (가짜 계정, 토큰을 콘솔에 출력) + reset: ${SUDAM_SEED_RESET:false} # enabled와 함께 true면 시드 선생님의 과외를 지우고 다시 만든다. 리셋 후 다시 끈다 diff --git a/src/test/java/com/sudam/global/seed/DemoSeedResetterTest.java b/src/test/java/com/sudam/global/seed/DemoSeedResetterTest.java new file mode 100644 index 0000000..4e19632 --- /dev/null +++ b/src/test/java/com/sudam/global/seed/DemoSeedResetterTest.java @@ -0,0 +1,84 @@ +package com.sudam.global.seed; + +import jakarta.persistence.EntityManager; +import jakarta.persistence.Query; +import jakarta.persistence.TypedQuery; +import org.junit.jupiter.api.DisplayName; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.extension.ExtendWith; +import org.mockito.ArgumentCaptor; +import org.mockito.InjectMocks; +import org.mockito.Mock; +import org.mockito.junit.jupiter.MockitoExtension; + +import java.util.List; + +import static org.assertj.core.api.Assertions.assertThat; +import static org.mockito.ArgumentMatchers.anyString; +import static org.mockito.ArgumentMatchers.eq; +import static org.mockito.BDDMockito.given; +import static org.mockito.Mockito.never; +import static org.mockito.Mockito.verify; + +@ExtendWith(MockitoExtension.class) +class DemoSeedResetterTest { + + @Mock private EntityManager entityManager; + @Mock private TypedQuery tutoringIdQuery; + @Mock private Query bulkQuery; + + @InjectMocks + private DemoSeedResetter demoSeedResetter; + + @Test + @DisplayName("시드 선생님에게 과외가 없으면 아무것도 지우지 않는다") + void 과외가_없으면_삭제_안_함() { + // given + givenTutoringIds(List.of()); + + // when + int deleted = demoSeedResetter.deleteTutoringsOf(1L); + + // then + assertThat(deleted).isZero(); + verify(entityManager, never()).createQuery(anyString()); + } + + @Test + @DisplayName("과외가 있으면 자식 테이블부터 FK 역순으로 지우고, 지운 과외 수를 돌려준다") + void 자식부터_역순_삭제() { + // given + givenTutoringIds(List.of(10L, 11L)); + given(entityManager.createQuery(anyString())).willReturn(bulkQuery); + given(bulkQuery.setParameter(eq("ids"), eq(List.of(10L, 11L)))).willReturn(bulkQuery); + + // when + int deleted = demoSeedResetter.deleteTutoringsOf(1L); + + // then + assertThat(deleted).isEqualTo(2); + ArgumentCaptor jpql = ArgumentCaptor.forClass(String.class); + verify(entityManager, org.mockito.Mockito.atLeastOnce()).createQuery(jpql.capture()); + assertThat(jpql.getAllValues()).extracting(DemoSeedResetterTest::targetEntity).containsExactly( + "InvoiceAmountAdjustment", "InvoicePayment", "Invoice", + "SettlementReportProgress", "SettlementReport", + "SessionProgress", "SessionRecord", "Session", "Cycle", + "Participant", "Participant", + "TutoringSetting", "TutoringPolicy", "Textbook", "TutoringSchedule", "Tutoring"); + // 학생 행이 같은 테이블의 학부모 행을 가리키므로, 지우기 전에 그 참조를 먼저 비운다. + assertThat(jpql.getAllValues().get(9)).startsWith("update Participant"); + assertThat(jpql.getAllValues().get(10)).startsWith("delete from Participant"); + } + + private void givenTutoringIds(List ids) { + given(entityManager.createQuery(anyString(), eq(Long.class))).willReturn(tutoringIdQuery); + given(tutoringIdQuery.setParameter(eq("teacherId"), eq(1L))).willReturn(tutoringIdQuery); + given(tutoringIdQuery.getResultList()).willReturn(ids); + } + + // "delete from X x ..." / "update X x ..."에서 X를 꺼낸다. + private static String targetEntity(String jpql) { + String[] words = jpql.trim().split("\\s+"); + return words[0].equals("delete") ? words[2] : words[1]; + } +} diff --git a/src/test/java/com/sudam/global/seed/DemoSeedRunnerConditionTest.java b/src/test/java/com/sudam/global/seed/DemoSeedRunnerConditionTest.java index 267161e..cebbd2c 100644 --- a/src/test/java/com/sudam/global/seed/DemoSeedRunnerConditionTest.java +++ b/src/test/java/com/sudam/global/seed/DemoSeedRunnerConditionTest.java @@ -34,6 +34,16 @@ class DemoSeedRunnerConditionTest { }); } + @Test + @DisplayName("sudam.seed.enabled=false면 sudam.seed.reset=true여도 리셋기 빈이 생기지 않는다") + void 시드가_꺼져_있으면_리셋기_없음() { + // when & then + new ApplicationContextRunner() + .withUserConfiguration(DemoSeedResetter.class) + .withPropertyValues("sudam.seed.enabled=false", "sudam.seed.reset=true") + .run(context -> assertThat(context).doesNotHaveBean(DemoSeedResetter.class)); + } + @Test @DisplayName("sudam.seed.enabled=true면 실행기 빈이 생긴다") void 설정값이_true면_빈_생성() { diff --git a/src/test/java/com/sudam/global/seed/DemoSeedRunnerTest.java b/src/test/java/com/sudam/global/seed/DemoSeedRunnerTest.java new file mode 100644 index 0000000..f342da7 --- /dev/null +++ b/src/test/java/com/sudam/global/seed/DemoSeedRunnerTest.java @@ -0,0 +1,36 @@ +package com.sudam.global.seed; + +import com.sudam.domain.user.enums.Role; +import com.sudam.global.security.util.JwtUtil; +import org.junit.jupiter.api.DisplayName; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.ValueSource; +import org.junit.jupiter.api.extension.ExtendWith; +import org.mockito.Mock; +import org.mockito.junit.jupiter.MockitoExtension; + +import static org.mockito.BDDMockito.given; +import static org.mockito.Mockito.verify; + +@ExtendWith(MockitoExtension.class) +class DemoSeedRunnerTest { + + @Mock private DemoSeedService demoSeedService; + @Mock private JwtUtil jwtUtil; + + @ParameterizedTest(name = "reset={0}") + @ValueSource(booleans = {true, false}) + @DisplayName("실행기는 sudam.seed.reset 값을 그대로 시드 서비스에 넘긴다") + void 리셋_플래그를_서비스에_전달(boolean reset) { + // given + DemoSeedRunner runner = new DemoSeedRunner(demoSeedService, jwtUtil, "", reset); + given(demoSeedService.seed(DemoSeedRunner.DEFAULT_TEACHER_KAKAO_ID, reset)) + .willReturn(DemoSeedResult.skipped(1L, Role.TEACHER)); + + // when + runner.run(null); + + // then + verify(demoSeedService).seed(DemoSeedRunner.DEFAULT_TEACHER_KAKAO_ID, reset); + } +} diff --git a/src/test/java/com/sudam/global/seed/DemoSeedServiceTest.java b/src/test/java/com/sudam/global/seed/DemoSeedServiceTest.java index 55298ca..4861c99 100644 --- a/src/test/java/com/sudam/global/seed/DemoSeedServiceTest.java +++ b/src/test/java/com/sudam/global/seed/DemoSeedServiceTest.java @@ -26,6 +26,7 @@ import org.junit.jupiter.api.Test; import org.junit.jupiter.api.extension.ExtendWith; import org.mockito.ArgumentCaptor; +import org.mockito.InOrder; import org.mockito.InjectMocks; import org.mockito.Mock; import org.mockito.junit.jupiter.MockitoExtension; @@ -49,6 +50,7 @@ import static org.mockito.ArgumentMatchers.any; import static org.mockito.ArgumentMatchers.anyLong; import static org.mockito.BDDMockito.given; +import static org.mockito.Mockito.inOrder; import static org.mockito.Mockito.times; import static org.mockito.Mockito.verify; import static org.mockito.Mockito.verifyNoInteractions; @@ -81,6 +83,7 @@ class DemoSeedServiceTest { @Mock private SessionRecordRepository sessionRecordRepository; @Mock private SessionProgressRepository sessionProgressRepository; @Mock private SettlementReportCreator settlementReportCreator; + @Mock private DemoSeedResetter demoSeedResetter; @Mock private Clock clock; @InjectMocks @@ -97,7 +100,7 @@ class DemoSeedServiceTest { given(tutoringRepository.existsByTeacherId(1L)).willReturn(true); // when - DemoSeedResult result = demoSeedService.seed("seed-teacher-1"); + DemoSeedResult result = demoSeedService.seed("seed-teacher-1", false); // then assertThat(result.created()).isFalse(); @@ -108,7 +111,27 @@ class DemoSeedServiceTest { verifyNoInteractions(teacherProfileRepository, termsRepository, userTermsAgreementRepository, tutoringScheduleRepository, textbookRepository, tutoringPolicyRepository, tutoringSettingRepository, participantRepository, cycleRepository, invoiceRepository, sessionRepository, - sessionRecordRepository, sessionProgressRepository, settlementReportCreator); + sessionRecordRepository, sessionProgressRepository, settlementReportCreator, demoSeedResetter); + } + + @Test + @DisplayName("reset=true면 과외 존재 여부를 보기 전에 시드 선생님의 과외를 지운다 (같은 트랜잭션)") + void 리셋이면_확인_전에_삭제() { + // given + User teacher = User.createTeacher(Provider.KAKAO, "seed-teacher-1", "seed-teacher@sudam.test"); + ReflectionTestUtils.setField(teacher, "id", 1L); + given(userRepository.findByProviderAndProviderId(Provider.KAKAO, "seed-teacher-1")) + .willReturn(Optional.of(teacher)); + // 순서만 확인하려고 삭제 뒤에도 과외가 남아 있다고 두어 생성 단계를 건너뛴다. + given(tutoringRepository.existsByTeacherId(1L)).willReturn(true); + + // when + demoSeedService.seed("seed-teacher-1", true); + + // then + InOrder inOrder = inOrder(demoSeedResetter, tutoringRepository); + inOrder.verify(demoSeedResetter).deleteTutoringsOf(1L); + inOrder.verify(tutoringRepository).existsByTeacherId(1L); } @Test @@ -222,7 +245,7 @@ private SeedCapture seedAll() { return cycleId + REPORT_ID_OFFSET; }); - DemoSeedResult result = demoSeedService.seed("seed-teacher-1"); + DemoSeedResult result = demoSeedService.seed("seed-teacher-1", false); assertThat(result.created()).isTrue(); ArgumentCaptor invoiceCaptor = ArgumentCaptor.forClass(Invoice.class); From dbdcb6aa0afc4b3d88aa3f31273418b6d96cb0bf Mon Sep 17 00:00:00 2001 From: chjpooh2002 Date: Mon, 16 Nov 2026 17:50:34 +0900 Subject: [PATCH 3/3] =?UTF-8?q?docs:=20=EC=8B=9C=EB=93=9C=20=EB=A6=AC?= =?UTF-8?q?=ED=8F=AC=ED=8A=B8=20=C2=B7=20=EB=A6=AC=EC=85=8B=20=EC=82=AC?= =?UTF-8?q?=EC=9A=A9=EB=B2=95=20=EC=B6=94=EA=B0=80=20(#41)?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- docs/architecture.md | 31 +++++++++++++++++++++---------- 1 file changed, 21 insertions(+), 10 deletions(-) diff --git a/docs/architecture.md b/docs/architecture.md index 3eac952..91107ab 100644 --- a/docs/architecture.md +++ b/docs/architecture.md @@ -77,7 +77,7 @@ com.sudam ├── handler/GeneralExceptionHandler # @RestControllerAdvice ├── entity/BaseTimeEntity.java # createdAt / updatedAt 감사 ├── crypto/AccountNumberConverter # 계좌번호 AES-256-GCM JPA 변환기 - ├── seed # 시연용 가상 데이터 (sudam.seed.enabled = true일 때만 빈 생성). DemoSeedRunner → DemoSeedService, DemoIncomeCard · DemoLessonPlan(순수 함수) + ├── seed # 시연용 가상 데이터 (sudam.seed.enabled = true일 때만 빈 생성). DemoSeedRunner → DemoSeedService(→ DemoSeedResetter: sudam.seed.reset일 때 삭제), DemoIncomeCard · DemoLessonPlan(순수 함수) ├── config # SecurityConfig, JpaConfig, SwaggerConfig, ClockConfig(Asia/Seoul Clock 빈 — 서비스는 LocalDateTime.now(clock)) └── security # 인증 인프라 (코드 enum은 domain/auth에 둔다) ├── filter/JwtAuthenticationFilter @@ -160,7 +160,7 @@ GET /api/v1/users/me/settings profile · provider만 DB 값, 소개서 ### 시연용 가상 데이터 -과외 · 참여자 생성 API가 없어 시연 데이터를 부팅 때 만든다 (`global/seed`). 정산 서비스를 거치지 않고 엔티티를 직접 만들어 한 트랜잭션으로 저장한다(중간 실패 시 아무것도 남지 않음). 날짜는 모두 `Clock` 빈(Asia/Seoul) 기준 실행일의 상대값이다. +과외 · 참여자 생성 API가 없어 시연 데이터를 부팅 때 만든다 (`global/seed`). 정산 서비스를 거치지 않고 엔티티를 직접 만들어 한 트랜잭션으로 저장한다(중간 실패 시 아무것도 남지 않음). 정산 리포트만은 실제 리포트 생성기(`SettlementReportCreator`)로 만들어 통계 · 진도 표가 정산과 같은 계산으로 나온다. 날짜는 모두 `Clock` 빈(Asia/Seoul) 기준 실행일의 상대값이다. **켜는 법** — `.env`(또는 환경 변수)에 넣고 부팅한다. 프로파일이 아니라 이 값 하나로 켜고 끈다. @@ -168,24 +168,34 @@ GET /api/v1/users/me/settings profile · provider만 DB 값, 소개서 | --- | --- | --- | | `SUDAM_SEED_ENABLED` | `false` | `true`일 때만 실행기 빈이 생긴다 (`sudam.seed.enabled`) | | `SUDAM_SEED_TEACHER_KAKAO_ID` | 빈 값 | 시드 선생님의 카카오 회원번호. 비우면 가짜 계정 `seed-teacher-1` | +| `SUDAM_SEED_RESET` | `false` | `SUDAM_SEED_ENABLED`와 함께 `true`면 재기동 때 시드 선생님의 과외를 지우고 처음 상태로 다시 만든다 (`sudam.seed.reset`) | - 회원번호가 기본값이면 부팅 로그에 액세스 토큰을 한 번 출력한다 (30분 뒤 만료, 다시 받으려면 재부팅). 파일 · DB · 응답에는 남기지 않는다. - 회원번호를 넣으면 실제 사람 계정이므로 토큰을 출력하지 않는다. 그 카카오 계정으로 한 번 로그인해 둔 회원이 있으면 그 회원에 데이터를 붙이고, 없으면 새로 만든다. 시연 때 카카오 로그인으로 들어간다. **반복 실행** — 시드 선생님(KAKAO, 회원번호)에게 과외가 하나라도 있으면 아무것도 만들지 않고 `가상 데이터가 이미 있어 건너뜀` 로그만 남긴다. `ddl-auto: create`면 부팅마다 새로 만들어지고, `update`면 처음 한 번만 만들어진다. +**리셋 (UT 리허설 뒤 되돌리기)** — `update`(개발 서버)에서 리허설로 바뀐 데이터를 처음 상태로 돌린다. + +1. `SUDAM_SEED_RESET=true`로 재기동한다. `DemoSeedResetter`가 시드 선생님의 과외와 그 아래 데이터(일정 · 교재 · 정책 · 설정 · 참여자 · 사이클 · 회차 · 기록 · 진도 · 리포트 · 청구 · 입금 · 교육비 조정)를 FK 역순으로 지우고, 같은 트랜잭션에서 시드를 다시 만든다. 다시 만들다 실패하면 삭제도 롤백된다. +2. User · TeacherProfile · 약관 동의는 지우지 않는다. 카카오로 로그인한 상태가 그대로 유지된다. 회원번호를 넣은 실제 계정이면 그 계정에서 손으로 만든 과외도 함께 지워진다. +3. 끝나면 `SUDAM_SEED_RESET`을 끄고 다시 재기동한다. 켜 둔 채면 재기동할 때마다 지워진다 (부팅 로그에 경고가 크게 찍힌다). + +테이블이 늘면 `DemoSeedResetter.STATEMENTS`에 FK 순서대로 추가한다 (예: 리포트 열람 테이블은 `SettlementReport` 삭제 앞). + **데이터** - 선생님 한서윤: 프로필(영어) + 현재 시행 중인 필수 약관 동의 → `GET /users/me`의 status = `ACTIVE`. - 과외마다 공통: 영어 과외, 수업 일정, 교재 1권, 선불 정책(사이클 1부터, 국민은행 · 가짜 계좌, 예금주 한서윤), 공유 설정, 학부모(어머님, 가짜 번호 `010000000xx`, 링크 토큰 발급). -- 수입 화면(T-15)용 4개 — 사이클 1 SETTLED · 사이클 2 IN_PROGRESS, 사이클 2를 청구하는 선불 '다음 N회차' 청구. 회차 · 기록은 없다. +- 수입 화면(T-15) · 리포트(T-13 · T-14)용 4개 — 사이클 1(실행 5주 전 시작, 1주 전 SETTLED) · 사이클 2 IN_PROGRESS, 사이클 2를 청구하는 선불 '다음 N회차' 청구. + - 사이클 1에 정산 회차만큼 회차 · 기록 · 진도(회차마다 2단원)를 깔고, 실제 정산 순서(정산 → 다음 사이클 → 리포트 → 청구)로 리포트를 만들어 청구 `report_id`에 연결한다. 실제 정산은 사이클을 닫을 때 항상 리포트를 만들므로 4명 모두 리포트가 있다. 이해도 분포는 학생마다 다르게 두었다. -| 학생 | 정산 회차 · 수업료 | 청구 상태 | 카드 아래 줄 | -| --- | --- | --- | --- | -| 박지후 | 8 · 360,000 | CONFIRM_REQUESTED (실행 2시간 전 학부모 요청) | `PARENT_CONFIRMED` | -| 윤서아 | 8 · 360,000 | PENDING, 미입금 알림 켬 | `REMINDER_SCHEDULED` | -| 이도윤 | 4 · 200,000 | PARTIAL (실행 하루 전 120,000 입금) | `PARTIAL_PAID` | -| 김하린 | 8 · 280,000 | PAID (실행 하루 전 전액 입금) | `NONE` | +| 학생 | 정산 회차 · 수업료 | 청구 상태 | 카드 아래 줄 | 사이클 1 리포트 (이해도 상/중/하, 숙제율) | +| --- | --- | --- | --- | --- | +| 박지후 | 8 · 360,000 | CONFIRM_REQUESTED (실행 2시간 전 학부모 요청) | `PARENT_CONFIRMED` | 있음 (6/2/0, 93%) | +| 윤서아 | 8 · 360,000 | PENDING, 미입금 알림 켬 | `REMINDER_SCHEDULED` | 있음 (2/5/1, 71%) | +| 이도윤 | 4 · 200,000 | PARTIAL (실행 하루 전 120,000 입금) | `PARTIAL_PAID` | 있음 (0/1/3, 50%) | +| 김하린 | 8 · 280,000 | PAID (실행 하루 전 전액 입금) | `NONE` | 있음 (5/3/0, 93%) | - 시연용 김서아(T-09 · T-14) — 고1 · 선불 · 8회 360,000원(회당 45,000). 수업은 18:00~19:30, 실행일이 월 · 수 · 금이면 월 · 수 · 금, 아니면 실행일 요일과 그 뒤 2일 · 4일 요일(오늘이 항상 수업일). 사이클 1 IN_PROGRESS에 오늘 **전** 수업일 7회의 기록 · 진도(수능특강 영어, Unit 1~14). 오늘 회차 · 청구(선불 첫 청구 포함)는 없다. - 안내일(`notified_at`)은 비어 있다. 목록은 `created_at`(실행 시각)으로 이번 달에 들어온다. @@ -194,11 +204,12 @@ GET /api/v1/users/me/settings profile · provider만 DB 값, 소개서 1. 부팅 로그의 토큰을 복사하거나(기본 계정) 카카오로 로그인한 뒤 Swagger(`/swagger-ui.html`) **Authorize**에 넣는다. 부팅 로그에 김서아 `tutoringId` · 오늘 `scheduleId` · `originalDate`가 함께 찍힌다. 2. `GET /api/v1/invoices` → 요약 1,200,000 / 400,000 / 800,000, 카드 4장(박지후 → 윤서아 → 이도윤 → 김하린). + - 각 청구의 `reportId`로 `GET /api/v1/reports/{reportId}`와 `GET /api/v1/reports/{reportId}/invoice`를 열 수 있다. 3. `POST /api/v1/tutorings/{김서아 tutoringId}/records` (`scheduleId` = 오늘 요일 일정, `originalDate` = 오늘, 교재 진도 15~16) → 응답 `noInCycle: 8`, `settlement.settled = true`, `reportId` · `invoiceId`. 4. `GET /api/v1/reports/{reportId}` → 김서아 8/8 리포트. 5. `GET /api/v1/invoices` → 1,560,000 / 400,000 / 1,160,000, 카드 5장(김서아 '다음 8회차' 360,000이 입금 대기로 추가). -**배포에서 쓸 때 주의** — 시연이 끝나면 `SUDAM_SEED_ENABLED`를 끈다. `ddl-auto: create`면 재배포(재부팅)마다 처음 상태로 돌아간다. 기본 계정의 토큰이 서버 로그에 남으므로 로그 접근 범위를 확인한다. +**배포에서 쓸 때 주의** — 시연이 끝나면 `SUDAM_SEED_ENABLED`를 끈다. `ddl-auto: create`면 재배포(재부팅)마다 처음 상태로 돌아간다. `update`에서 옛 시드(리포트 없음)가 이미 있으면 한 번 `SUDAM_SEED_RESET=true`로 재기동해야 리포트가 생긴다. 기본 계정의 토큰이 서버 로그에 남으므로 로그 접근 범위를 확인한다. ## 아직 정해지지 않은 것