#Step 11 — 테스트

@RegisterExtension
public static final TestWorkflowExtension testWorkflowExtension =
    TestWorkflowExtension.newBuilder()
        .setWorkflowTypes(OrderWorkflowImpl.class)
        .setActivityImplementations(new PaymentActivityImpl(), new InventoryActivityImpl())
        .setDoNotStart(true)      // 테스트 안에서 직접 start() 하고 싶을 때
        .build();

@Test
void 주문이_완료된다(TestWorkflowEnvironment testEnv, Worker worker, OrderWorkflow workflow) {
    worker.registerActivitiesImplementations(mockPayment);
    testEnv.start();
    assertThat(workflow.processOrder(req)).isEqualTo("order-1001 COMPLETED");
}

@BeforeEach void setUp()  { testEnv = TestWorkflowEnvironment.newInstance(); ... }
@AfterEach  void tearDown() { testEnv.close(); }

class OrderWorkflowTest {

    private static final String TASK_QUEUE = "ORDER_TASK_QUEUE";

    private TestWorkflowEnvironment testEnv;
    private Worker worker;
    private WorkflowClient client;

    private PaymentActivity payment;
    private InventoryActivity inventory;
    private ShippingActivity shipping;
    private NotificationActivity notification;

    @BeforeEach
    void setUp() {
        testEnv = TestWorkflowEnvironment.newInstance();
        worker  = testEnv.newWorker(TASK_QUEUE);
        client  = testEnv.getWorkflowClient();

        worker.registerWorkflowImplementationTypes(OrderWorkflowImpl.class);

        payment      = mock(PaymentActivity.class,      withSettings().withoutAnnotations());
        inventory    = mock(InventoryActivity.class,    withSettings().withoutAnnotations());
        shipping     = mock(ShippingActivity.class,     withSettings().withoutAnnotations());
        notification = mock(NotificationActivity.class, withSettings().withoutAnnotations());
        worker.registerActivitiesImplementations(payment, inventory, shipping, notification);
    }

    @AfterEach
    void tearDown() {
        testEnv.close();
    }

    @Test
    void 정상_주문은_COMPLETED_를_반환한다() {
        when(payment.charge("1001", 39000L)).thenReturn("PAY-8821");
        when(inventory.reserve("1001", "SKU-A", 2)).thenReturn("RSV-3310");
        when(shipping.requestShipment(eq("1001"), anyString())).thenReturn("SHIP-5507");

        testEnv.start();

        OrderWorkflow wf = client.newWorkflowStub(OrderWorkflow.class,
            WorkflowOptions.newBuilder()
                .setTaskQueue(TASK_QUEUE).setWorkflowId("order-1001").build());

        String result = wf.processOrder(
            new OrderRequest("1001", "C-77", "SKU-A", 2, 39000L, "서울시 강남구"));

        assertThat(result).isEqualTo("order-1001 COMPLETED");
        verify(payment).charge("1001", 39000L);
        verify(inventory).reserve("1001", "SKU-A", 2);
        verify(notification).notifyCustomer("1001", "주문이 완료되었습니다");
    }
}

System.out.println(testEnv.getDiagnostics());

public class ReviewReminderWorkflowImpl implements ReviewReminderWorkflow {
    private final NotificationActivity notification =
        Workflow.newActivityStub(NotificationActivity.class, ACT_OPTS);

    @Override
    public String remind(String orderId) {
        Workflow.sleep(Duration.ofDays(30));          // ← 30일 대기
        notification.notifyCustomer(orderId, "리뷰를 남겨 주세요");
        return orderId + " REMINDED";
    }
}

@Test
void 삼십일_뒤_리뷰_요청을_보낸다() {
    worker.registerWorkflowImplementationTypes(ReviewReminderWorkflowImpl.class);
    testEnv.start();

    ReviewReminderWorkflow wf = client.newWorkflowStub(
        ReviewReminderWorkflow.class,
        WorkflowOptions.newBuilder().setTaskQueue(TASK_QUEUE)
            .setWorkflowId("review-1001").build());

    long before = System.currentTimeMillis();
    String result = wf.remind("1001");                 // 블로킹 호출인데도…
    long wallClock = System.currentTimeMillis() - before;

    assertThat(result).isEqualTo("1001 REMINDED");
    assertThat(wallClock).isLessThan(2000);            // 실제 경과 2초 미만
    verify(notification).notifyCustomer("1001", "리뷰를 남겨 주세요");
}

long t0 = testEnv.currentTimeMillis();
testEnv.sleep(Duration.ofDays(7));                 // 가상 시계를 7일 밀기
long t1 = testEnv.currentTimeMillis();
System.out.println("가상 경과일 = " + Duration.ofMillis(t1 - t0).toDays());

WorkflowClient.start(wf::processOrder, req);        // 비동기 시작
testEnv.sleep(Duration.ofDays(3));                  // 가상 3일 경과
assertThat(wf.getStatus()).isEqualTo("WAITING_SHIPMENT");

PaymentActivity payment = mock(PaymentActivity.class, withSettings().withoutAnnotations());
when(payment.charge("1001", 39000L)).thenReturn("PAY-8821");
worker.registerActivitiesImplementations(payment);

// 재시도 가능한 실패 — RetryOptions 만큼 재시도된 뒤 최종 실패
when(payment.charge("1001", 39000L))
    .thenThrow(ApplicationFailure.newFailure("카드사 응답 없음", "PaymentGatewayTimeout"));

// 재시도 불가 실패 — 즉시 워크플로우로 전파
when(payment.charge("1001", 39000L))
    .thenThrow(ApplicationFailure.newNonRetryableFailure("잔액 부족", "InsufficientFunds"));

// 첫 두 번은 실패, 세 번째 성공 — 재시도 동작 자체를 검증
when(payment.charge("1001", 39000L))
    .thenThrow(ApplicationFailure.newFailure("일시 오류", "Transient"))
    .thenThrow(ApplicationFailure.newFailure("일시 오류", "Transient"))
    .thenReturn("PAY-8821");

@Test
void 결제는_두번_실패해도_세번째에_성공한다() {
    when(payment.charge("1001", 39000L))
        .thenThrow(ApplicationFailure.newFailure("일시 오류", "Transient"))
        .thenThrow(ApplicationFailure.newFailure("일시 오류", "Transient"))
        .thenReturn("PAY-8821");
    when(inventory.reserve(any(), any(), anyInt())).thenReturn("RSV-3310");
    when(shipping.requestShipment(any(), any())).thenReturn("SHIP-5507");

    testEnv.start();
    assertThat(newStub("order-1002").processOrder(req("1002")))
        .isEqualTo("order-1002 COMPLETED");

    verify(payment, times(3)).charge("1002", 39000L);   // 재시도 2회 + 성공 1회
}

@Test
void 재고_예약_액티비티가_예약ID를_반환한다() {
    TestActivityEnvironment env = TestActivityEnvironment.newInstance();
    env.registerActivitiesImplementations(new InventoryActivityImpl());

    InventoryActivity stub = env.newActivityStub(InventoryActivity.class);

    String reservationId = stub.reserve("1001", "SKU-A", 2);

    assertThat(reservationId).startsWith("RSV-");
    env.close();
}

TestActivityEnvironment env = TestActivityEnvironment.newInstance();
env.registerActivitiesImplementations(new ShippingActivityImpl());

List<Object> heartbeats = new ArrayList<>();
env.setActivityHeartbeatListener(String.class, heartbeats::add);

ShippingActivity stub = env.newActivityStub(ShippingActivity.class);
CompletableFuture<String> f =
    CompletableFuture.supplyAsync(() -> stub.requestShipment("1001", "서울시 강남구"));

Thread.sleep(300);
env.requestCancelActivity();                    // 취소 요청

assertThatThrownBy(f::get).hasCauseInstanceOf(ActivityCanceledException.class);
assertThat(heartbeats).contains("polling-1", "polling-2");
env.close();

@Test
void 취소_시그널을_받으면_상태가_CANCELED_로_바뀐다() {
    when(payment.charge(any(), anyLong())).thenReturn("PAY-8821");
    when(inventory.reserve(any(), any(), anyInt())).thenReturn("RSV-3310");
    testEnv.start();

    OrderWorkflow wf = client.newWorkflowStub(OrderWorkflow.class,
        WorkflowOptions.newBuilder().setTaskQueue(TASK_QUEUE)
            .setWorkflowId("order-1003").build());

    // ① 비동기 시작 — 즉시 반환된다
    WorkflowExecution exec = WorkflowClient.start(wf::processOrder, req("1003"));
    assertThat(exec.getWorkflowId()).isEqualTo("order-1003");

    // ② 가상 시간을 조금 흘려 워크플로우가 대기 지점까지 진행하게 한다
    testEnv.sleep(Duration.ofSeconds(1));

    // ③ 쿼리 — 진행 중 상태 확인
    assertThat(wf.getStatus()).isEqualTo("WAITING_SHIPMENT");

    // ④ 시그널 — 취소 요청
    wf.cancelRequested("고객 변심");

    // ⑤ 쿼리 — 시그널 반영 확인
    testEnv.sleep(Duration.ofSeconds(1));
    assertThat(wf.getStatus()).isEqualTo("CANCELED");

    // ⑥ 결과 회수 — 타입 스텁을 WorkflowStub 으로 변환
    String result = WorkflowStub.fromTyped(wf).getResult(String.class);
    assertThat(result).isEqualTo("order-1003 CANCELED");
}

@Test
void 배송이_실패하면_보상이_역순으로_실행된다() {
    when(payment.charge("1004", 39000L)).thenReturn("PAY-8821");
    when(inventory.reserve("1004", "SKU-A", 2)).thenReturn("RSV-3310");
    // 배송만 재시도 불가 실패로 주입
    when(shipping.requestShipment(eq("1004"), anyString()))
        .thenThrow(ApplicationFailure.newNonRetryableFailure(
            "배송 불가 지역", "ShippingUnavailable"));

    testEnv.start();

    assertThatThrownBy(() -> newStub("order-1004").processOrder(req("1004")))
        .isInstanceOf(WorkflowFailedException.class)
        .hasRootCauseMessage("배송 불가 지역");

    // 보상이 "실행의 역순"으로 호출되었는지 검증
    InOrder inOrder = inOrder(payment, inventory, shipping);
    inOrder.verify(payment).charge("1004", 39000L);         // 정방향 1
    inOrder.verify(inventory).reserve("1004", "SKU-A", 2);  // 정방향 2
    inOrder.verify(shipping).requestShipment(eq("1004"), anyString()); // 정방향 3 (실패)
    inOrder.verify(inventory).release("RSV-3310");          // 보상 1 ← 나중 것 먼저
    inOrder.verify(payment).refund("PAY-8821");             // 보상 2 ← 먼저 한 것 나중에

    verify(shipping, never()).cancelShipment(anyString());  // 배송은 애초에 성공한 적 없음
}

import io.temporal.testing.WorkflowReplayer;

class OrderWorkflowReplayTest {

    @Test
    void 운영_히스토리를_현재_코드로_리플레이할_수_있다() throws Exception {
        WorkflowReplayer.replayWorkflowExecutionFromResource(
            "histories/order-1001.json", OrderWorkflowImpl.class);
    }
}

class OrderWorkflowReplayTest {

    static Stream<Path> histories() throws Exception {
        Path dir = Paths.get(
            OrderWorkflowReplayTest.class.getResource("/histories").toURI());
        try (Stream<Path> s = Files.list(dir)) {
            return s.filter(p -> p.toString().endsWith(".json")).toList().stream();
        }
    }

    @ParameterizedTest(name = "replay {0}")
    @MethodSource("histories")
    void 모든_운영_히스토리가_리플레이된다(Path history) throws Exception {
        WorkflowReplayer.replayWorkflowExecution(
            Files.readString(history), OrderWorkflowImpl.class);
    }
}

package com.example.order;

/*
 * Step 11 — 테스트 : Practice
 *
 * 실행 방법
 *   전체        : ./gradlew test --tests 'com.example.order.Practice'
 *   구간만      : ./gradlew test --tests 'com.example.order.Practice$TimeSkippingTests'
 *   리플레이만  : ./gradlew test --tests 'com.example.order.Practice$ReplayTests'
 *
 * 위치: src/test/java/com/example/order/Practice.java
 *
 * 필요 의존성 (build.gradle)
 *   testImplementation 'io.temporal:temporal-testing:1.22.3'
 *   testImplementation 'org.junit.jupiter:junit-jupiter:5.10.1'
 *   testImplementation 'org.mockito:mockito-core:5.8.0'
 *   testImplementation 'org.assertj:assertj-core:3.24.2'
 *
 * Temporal Server 를 띄울 필요가 없습니다. TestWorkflowEnvironment 가
 * temporal-test-server 를 인메모리로 기동합니다. (11-1)
 */

import io.temporal.activity.ActivityInterface;
import io.temporal.activity.ActivityMethod;
import io.temporal.activity.ActivityOptions;
import io.temporal.api.common.v1.WorkflowExecution;
import io.temporal.client.WorkflowClient;
import io.temporal.client.WorkflowFailedException;
import io.temporal.client.WorkflowOptions;
import io.temporal.client.WorkflowStub;
import io.temporal.failure.ApplicationFailure;
import io.temporal.testing.TestActivityEnvironment;
import io.temporal.testing.TestWorkflowEnvironment;
import io.temporal.worker.Worker;
import io.temporal.workflow.Workflow;
import io.temporal.workflow.WorkflowInterface;
import io.temporal.workflow.WorkflowMethod;
import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Nested;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.MethodSource;
import org.mockito.InOrder;

import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.time.Duration;
import java.util.ArrayList;
import java.util.List;
import java.util.stream.Stream;

import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatThrownBy;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.anyInt;
import static org.mockito.ArgumentMatchers.anyLong;
import static org.mockito.ArgumentMatchers.anyString;
import static org.mockito.ArgumentMatchers.eq;
import static org.mockito.Mockito.inOrder;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.never;
import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
import static org.mockito.Mockito.withSettings;

class Practice {

    static final String TASK_QUEUE = "ORDER_TASK_QUEUE";

    // [11-4] 액티비티 mock 은 반드시 이 헬퍼를 거칩니다.
    //        withSettings().withoutAnnotations() 를 빠뜨리면 registerActivitiesImplementations 가
    //        IllegalArgumentException: Interface annotated with @ActivityInterface can't be
    //        registered as an activity implementation 으로 실패합니다.
    static <T> T activityMock(Class<T> type) {
        return mock(type, withSettings().withoutAnnotations());
    }

    static OrderRequest req(String orderId) {
        return new OrderRequest(orderId, "C-77", "SKU-A", 2, 39000L, "서울시 강남구");
    }

    // =====================================================================
    // [11-2][11-4][11-6][11-7] 워크플로우 테스트
    // =====================================================================
    @Nested
    @DisplayName("11-2/4/6/7 — TestWorkflowEnvironment 워크플로우 테스트")
    class WorkflowTests {

        TestWorkflowEnvironment testEnv;
        Worker worker;
        WorkflowClient client;

        PaymentActivity payment;
        InventoryActivity inventory;
        ShippingActivity shipping;
        NotificationActivity notification;

        @BeforeEach
        void setUp() {
            // [11-2] 서버 없이 인메모리 Temporal 서비스가 뜹니다.
            testEnv = TestWorkflowEnvironment.newInstance();
            worker = testEnv.newWorker(TASK_QUEUE);
            client = testEnv.getWorkflowClient();

            worker.registerWorkflowImplementationTypes(OrderWorkflowImpl.class);

            payment = activityMock(PaymentActivity.class);
            inventory = activityMock(InventoryActivity.class);
            shipping = activityMock(ShippingActivity.class);
            notification = activityMock(NotificationActivity.class);
            worker.registerActivitiesImplementations(payment, inventory, shipping, notification);
        }

        @AfterEach
        void tearDown() {
            testEnv.close();
        }

        OrderWorkflow stub(String workflowId) {
            return client.newWorkflowStub(OrderWorkflow.class,
                    WorkflowOptions.newBuilder()
                            .setTaskQueue(TASK_QUEUE)
                            .setWorkflowId(workflowId)
                            .build());
        }

        // [11-2] 첫 테스트 — 기대 소요 0.9초 내외
        @Test
        @DisplayName("11-2 정상 주문은 COMPLETED 를 반환한다")
        void 정상_주문은_COMPLETED_를_반환한다() {
            when(payment.charge("1001", 39000L)).thenReturn("PAY-8821");
            when(inventory.reserve("1001", "SKU-A", 2)).thenReturn("RSV-3310");
            when(shipping.requestShipment(eq("1001"), anyString())).thenReturn("SHIP-5507");

            testEnv.start();

            String result = stub("order-1001").processOrder(req("1001"));

            assertThat(result).isEqualTo("order-1001 COMPLETED");
            verify(payment).charge("1001", 39000L);
            verify(inventory).reserve("1001", "SKU-A", 2);
            verify(notification).notifyCustomer("1001", "주문이 완료되었습니다");

            // 테스트 환경에도 진짜 이벤트 히스토리가 쌓입니다.
            System.out.println(testEnv.getDiagnostics());
        }

        // [11-4] 실패 주입 — 재시도 불가
        @Test
        @DisplayName("11-4 잔액 부족은 재시도 없이 즉시 실패한다")
        void 잔액_부족은_즉시_실패한다() {
            when(payment.charge("1002", 39000L)).thenThrow(
                    ApplicationFailure.newNonRetryableFailure("잔액 부족", "InsufficientFunds"));

            testEnv.start();

            assertThatThrownBy(() -> stub("order-1002").processOrder(req("1002")))
                    .isInstanceOf(WorkflowFailedException.class)
                    .hasRootCauseMessage("잔액 부족");

            verify(payment, times(1)).charge("1002", 39000L);   // 재시도 없음
            verify(inventory, never()).reserve(any(), any(), anyInt());
        }

        // [11-4] 재시도 동작 검증 — 백오프에도 시간 스킵이 적용되어 0.5초에 끝납니다.
        @Test
        @DisplayName("11-4 결제는 두 번 실패해도 세 번째에 성공한다")
        void 결제는_두번_실패해도_세번째에_성공한다() {
            when(payment.charge("1003", 39000L))
                    .thenThrow(ApplicationFailure.newFailure("일시 오류", "Transient"))
                    .thenThrow(ApplicationFailure.newFailure("일시 오류", "Transient"))
                    .thenReturn("PAY-8821");
            when(inventory.reserve(any(), any(), anyInt())).thenReturn("RSV-3310");
            when(shipping.requestShipment(any(), any())).thenReturn("SHIP-5507");

            testEnv.start();

            assertThat(stub("order-1003").processOrder(req("1003")))
                    .isEqualTo("order-1003 COMPLETED");

            verify(payment, times(3)).charge("1003", 39000L);
        }

        // [11-6] 시그널 · 쿼리 · 결과 회수
        @Test
        @DisplayName("11-6 취소 시그널을 받으면 상태가 CANCELED 로 바뀐다")
        void 취소_시그널을_받으면_CANCELED() {
            when(payment.charge(any(), anyLong())).thenReturn("PAY-8821");
            when(inventory.reserve(any(), any(), anyInt())).thenReturn("RSV-3310");

            testEnv.start();
            OrderWorkflow wf = stub("order-1004");

            // ① 비동기 시작 — 즉시 반환
            WorkflowExecution exec = WorkflowClient.start(wf::processOrder, req("1004"));
            assertThat(exec.getWorkflowId()).isEqualTo("order-1004");

            // ② 가상 시간을 밀어 워크플로우를 대기 지점까지 진행시킴 (Thread.sleep 금지!)
            testEnv.sleep(Duration.ofSeconds(1));

            // ③ 쿼리
            assertThat(wf.getStatus()).isEqualTo("WAITING_SHIPMENT");

            // ④ 시그널
            wf.cancelRequested("고객 변심");
            testEnv.sleep(Duration.ofSeconds(1));

            // ⑤ 쿼리로 반영 확인
            assertThat(wf.getStatus()).isEqualTo("CANCELED");

            // ⑥ 결과 회수 — 타입 스텁을 언타입 스텁으로 변환해야 getResult 가 가능
            String result = WorkflowStub.fromTyped(wf).getResult(String.class);
            assertThat(result).isEqualTo("order-1004 CANCELED");
        }

        // [11-7] Saga 보상 역순 검증
        @Test
        @DisplayName("11-7 배송이 실패하면 보상이 역순으로 실행된다")
        void 배송_실패시_보상은_역순() {
            when(payment.charge("1005", 39000L)).thenReturn("PAY-8821");
            when(inventory.reserve("1005", "SKU-A", 2)).thenReturn("RSV-3310");
            when(shipping.requestShipment(eq("1005"), anyString())).thenThrow(
                    ApplicationFailure.newNonRetryableFailure("배송 불가 지역", "ShippingUnavailable"));

            testEnv.start();

            assertThatThrownBy(() -> stub("order-1005").processOrder(req("1005")))
                    .isInstanceOf(WorkflowFailedException.class)
                    .hasRootCauseMessage("배송 불가 지역");

            // verify 만 쓰면 "둘 다 호출됨"만 확인됩니다. 순서 버그는 InOrder 로만 잡힙니다.
            InOrder ord = inOrder(payment, inventory, shipping);
            ord.verify(payment).charge("1005", 39000L);
            ord.verify(inventory).reserve("1005", "SKU-A", 2);
            ord.verify(shipping).requestShipment(eq("1005"), anyString());
            ord.verify(inventory).release("RSV-3310");     // 보상 1 — 나중 것 먼저
            ord.verify(payment).refund("PAY-8821");        // 보상 2 — 먼저 한 것 나중에

            verify(shipping, never()).cancelShipment(anyString());
        }
    }

    // =====================================================================
    // [11-3] 시간 스킵 — 30일이 0.4초
    // =====================================================================
    @Nested
    @DisplayName("11-3 — 시간 스킵")
    class TimeSkippingTests {

        TestWorkflowEnvironment testEnv;
        Worker worker;
        WorkflowClient client;
        NotificationActivity notification;

        @BeforeEach
        void setUp() {
            testEnv = TestWorkflowEnvironment.newInstance();
            worker = testEnv.newWorker(TASK_QUEUE);
            client = testEnv.getWorkflowClient();
            worker.registerWorkflowImplementationTypes(ReviewReminderWorkflowImpl.class);
            notification = activityMock(NotificationActivity.class);
            worker.registerActivitiesImplementations(notification);
        }

        @AfterEach
        void tearDown() {
            testEnv.close();
        }

        @Test
        @DisplayName("11-3 30일 대기 워크플로우가 2초 미만에 끝난다")
        void 삼십일_대기가_즉시_끝난다() {
            testEnv.start();

            ReviewReminderWorkflow wf = client.newWorkflowStub(ReviewReminderWorkflow.class,
                    WorkflowOptions.newBuilder()
                            .setTaskQueue(TASK_QUEUE)
                            .setWorkflowId("review-1001")
                            .build());

            long before = System.currentTimeMillis();
            String result = wf.remind("1001");
            long wallClock = System.currentTimeMillis() - before;

            assertThat(result).isEqualTo("1001 REMINDED");
            // "빨리 끝났다"를 주석이 아니라 테스트 조건으로 못박습니다.
            // 시간 스킵이 꺼지면 이 단언이 깨집니다.
            assertThat(wallClock).isLessThan(2000);
            verify(notification).notifyCustomer("1001", "리뷰를 남겨 주세요");

            System.out.println("벽시계 경과 = " + wallClock + "ms / 가상 경과 = 30일");
        }

        @Test
        @DisplayName("11-3 testEnv.sleep 은 가상 시각만 민다")
        void 가상_시각을_직접_민다() {
            testEnv.start();
            long t0 = testEnv.currentTimeMillis();
            testEnv.sleep(Duration.ofDays(7));
            long t1 = testEnv.currentTimeMillis();

            assertThat(Duration.ofMillis(t1 - t0).toDays()).isEqualTo(7);
        }
    }

    // =====================================================================
    // [11-5] TestActivityEnvironment — 액티비티 단독
    // =====================================================================
    @Nested
    @DisplayName("11-5 — TestActivityEnvironment")
    class ActivityTests {

        @Test
        @DisplayName("11-5 재고 예약 액티비티가 예약 ID 를 반환한다")
        void 재고_예약_단독_테스트() {
            TestActivityEnvironment env = TestActivityEnvironment.newInstance();
            env.registerActivitiesImplementations(new InventoryActivityImpl());

            InventoryActivity stub = env.newActivityStub(InventoryActivity.class);
            String reservationId = stub.reserve("1001", "SKU-A", 2);

            assertThat(reservationId).startsWith("RSV-");
            env.close();
        }

        @Test
        @DisplayName("11-5 하트비트가 실제로 전송되는지 확인한다")
        void 하트비트_리스너로_검증() {
            TestActivityEnvironment env = TestActivityEnvironment.newInstance();
            env.registerActivitiesImplementations(new ShippingActivityImpl());

            List<Object> heartbeats = new ArrayList<>();
            env.setActivityHeartbeatListener(String.class, heartbeats::add);

            ShippingActivity stub = env.newActivityStub(ShippingActivity.class);
            String shipmentId = stub.requestShipment("1001", "서울시 강남구");

            assertThat(shipmentId).startsWith("SHIP-");
            assertThat(heartbeats).isNotEmpty();
            System.out.println("수신한 하트비트: " + heartbeats);
            env.close();
        }
    }

    // =====================================================================
    // [11-8] 리플레이 테스트
    // =====================================================================
    @Nested
    @DisplayName("11-8 — WorkflowReplayer")
    class ReplayTests {

        static Stream<Path> histories() throws Exception {
            var url = Practice.class.getResource("/histories");
            if (url == null) {
                return Stream.empty();
            }
            Path dir = Paths.get(url.toURI());
            try (Stream<Path> s = Files.list(dir)) {
                return s.filter(p -> p.toString().endsWith(".json")).toList().stream();
            }
        }

        // 히스토리 파일이 하나도 없으면 아래 @ParameterizedTest 가 0건으로 "조용히 통과"합니다.
        // 그 함정을 막는 가드 테스트입니다.
        @Test
        @DisplayName("11-8 히스토리 리소스가 비어 있지 않다")
        void 히스토리가_존재한다() throws Exception {
            assertThat(histories().toList())
                    .as("src/test/resources/histories/*.json — dump-histories.sh 로 채우세요")
                    .isNotEmpty();
        }

        @ParameterizedTest(name = "replay {0}")
        @MethodSource("histories")
        @DisplayName("11-8 모든 운영 히스토리가 현재 코드로 리플레이된다")
        void 모든_히스토리가_리플레이된다(Path history) throws Exception {
            io.temporal.testing.WorkflowReplayer.replayWorkflowExecution(
                    Files.readString(history), OrderWorkflowImpl.class);
        }

        // 클래스패스 리소스 이름으로 직접 지정하는 단건 버전
        @Test
        @DisplayName("11-8 order-1001.json 단건 리플레이")
        void 단건_리플레이() throws Exception {
            io.temporal.testing.WorkflowReplayer.replayWorkflowExecutionFromResource(
                    "histories/order-1001.json", OrderWorkflowImpl.class);
        }
    }

    // =====================================================================
    // 본문 11-3 예제를 이 파일만으로 돌리기 위한 픽스처
    // =====================================================================

    @WorkflowInterface
    public interface ReviewReminderWorkflow {
        @WorkflowMethod
        String remind(String orderId);
    }

    public static class ReviewReminderWorkflowImpl implements ReviewReminderWorkflow {

        private final NotificationActivity notification = Workflow.newActivityStub(
                NotificationActivity.class,
                ActivityOptions.newBuilder()
                        .setStartToCloseTimeout(Duration.ofSeconds(10))
                        .build());

        @Override
        public String remind(String orderId) {
            // 실제 서버에서는 30일. 테스트 환경에서는 가상 시계가 즉시 점프합니다.
            Workflow.sleep(Duration.ofDays(30));
            notification.notifyCustomer(orderId, "리뷰를 남겨 주세요");
            return orderId + " REMINDED";
        }
    }

    // 11-5 에서 쓰는 최소 액티비티 구현 (실제 프로젝트에서는 src/main 에 있습니다)
    public static class InventoryActivityImpl implements InventoryActivity {
        @Override
        public String reserve(String orderId, String sku, int qty) {
            return "RSV-" + Math.abs((orderId + sku).hashCode() % 10000);
        }

        @Override
        public void release(String reservationId) {
            System.out.println("release " + reservationId);
        }
    }

    public static class ShippingActivityImpl implements ShippingActivity {
        @Override
        public String requestShipment(String orderId, String address) {
            for (int i = 1; i <= 3; i++) {
                io.temporal.activity.Activity.getExecutionContext()
                        .heartbeat("polling-" + i);
            }
            return "SHIP-" + Math.abs(orderId.hashCode() % 10000);
        }

        @Override
        public void cancelShipment(String shipmentId) {
            System.out.println("cancelShipment " + shipmentId);
        }
    }

    // 참고 — 실제 액티비티 인터페이스는 src/main 에 있습니다.
    // 이 파일 단독으로 컴파일해 보고 싶을 때만 아래 주석을 해제하세요.
    //
    // @ActivityInterface
    // public interface NotificationActivity {
    //     @ActivityMethod void notifyCustomer(String orderId, String message);
    // }
}

package com.example.order;

/*
 * Step 11 — 테스트 : Exercise (문제지)
 *
 * 실행 방법
 *   ./gradlew test --tests 'com.example.order.Exercise'
 *
 * 위치: src/test/java/com/example/order/Exercise.java
 *
 * 각 문제의 // TODO 자리를 채우세요. 단언문(assertThat)은 이미 적혀 있으므로
 * "무엇을 만족시켜야 하는지"는 명확합니다. 단언문을 고쳐서 통과시키지 마세요.
 *
 * 문제 7 을 풀려면 src/test/resources/histories/ 에 히스토리 JSON 이 필요합니다.
 * 운영 서버가 없다면 이렇게 만드세요.
 *   1) Practice$WorkflowTests 를 한 번 실행합니다.
 *   2) 콘솔에 출력된 testEnv.getDiagnostics() 의 히스토리 부분을 참고하거나,
 *   3) 로컬 dev 서버(temporal server start-dev)에서 워크플로우를 한 번 돌린 뒤
 *      temporal workflow show -w order-1001 --output json > src/test/resources/histories/order-1001.json
 */

import io.temporal.client.WorkflowClient;
import io.temporal.client.WorkflowFailedException;
import io.temporal.client.WorkflowOptions;
import io.temporal.failure.ApplicationFailure;
import io.temporal.testing.TestActivityEnvironment;
import io.temporal.testing.TestWorkflowEnvironment;
import io.temporal.worker.Worker;
import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;

import java.nio.file.Path;
import java.time.Duration;
import java.util.stream.Stream;

import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatThrownBy;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.anyInt;
import static org.mockito.ArgumentMatchers.anyLong;
import static org.mockito.ArgumentMatchers.anyString;
import static org.mockito.ArgumentMatchers.eq;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
import static org.mockito.Mockito.withSettings;

class Exercise {

    static final String TASK_QUEUE = "ORDER_TASK_QUEUE";

    TestWorkflowEnvironment testEnv;
    Worker worker;
    WorkflowClient client;

    PaymentActivity payment;
    InventoryActivity inventory;
    ShippingActivity shipping;
    NotificationActivity notification;

    static OrderRequest req(String orderId) {
        return new OrderRequest(orderId, "C-77", "SKU-A", 2, 39000L, "서울시 강남구");
    }

    // -----------------------------------------------------------------
    // 문제 1 — TestWorkflowEnvironment 를 수동으로 구성하기
    //
    // setUp() 의 TODO 를 채워 아래 테스트가 통과하게 하세요.
    // 필요한 것: 인메모리 환경 생성, Worker 생성, WorkflowClient 획득,
    //            워크플로우 타입 등록, 액티비티 mock 등록.
    // -----------------------------------------------------------------
    @BeforeEach
    void setUp() {
        // TODO: 여기에 작성 — testEnv / worker / client 초기화
        // 힌트: TestWorkflowEnvironment.newInstance(), testEnv.newWorker(TASK_QUEUE),
        //       testEnv.getWorkflowClient()

        // TODO: 여기에 작성 — worker.registerWorkflowImplementationTypes(...)

        // TODO: 여기에 작성 — payment / inventory / shipping / notification mock 생성 후
        //       worker.registerActivitiesImplementations(...)
        //       (문제 3 을 먼저 읽고 오면 어떻게 mock 을 만들어야 하는지 알 수 있습니다)
    }

    @AfterEach
    void tearDown() {
        if (testEnv != null) {
            testEnv.close();
        }
    }

    OrderWorkflow stub(String workflowId) {
        return client.newWorkflowStub(OrderWorkflow.class,
                WorkflowOptions.newBuilder()
                        .setTaskQueue(TASK_QUEUE)
                        .setWorkflowId(workflowId)
                        .build());
    }

    @Test
    @DisplayName("문제 1 — 정상 주문이 COMPLETED 를 반환한다")
    void 문제1_정상_주문() {
        when(payment.charge("2001", 39000L)).thenReturn("PAY-1111");
        when(inventory.reserve("2001", "SKU-A", 2)).thenReturn("RSV-2222");
        when(shipping.requestShipment(eq("2001"), anyString())).thenReturn("SHIP-3333");

        testEnv.start();

        String result = stub("order-2001").processOrder(req("2001"));

        assertThat(result).isEqualTo("order-2001 COMPLETED");
        verify(notification).notifyCustomer("2001", "주문이 완료되었습니다");
    }

    // -----------------------------------------------------------------
    // 문제 2 — 시간 스킵
    //
    // 30일을 기다리는 워크플로우를 2초 미만에 통과시키세요.
    // 주의: Thread.sleep 으로는 절대 통과할 수 없습니다.
    //       Practice.ReviewReminderWorkflowImpl 을 등록해서 쓰세요.
    // -----------------------------------------------------------------
    @Test
    @DisplayName("문제 2 — 30일 대기 워크플로우가 2초 미만에 끝난다")
    void 문제2_시간_스킵() {
        // TODO: 여기에 작성 — worker 에 Practice.ReviewReminderWorkflowImpl 등록
        // 힌트: worker.registerWorkflowImplementationTypes(...)

        testEnv.start();

        // TODO: 여기에 작성 — ReviewReminderWorkflow 스텁을 만들고 remind("2002") 호출
        long before = System.currentTimeMillis();
        String result = null;   // TODO: 여기에 작성
        long wallClock = System.currentTimeMillis() - before;

        assertThat(result).isEqualTo("2002 REMINDED");
        assertThat(wallClock).isLessThan(2000);
    }

    // -----------------------------------------------------------------
    // 문제 3 — 액티비티 mock 등록 실패 고치기
    //
    // 아래 메서드는 "일부러 실패하는" 코드입니다.
    // ① 먼저 그대로 실행해서 어떤 예외가 나오는지 눈으로 확인하세요.
    //    java.lang.IllegalArgumentException: Interface annotated with @ActivityInterface
    //      can't be registered as an activity implementation: interface ...PaymentActivity
    // ② 그다음 TODO 자리를 채워 정상 등록되게 고치세요.
    // -----------------------------------------------------------------
    @Test
    @DisplayName("문제 3 — mock 액티비티 등록이 실패하지 않게 고친다")
    void 문제3_mock_등록() {
        TestWorkflowEnvironment env = TestWorkflowEnvironment.newInstance();
        Worker w = env.newWorker("EX3_QUEUE");

        // ① 아래 줄을 그대로 두고 한 번 실행해 보세요 (실패합니다)
        // w.registerActivitiesImplementations(mock(PaymentActivity.class));

        // ② TODO: 여기에 작성 — 위 줄을 고쳐 정상 등록되게 하세요
        //    힌트: Mockito 가 @ActivityInterface 어노테이션을 프록시에 복사합니다

        env.close();
        // 예외 없이 여기까지 오면 성공
        assertThat(true).isTrue();
    }

    // -----------------------------------------------------------------
    // 문제 4 — 재시도 검증
    //
    // 결제가 2번 실패한 뒤 3번째에 성공하도록 스텁하고,
    // charge 가 정확히 3번 호출되었는지 검증하세요.
    // -----------------------------------------------------------------
    @Test
    @DisplayName("문제 4 — 결제 2회 실패 후 성공, 호출 3회")
    void 문제4_재시도() {
        // TODO: 여기에 작성 — payment.charge("2004", 39000L) 를
        //       두 번 재시도 가능 실패 → 세 번째 성공("PAY-4444") 으로 스텁
        //       힌트: ApplicationFailure.newFailure(message, type)
        //             .thenThrow(...).thenThrow(...).thenReturn(...)

        when(inventory.reserve(any(), any(), anyInt())).thenReturn("RSV-2222");
        when(shipping.requestShipment(any(), any())).thenReturn("SHIP-3333");

        testEnv.start();

        assertThat(stub("order-2004").processOrder(req("2004")))
                .isEqualTo("order-2004 COMPLETED");

        // TODO: 여기에 작성 — charge 가 3번 호출되었는지 검증
        // 힌트: verify(mock, times(n))
    }

    // -----------------------------------------------------------------
    // 문제 5 — 비동기 시작 → 시그널 → 쿼리 → 결과 회수
    //
    // 아래 4단계를 채우세요. 마지막 결과 회수가 이 문제의 핵심입니다.
    // -----------------------------------------------------------------
    @Test
    @DisplayName("문제 5 — 시그널과 쿼리, 그리고 결과 회수")
    void 문제5_시그널_쿼리() {
        when(payment.charge(any(), anyLong())).thenReturn("PAY-1111");
        when(inventory.reserve(any(), any(), anyInt())).thenReturn("RSV-2222");

        testEnv.start();
        OrderWorkflow wf = stub("order-2005");

        // ① 비동기 시작 (주어짐)
        WorkflowClient.start(wf::processOrder, req("2005"));

        // ② TODO: 여기에 작성 — 가상 시간을 1초 밀어 워크플로우를 대기 지점까지 진행
        //    (Thread.sleep 금지)

        // ③ 쿼리로 진행 중 상태 확인
        assertThat(wf.getStatus()).isEqualTo("WAITING_SHIPMENT");

        // ④ TODO: 여기에 작성 — cancelRequested 시그널 전송 후 가상 시간 1초 밀기

        assertThat(wf.getStatus()).isEqualTo("CANCELED");

        // ⑤ TODO: 여기에 작성 — 워크플로우 결과를 String 으로 회수
        //    힌트: 타입 스텁으로는 getResult 를 못 부릅니다. 언타입 스텁으로 바꾸세요.
        String result = null;   // TODO: 여기에 작성

        assertThat(result).isEqualTo("order-2005 CANCELED");
    }

    // -----------------------------------------------------------------
    // 문제 6 — 보상 순서까지 검증하기
    //
    // 아래 테스트는 이미 통과합니다. 하지만 보상 순서가 뒤바뀐 구현에서도
    // 그대로 통과합니다(둘 다 호출되기만 하면 되므로).
    // 순서까지 검증하도록 고치세요.
    // -----------------------------------------------------------------
    @Test
    @DisplayName("문제 6 — 보상이 역순으로 실행되는지 검증한다")
    void 문제6_보상_역순() {
        when(payment.charge("2006", 39000L)).thenReturn("PAY-1111");
        when(inventory.reserve("2006", "SKU-A", 2)).thenReturn("RSV-2222");
        when(shipping.requestShipment(eq("2006"), anyString())).thenThrow(
                ApplicationFailure.newNonRetryableFailure("배송 불가 지역", "ShippingUnavailable"));

        testEnv.start();

        assertThatThrownBy(() -> stub("order-2006").processOrder(req("2006")))
                .isInstanceOf(WorkflowFailedException.class);

        // 아래 두 줄은 "호출 여부"만 봅니다 — 순서 버그를 못 잡습니다.
        verify(inventory).release("RSV-2222");
        verify(payment).refund("PAY-1111");

        // TODO: 여기에 작성 — 위 두 줄을 순서까지 검증하도록 바꾸세요.
        //       정방향: charge → reserve → requestShipment(실패)
        //       보상  : release → refund   (나중에 한 것부터)
        //       힌트: org.mockito.InOrder
    }

    // -----------------------------------------------------------------
    // 문제 7 — 리플레이 테스트
    //
    // src/test/resources/histories/ 의 모든 .json 을 도는
    // @ParameterizedTest 를 작성하세요.
    // 디렉터리가 비어 있으면 0건으로 조용히 통과하므로 가드도 함께 넣으세요.
    // -----------------------------------------------------------------

    // TODO: 여기에 작성 — static Stream<Path> histories() 메서드
    //       힌트: Exercise.class.getResource("/histories"), Files.list(dir)

    // TODO: 여기에 작성 — @Test 가드 : histories() 가 비어 있지 않은지 단언

    // TODO: 여기에 작성 — @ParameterizedTest + @MethodSource("histories")
    //       WorkflowReplayer.replayWorkflowExecution(
    //           Files.readString(history), OrderWorkflowImpl.class);
}

package com.example.order;

/*
 * Step 11 — 테스트 : Solution (정답 + 해설)
 *
 * 실행 방법
 *   ./gradlew test --tests 'com.example.order.Solution'
 *
 * 위치: src/test/java/com/example/order/Solution.java
 *
 * Exercise.java 를 직접 풀어 본 뒤에 여세요.
 * 각 정답 위에 "왜 그렇게 써야 하는가"를 설명하는 주석 블록이 붙어 있습니다.
 */

import io.temporal.api.common.v1.WorkflowExecution;
import io.temporal.client.WorkflowClient;
import io.temporal.client.WorkflowFailedException;
import io.temporal.client.WorkflowOptions;
import io.temporal.client.WorkflowStub;
import io.temporal.failure.ApplicationFailure;
import io.temporal.testing.TestWorkflowEnvironment;
import io.temporal.testing.WorkflowReplayer;
import io.temporal.worker.Worker;
import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.MethodSource;
import org.mockito.InOrder;

import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.time.Duration;
import java.util.stream.Stream;

import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatThrownBy;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.anyInt;
import static org.mockito.ArgumentMatchers.anyLong;
import static org.mockito.ArgumentMatchers.anyString;
import static org.mockito.ArgumentMatchers.eq;
import static org.mockito.Mockito.inOrder;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.never;
import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
import static org.mockito.Mockito.withSettings;

class Solution {

    static final String TASK_QUEUE = "ORDER_TASK_QUEUE";

    TestWorkflowEnvironment testEnv;
    Worker worker;
    WorkflowClient client;

    PaymentActivity payment;
    InventoryActivity inventory;
    ShippingActivity shipping;
    NotificationActivity notification;

    static OrderRequest req(String orderId) {
        return new OrderRequest(orderId, "C-77", "SKU-A", 2, 39000L, "서울시 강남구");
    }

    /*
     * ─────────────────────────────────────────────────────────────────
     * 정답 1 — TestWorkflowEnvironment 수동 구성
     * ─────────────────────────────────────────────────────────────────
     * 순서가 중요합니다.
     *
     *   ① TestWorkflowEnvironment.newInstance()
     *      → 이 시점에 인메모리 Temporal 서비스(temporal-test-server)가 프로세스 안에서 뜹니다.
     *        Docker 도, 7233 포트도, PostgreSQL 도 필요 없습니다.
     *   ② testEnv.newWorker(TASK_QUEUE)
     *      → Worker 를 만들되 아직 폴링은 시작하지 않습니다.
     *   ③ registerWorkflowImplementationTypes / registerActivitiesImplementations
     *      → 등록은 반드시 start() 전에 끝나야 합니다. start() 후 등록하면
     *        IllegalStateException: Worker has already been started 가 납니다.
     *   ④ testEnv.start()
     *      → 이제 폴러가 뜨고 Task 를 가져가기 시작합니다. 각 @Test 안에서 부릅니다
     *        (테스트마다 다른 워크플로우 타입을 등록해야 할 수 있으므로).
     *   ⑤ @AfterEach 의 testEnv.close()
     *      → 빠뜨리면 테스트마다 인메모리 서비스와 스레드풀이 누수됩니다.
     *        테스트 100개짜리 클래스에서 OutOfMemoryError 로 이어집니다.
     *
     * 액티비티 mock 은 activityMock() 헬퍼를 거칩니다 — 이유는 정답 3 참고.
     */
    static <T> T activityMock(Class<T> type) {
        return mock(type, withSettings().withoutAnnotations());
    }

    @BeforeEach
    void setUp() {
        testEnv = TestWorkflowEnvironment.newInstance();
        worker = testEnv.newWorker(TASK_QUEUE);
        client = testEnv.getWorkflowClient();

        worker.registerWorkflowImplementationTypes(OrderWorkflowImpl.class);

        payment = activityMock(PaymentActivity.class);
        inventory = activityMock(InventoryActivity.class);
        shipping = activityMock(ShippingActivity.class);
        notification = activityMock(NotificationActivity.class);
        worker.registerActivitiesImplementations(payment, inventory, shipping, notification);
    }

    @AfterEach
    void tearDown() {
        if (testEnv != null) {
            testEnv.close();
        }
    }

    OrderWorkflow stub(String workflowId) {
        return client.newWorkflowStub(OrderWorkflow.class,
                WorkflowOptions.newBuilder()
                        .setTaskQueue(TASK_QUEUE)
                        .setWorkflowId(workflowId)
                        .build());
    }

    @Test
    @DisplayName("정답 1 — 정상 주문이 COMPLETED 를 반환한다")
    void 정답1_정상_주문() {
        when(payment.charge("2001", 39000L)).thenReturn("PAY-1111");
        when(inventory.reserve("2001", "SKU-A", 2)).thenReturn("RSV-2222");
        when(shipping.requestShipment(eq("2001"), anyString())).thenReturn("SHIP-3333");

        testEnv.start();

        String result = stub("order-2001").processOrder(req("2001"));

        assertThat(result).isEqualTo("order-2001 COMPLETED");
        verify(notification).notifyCustomer("2001", "주문이 완료되었습니다");
    }

    /*
     * ─────────────────────────────────────────────────────────────────
     * 정답 2 — 시간 스킵
     * ─────────────────────────────────────────────────────────────────
     * 워크플로우 코드는 Workflow.sleep(Duration.ofDays(30)) 을 그대로 둡니다.
     * 테스트 쪽에서 아무것도 특별히 하지 않아도 30일이 즉시 지나갑니다.
     *
     * 발동 조건은 단 하나입니다.
     *   "등록된 모든 Worker 가 처리할 Task 가 없어 유휴 상태가 되면,
     *    가상 시계를 다음 타이머의 발화 시각으로 즉시 점프시킨다."
     *
     * 그래서 다음 두 가지가 이 테스트를 망칩니다.
     *
     *   (a) Thread.sleep(...) 를 넣는 것
     *       → 벽시계가 진짜로 흐릅니다. 가상 시계와 무관합니다.
     *         CI 가 그만큼 느려지고, 느린 머신에서는 대기 시간이 부족해 flaky 해집니다.
     *         대기가 필요하면 언제나 testEnv.sleep(Duration) 을 쓰세요 — 비용이 0입니다.
     *
     *   (b) TestEnvironmentOptions.newBuilder().setUseTimeskipping(false)
     *       → 시간 스킵을 끕니다. 이 옵션을 켠 채로 이 테스트를 돌리면
     *         정말로 30일을 기다립니다(사실상 CI 타임아웃).
     *         이 옵션은 "외부 스레드에서 시그널을 보내는 동안 시계가 점프해 버리면 곤란한"
     *         테스트에만 쓰고, 긴 대기가 있는 테스트와는 반드시 클래스를 분리하세요.
     *
     * wallClock 단언을 남겨 두는 이유: 누군가 나중에 시간 스킵을 끄거나
     * Thread.sleep 을 끼워 넣으면 이 테스트가 즉시 실패해 알려 줍니다.
     */
    @Test
    @DisplayName("정답 2 — 30일 대기 워크플로우가 2초 미만에 끝난다")
    void 정답2_시간_스킵() {
        worker.registerWorkflowImplementationTypes(Practice.ReviewReminderWorkflowImpl.class);
        testEnv.start();

        Practice.ReviewReminderWorkflow wf = client.newWorkflowStub(
                Practice.ReviewReminderWorkflow.class,
                WorkflowOptions.newBuilder()
                        .setTaskQueue(TASK_QUEUE)
                        .setWorkflowId("review-2002")
                        .build());

        long before = System.currentTimeMillis();
        String result = wf.remind("2002");
        long wallClock = System.currentTimeMillis() - before;

        assertThat(result).isEqualTo("2002 REMINDED");
        assertThat(wallClock).isLessThan(2000);
    }

    /*
     * ─────────────────────────────────────────────────────────────────
     * 정답 3 — withSettings().withoutAnnotations()
     * ─────────────────────────────────────────────────────────────────
     * 틀린 코드:
     *     w.registerActivitiesImplementations(mock(PaymentActivity.class));
     *
     * 실제 에러:
     *     java.lang.IllegalArgumentException: Interface annotated with @ActivityInterface
     *       can't be registered as an activity implementation:
     *       interface com.example.order.PaymentActivity
     *
     * 왜 이 메시지가 혼란스러운가:
     *   우리는 인터페이스를 등록한 적이 없습니다. mock 객체를 등록했습니다.
     *   그런데 Mockito 는 기본적으로 모킹 대상의 어노테이션을 **생성한 프록시 클래스에 복사**합니다.
     *   그래서 프록시 클래스에 @ActivityInterface 가 클래스 레벨로 붙어 버립니다.
     *
     *   Temporal SDK 의 registerActivitiesImplementations 는 등록된 객체의 클래스를 보고
     *   "@ActivityInterface 가 직접 붙어 있으면 그건 인터페이스(=계약)이지 구현이 아니다"
     *   라고 판단합니다. 정상적인 방어 로직인데, mock 이 그 조건에 걸린 것입니다.
     *
     * 해결:
     *     mock(PaymentActivity.class, withSettings().withoutAnnotations())
     *
     * 재발 방지:
     *   프로젝트 공용 테스트 유틸에 헬퍼를 하나 두고 팀 규칙으로 강제하세요.
     *     static <T> T activityMock(Class<T> type) {
     *         return mock(type, withSettings().withoutAnnotations());
     *     }
     *   @Mock 어노테이션 방식(MockitoExtension)도 같은 문제가 있으므로,
     *   액티비티만큼은 필드 주입 대신 이 헬퍼로 만드는 편이 안전합니다.
     */
    @Test
    @DisplayName("정답 3 — mock 액티비티가 정상 등록된다")
    void 정답3_mock_등록() {
        TestWorkflowEnvironment env = TestWorkflowEnvironment.newInstance();
        Worker w = env.newWorker("EX3_QUEUE");

        w.registerActivitiesImplementations(activityMock(PaymentActivity.class));

        env.close();
        assertThat(true).isTrue();
    }

    /*
     * ─────────────────────────────────────────────────────────────────
     * 정답 4 — 재시도 검증
     * ─────────────────────────────────────────────────────────────────
     * Mockito 의 연쇄 스텁 .thenThrow().thenThrow().thenReturn() 은
     * 호출 순서대로 다른 동작을 합니다. 즉 1회차 실패, 2회차 실패, 3회차 성공입니다.
     *
     * verify(payment, times(3)) 의 3 은 "재시도 2회 + 성공 1회"입니다.
     * 히스토리로 보면 이렇게 됩니다.
     *
     *    5 ActivityTaskScheduled  PaymentActivity.charge
     *    6 ActivityTaskStarted
     *    7 ActivityTaskFailed     (Transient)   ← 1회차
     *      ... RetryPolicy 에 따라 1초 대기 ...
     *    8 ActivityTaskStarted
     *    9 ActivityTaskFailed     (Transient)   ← 2회차
     *      ... 2초 대기 (backoffCoefficient=2.0) ...
     *   10 ActivityTaskStarted
     *   11 ActivityTaskCompleted  PAY-4444      ← 3회차
     *
     * 주목할 점: ActivityTaskScheduled 는 한 번만 생깁니다. 재시도는 같은 Scheduled
     * 이벤트 아래에서 Started/Failed 가 반복되는 형태입니다.
     *
     * 그리고 이 테스트는 백오프 1초 + 2초 = 3초를 기다려야 하는데도 0.5초에 끝납니다.
     * **재시도 백오프 대기에도 시간 스킵이 적용되기 때문**입니다. 이 덕분에
     * "maximumAttempts=10, maximumInterval=1분" 같은 현실적인 재시도 정책도
     * 테스트로 검증할 수 있습니다.
     */
    @Test
    @DisplayName("정답 4 — 결제 2회 실패 후 성공, 호출 3회")
    void 정답4_재시도() {
        when(payment.charge("2004", 39000L))
                .thenThrow(ApplicationFailure.newFailure("일시 오류", "Transient"))
                .thenThrow(ApplicationFailure.newFailure("일시 오류", "Transient"))
                .thenReturn("PAY-4444");
        when(inventory.reserve(any(), any(), anyInt())).thenReturn("RSV-2222");
        when(shipping.requestShipment(any(), any())).thenReturn("SHIP-3333");

        testEnv.start();

        assertThat(stub("order-2004").processOrder(req("2004")))
                .isEqualTo("order-2004 COMPLETED");

        verify(payment, times(3)).charge("2004", 39000L);
    }

    /*
     * ─────────────────────────────────────────────────────────────────
     * 정답 5 — 비동기 시작 · 시그널 · 쿼리 · 결과 회수
     * ─────────────────────────────────────────────────────────────────
     * ① 왜 비동기 시작인가
     *    wf.processOrder(req) 는 워크플로우 완료까지 블로킹합니다.
     *    그 상태로는 시그널을 보낼 스레드가 없습니다.
     *    WorkflowClient.start(wf::processOrder, req) 는 WorkflowExecution
     *    (workflowId + runId)만 돌려주고 즉시 반환합니다.
     *
     * ② 왜 testEnv.sleep 을 끼우는가
     *    시그널은 히스토리에 기록된 뒤 "다음 Workflow Task" 에서 처리됩니다.
     *    시그널 직후 곧바로 쿼리하면 아직 반영 전일 수 있습니다.
     *    testEnv.sleep(1초) 는 가상 시각만 밀 뿐이라 비용이 0이면서
     *    Workflow Task 를 한 번 돌게 만듭니다. Thread.sleep 과 달리 CI 를 느리게 하지 않습니다.
     *
     * ③ 결과 회수 — 이 문제의 핵심
     *    타입 스텁(OrderWorkflow)에는 getResult 메서드가 없습니다.
     *    WorkflowStub.fromTyped(wf) 로 언타입 스텁으로 바꾼 뒤
     *    getResult(String.class) 를 부릅니다.
     *    (같은 workflowId 로 client.newUntypedWorkflowStub("order-2005") 를
     *     새로 만들어도 되지만, fromTyped 가 runId 까지 정확히 물고 있어 안전합니다.)
     */
    @Test
    @DisplayName("정답 5 — 시그널과 쿼리, 그리고 결과 회수")
    void 정답5_시그널_쿼리() {
        when(payment.charge(any(), anyLong())).thenReturn("PAY-1111");
        when(inventory.reserve(any(), any(), anyInt())).thenReturn("RSV-2222");

        testEnv.start();
        OrderWorkflow wf = stub("order-2005");

        WorkflowExecution exec = WorkflowClient.start(wf::processOrder, req("2005"));
        assertThat(exec.getWorkflowId()).isEqualTo("order-2005");

        testEnv.sleep(Duration.ofSeconds(1));
        assertThat(wf.getStatus()).isEqualTo("WAITING_SHIPMENT");

        wf.cancelRequested("고객 변심");
        testEnv.sleep(Duration.ofSeconds(1));
        assertThat(wf.getStatus()).isEqualTo("CANCELED");

        String result = WorkflowStub.fromTyped(wf).getResult(String.class);
        assertThat(result).isEqualTo("order-2005 CANCELED");
    }

    /*
     * ─────────────────────────────────────────────────────────────────
     * 정답 6 — InOrder 로 보상 순서 검증
     * ─────────────────────────────────────────────────────────────────
     * 문제지에 있던 버전:
     *     verify(inventory).release("RSV-2222");
     *     verify(payment).refund("PAY-1111");
     *
     * 이건 "둘 다 한 번씩 호출되었다"만 봅니다. 보상 순서를 뒤집은 구현
     * (refund 먼저 → release 나중) 에서도 그대로 통과합니다.
     * 즉 실무에서 가장 위험한 버그(보상 순서 오류)를 못 잡습니다.
     *
     * 왜 순서가 중요한가:
     *   Saga 보상은 "실행의 역순"이어야 합니다. 결제 → 재고예약 → 배송 순으로 했다면
     *   보상은 재고해제 → 환불 순입니다. 순서가 뒤집히면
     *   "환불은 끝났는데 재고 해제 도중 장애" 같은 상황에서
     *   고객은 돈을 돌려받았는데 재고는 잠긴 채 남습니다.
     *
     * InOrder 버전으로 바꾸면, 보상 순서를 뒤집은 구현에서 이렇게 실패합니다.
     *
     *     org.mockito.exceptions.verification.VerificationInOrderFailure:
     *     Verification in order failure
     *     Wanted but not invoked:
     *     inventoryActivity.release("RSV-2222");
     *     Wanted anywhere AFTER following interaction:
     *     paymentActivity.refund("PAY-1111");
     *
     * 마지막 verify(shipping, never()).cancelShipment(...) 도 의미가 있습니다.
     * 배송은 애초에 성공한 적이 없으므로 배송 취소 보상은 호출되면 안 됩니다.
     * "성공하지 않은 단계는 보상하지 않는다"는 Saga 의 기본 규칙을 못박는 단언입니다.
     */
    @Test
    @DisplayName("정답 6 — 보상이 역순으로 실행된다")
    void 정답6_보상_역순() {
        when(payment.charge("2006", 39000L)).thenReturn("PAY-1111");
        when(inventory.reserve("2006", "SKU-A", 2)).thenReturn("RSV-2222");
        when(shipping.requestShipment(eq("2006"), anyString())).thenThrow(
                ApplicationFailure.newNonRetryableFailure("배송 불가 지역", "ShippingUnavailable"));

        testEnv.start();

        assertThatThrownBy(() -> stub("order-2006").processOrder(req("2006")))
                .isInstanceOf(WorkflowFailedException.class)
                .hasRootCauseMessage("배송 불가 지역");

        InOrder ord = inOrder(payment, inventory, shipping);
        ord.verify(payment).charge("2006", 39000L);
        ord.verify(inventory).reserve("2006", "SKU-A", 2);
        ord.verify(shipping).requestShipment(eq("2006"), anyString());
        ord.verify(inventory).release("RSV-2222");
        ord.verify(payment).refund("PAY-1111");

        verify(shipping, never()).cancelShipment(anyString());
    }

    /*
     * ─────────────────────────────────────────────────────────────────
     * 정답 7 — 리플레이 테스트
     * ─────────────────────────────────────────────────────────────────
     * @MethodSource 가 참조하는 메서드는 static 이어야 하고,
     * Stream / Iterable / 배열을 반환해야 합니다. 여기서는 Stream<Path> 입니다.
     *
     * Files.list 는 스트림을 닫아야 하므로 try-with-resources 로 감싸고
     * toList() 로 즉시 소비한 뒤 다시 스트림으로 만듭니다.
     * (그냥 return Files.list(dir) 하면 파일 핸들이 누수됩니다.)
     *
     * ★ 가드 테스트를 반드시 함께 두세요.
     *   히스토리 디렉터리가 비면 @ParameterizedTest 는 "0건 실행"으로 끝나고,
     *   JUnit 설정에 따라 조용히 통과합니다. 즉 **리플레이 검증이 사라진 줄도 모르고**
     *   CI 초록불을 보게 됩니다. 리플레이 테스트를 무력화하는 가장 흔한 방식입니다.
     *
     * ★ Step 12 로 이어지는 숙제
     *   히스토리는 Namespace 의 Retention Period 안에서만 조회할 수 있습니다.
     *   기본 72시간이므로, 3일 지난 워크플로우는 temporal workflow show 가 NotFound 입니다.
     *   덤프 스크립트를 매일 도는 크론에 넣거나 Archival 을 켜세요.
     *
     * ★ 왜 이 테스트가 대체 불가능한가
     *   위 정답 1~6 의 워크플로우 테스트는 전부 "새 히스토리를 새 코드로" 실행합니다.
     *   새 코드끼리는 언제나 일관되므로, Workflow.getVersion() 가드를 빼먹어도 통과합니다.
     *   운영에 이미 떠 있는 워크플로우와의 호환성은 오직 이 테스트만 검증합니다.
     */
    static Stream<Path> histories() throws Exception {
        var url = Solution.class.getResource("/histories");
        if (url == null) {
            return Stream.empty();
        }
        Path dir = Paths.get(url.toURI());
        try (Stream<Path> s = Files.list(dir)) {
            return s.filter(p -> p.toString().endsWith(".json")).toList().stream();
        }
    }

    @Test
    @DisplayName("정답 7-a — 히스토리 리소스가 비어 있지 않다 (가드)")
    void 정답7_가드() throws Exception {
        assertThat(histories().toList())
                .as("src/test/resources/histories/*.json 이 비면 리플레이 검증이 무력화됩니다")
                .isNotEmpty();
    }

    @ParameterizedTest(name = "replay {0}")
    @MethodSource("histories")
    @DisplayName("정답 7-b — 모든 운영 히스토리가 현재 코드로 리플레이된다")
    void 정답7_리플레이(Path history) throws Exception {
        WorkflowReplayer.replayWorkflowExecution(
                Files.readString(history), OrderWorkflowImpl.class);
    }
}