test(messaging): 대기 허가 테스트가 실행 순서에 따라 갈리지 않게 한다

문제: `MessagingAdmissionControllerTest.aWaitingCallerIsAdmittedOnceAPermitIsReturned`가
desktop 부하가 높을 때 가끔 실패한다(구조 정리 게이트에서 부하 7에 한 번,
이번에 부하 24~27에서 20번 중 한 번).

원인: 이 테스트는 대상 하나(`order.created`)로 허가 하나를 쥔 뒤, 같은 대상으로
대기자를 띄우고 곧바로 허가를 돌려준다. 그런데 대상별 상한(2인자 생성자에서는
프로세스 상한과 같은 1)이 나중에 더해지면서 같은 대상의 두 번째 호출은
프로세스 허가를 기다리지 않고 바로 `DESTINATION_IN_FLIGHT_LIMIT_EXCEEDED`로
거절된다. 그래서 테스트는 main 스레드의 `complete`가 대기자의 `admit`보다
먼저 돌 때만 통과한다(그때는 대기자가 기다릴 일이 없다). 부하가 높아 대기자가
먼저 돌면 거절되고 in-flight가 0이 되어 실패한다. 테스트 이름이 말하는
"기다리던 호출이 허가를 받는다"는 어느 쪽에서도 시험되지 않았다.

고친 방법:
- 대기자를 다른 대상으로 보내 프로세스 허가만 다투게 한다.
- 대기자가 실제로 limiter의 bounded wait에 들어가(TIMED_WAITING) 줄을 선 뒤에
  허가를 돌려준다. 순서를 테스트가 정하므로 스레드 일정에 기대지 않는다.
- 대기자의 거절을 잡아 단언한다(전에는 스레드 밖으로 사라졌다).
- 대기 상한을 2초에서 30초로 늘린다. 부하가 높을 때 상한이 먼저 끝나 생기는
  다른 갈림을 막는다. 대기자는 허가를 받는 즉시 끝나므로 평소 시간은 같다.

버린 대안: 같은 대상을 두고 3인자 생성자로 대상별 상한을 2로 주기. 그러면
대상별 상한 1·프로세스 상한 1 조합(2인자 생성자 기본)의 동작을 시험에서
숨긴다. 그 동작 자체를 바꾸는 것은 이 변경의 범위가 아니다.

위험·한계: 2인자 생성자 Javadoc은 "only ceiling is the process-wide one"이라
하지만 한 대상이 프로세스 허가를 모두 쥐면 같은 대상의 호출은 기다리지 않고
바로 거절된다. 운영 조립(`MessagingPublishConfiguration`)은 3인자 생성자로
대상별 상한(기본 64)을 따로 주므로 영향이 없다. 문서와 동작 중 무엇을 맞출지는
별도로 남긴다.

검증(desktop, `--no-build-cache`):
- RED: 새 테스트 모양에 대기자를 같은 대상으로 두면 매번 실패한다. 메시지
  "the waiter must be queued on the permit before it is returned (refused:
  MessageBackpressureException: order.created already holds its 1 in-flight
  publishes ...) expected: TIMED_WAITING but was: TERMINATED".
- GREEN: `:messaging:messaging-policy:check :messaging:messaging-policy:testQualityCheck`
  rc=0, 테스트 43 실패 0.
- 부하: busy loop 24개(12코어)를 건 채 이 클래스를 `--rerun`으로 20번 연속
  돌렸다. 고친 트리 20/20 통과(1분 부하 8→24). 같은 부하에서 고치기 전 트리는
  20번 중 1번 실패(8번째, "expected: 1 but was: 0", 대기자가 위 거절을 받음).
  로그 desktop `~/i1-layout-docs-logs/flaky/`.
This commit is contained in:
DongHyeonka
2026-11-07 15:14:21 +09:00
parent ae54f312a0
commit 5ab1b4182c
@@ -7,11 +7,14 @@ import dev.caskeleton.messaging.api.error.MessageBackpressureException;
import dev.caskeleton.messaging.api.error.MessageTooLargeException;
import java.time.Duration;
import java.util.List;
import java.util.concurrent.atomic.AtomicReference;
import org.junit.jupiter.api.Test;
class MessagingAdmissionControllerTest {
private static final String DESTINATION = "order.created";
private static final String OTHER_DESTINATION = "invoice.issued";
private static final Duration WAITER_BOUND = Duration.ofSeconds(30);
private static MessagingAdmissionController controller(int limit) {
return new MessagingAdmissionController(
@@ -182,16 +185,49 @@ class MessagingAdmissionControllerTest {
void aWaitingCallerIsAdmittedOnceAPermitIsReturned() throws InterruptedException {
MessagingAdmissionController controller =
new MessagingAdmissionController(
new PayloadLimitGuard(PayloadPolicy.defaults()),
new InFlightLimiter(1, Duration.ofSeconds(2)));
new PayloadLimitGuard(PayloadPolicy.defaults()), new InFlightLimiter(1, WAITER_BOUND));
controller.admit(DESTINATION, 100);
AtomicReference<RuntimeException> refused = new AtomicReference<>();
// Another destination, so only the process-wide permit is contested. A second publish to
// DESTINATION is refused at once by its own ceiling (equal to the process limit here) and
// never waits.
Thread waiter =
new Thread(
() -> {
try {
controller.admit(OTHER_DESTINATION, 100);
} catch (RuntimeException refusal) {
refused.set(refusal);
}
});
Thread waiter = new Thread(() -> controller.admit(DESTINATION, 100));
waiter.start();
awaitQueuedOnAPermit(waiter, refused);
controller.complete(DESTINATION);
waiter.join(Duration.ofSeconds(5).toMillis());
waiter.join(WAITER_BOUND.toMillis());
assertThat(refused.get()).as("the waiter was refused instead of admitted").isNull();
assertThat(waiter.isAlive()).isFalse();
assertThat(controller.inFlight()).isEqualTo(1);
assertThat(controller.inFlight(OTHER_DESTINATION)).isEqualTo(1);
}
/**
* Waits until {@code waiter} is parked in the limiter's bounded wait, so the permit is returned
* to a caller that is already queued rather than to one that has not arrived yet.
*/
private static void awaitQueuedOnAPermit(Thread waiter, AtomicReference<RuntimeException> refused)
throws InterruptedException {
long deadline = System.nanoTime() + WAITER_BOUND.toNanos();
while (waiter.getState() != Thread.State.TIMED_WAITING
&& waiter.isAlive()
&& System.nanoTime() < deadline) {
Thread.sleep(1);
}
assertThat(waiter.getState())
.as(
"the waiter must be queued on the permit before it is returned (refused: %s)",
refused.get())
.isEqualTo(Thread.State.TIMED_WAITING);
}
}