Repository navigation
Expand file tree
/
Copy pathWorkerQuotaTest.java
More file actions
137 lines (125 loc) · 6.8 KB
/
Copy pathWorkerQuotaTest.java
File metadata and controls
137 lines (125 loc) · 6.8 KB
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
package dev.jinhyeon.notificationlab.worker;
import dev.jinhyeon.notificationlab.ratelimit.RedisRateLimiter.Decision;
import dev.jinhyeon.notificationlab.ratelimit.RedisRateLimiter.Outcome;
import io.micrometer.core.instrument.simple.SimpleMeterRegistry;
import java.time.Duration;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicBoolean;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.function.Supplier;
import org.junit.jupiter.api.Test;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatThrownBy;
import static org.awaitility.Awaitility.await;
class WorkerQuotaTest {
@Test
void recoveryOnlyDefersKnownTransientFailuresAndAcquiresOncePerCall() {
for (var reason : dev.jinhyeon.notificationlab.ratelimit.RedisRateLimiter.FailureReason.values()) {
if (reason == dev.jinhyeon.notificationlab.ratelimit.RedisRateLimiter.FailureReason.NONE) continue;
var calls = new AtomicInteger();
var quota = new WorkerQuota(() -> { calls.incrementAndGet(); return new Decision(Outcome.UNAVAILABLE, 0, reason); },
100, true, true, new SimpleMeterRegistry());
if (reason.retryable()) assertThatThrownBy(quota::awaitPermit).isInstanceOf(WorkerQuota.QuotaUnavailableDeferred.class);
else assertThatThrownBy(quota::awaitPermit).isNotInstanceOf(WorkerQuota.QuotaUnavailableDeferred.class);
assertThat(calls.get()).isEqualTo(1);
}
}
@Test
void pauseModeChecksOnceAndReturnsOnlyABoundedSafeDelay() {
var calls = new AtomicInteger();
var registry = new SimpleMeterRegistry();
var quota = new WorkerQuota(() -> { calls.incrementAndGet(); return new Decision(Outcome.LIMITED, Long.MAX_VALUE); },
1, true, registry);
assertThatThrownBy(quota::awaitPermit).isInstanceOfSatisfying(WorkerQuota.QuotaDeferred.class,
deferred -> assertThat(deferred.delayMs()).isEqualTo(60000));
assertThat(calls.get()).isEqualTo(1);
assertThat(registry.get("notification.worker.quota.waiting").gauge().value()).isZero();
assertThat(new WorkerQuota.QuotaDeferred(0).delayMs()).isEqualTo(100);
}
@Test
void pauseModeNeverDefersRedisErrorsOrShutdown() {
var quota = new WorkerQuota(() -> new Decision(Outcome.UNAVAILABLE, 0), 100, true, new SimpleMeterRegistry());
assertThatThrownBy(quota::awaitPermit).isNotInstanceOf(WorkerQuota.QuotaDeferred.class).hasMessageContaining("unavailable");
quota.stopAdmission();
assertThatThrownBy(quota::awaitPermit).hasMessageContaining("stopping");
}
@Test
void retriesLimitedDecisionAndReleasesWaitingCountAfterPermit() {
var calls = new AtomicInteger();
var registry = new SimpleMeterRegistry();
var quota = new WorkerQuota(() -> new Decision(calls.incrementAndGet() == 3 ? Outcome.ALLOWED : Outcome.LIMITED, 1), 1000, registry);
quota.awaitPermit();
assertThat(calls.get()).isEqualTo(3);
assertThat(registry.get("notification.worker.quota.waiting").gauge().value()).isZero();
}
@Test
void timeoutDoesNotTreatAdvisoryRetryDelayAsPermitOrPollContinuously() {
var calls = new AtomicInteger();
var quota = new WorkerQuota(() -> { calls.incrementAndGet(); return new Decision(Outcome.LIMITED, 10000); },
100, new SimpleMeterRegistry());
assertThatThrownBy(quota::awaitPermit).hasMessageContaining("timeout");
assertThat(calls.get()).isEqualTo(1);
}
@Test
void unavailableStopsWithoutAutomaticRetry() {
var calls = new AtomicInteger();
var quota = new WorkerQuota(() -> { calls.incrementAndGet(); return new Decision(Outcome.UNAVAILABLE, 0); },
1000, new SimpleMeterRegistry());
assertThatThrownBy(quota::awaitPermit).hasMessageContaining("unavailable");
assertThat(calls.get()).isEqualTo(1);
}
@Test
void permitArrivingAfterWaitBudgetIsDiscarded() {
var registry = new SimpleMeterRegistry();
var quota = new WorkerQuota(() -> {
try { TimeUnit.MILLISECONDS.sleep(75); }
catch (InterruptedException interrupted) { Thread.currentThread().interrupt(); }
return new Decision(Outcome.ALLOWED, 0);
}, 25, registry);
assertThatThrownBy(quota::awaitPermit).hasMessageContaining("timeout");
assertThat(registry.get("notification.worker.quota.waiting").gauge().value()).isZero();
assertThat(registry.get("notification.worker.quota.rejected").tag("reason", "timeout").counter().count()).isEqualTo(1);
}
@Test
void shutdownWakesWaitingCallerWithoutAnotherAcquisition() throws Exception {
var calls = new AtomicInteger();
var quota = new WorkerQuota(() -> { calls.incrementAndGet(); return new Decision(Outcome.LIMITED, 5000); },
5000, new SimpleMeterRegistry());
try (var executor = Executors.newSingleThreadExecutor()) {
var work = executor.submit(() -> assertThatThrownBy(quota::awaitPermit).hasMessageContaining("stopping"));
await().atMost(Duration.ofSeconds(1)).until(() -> calls.get() == 1);
quota.stopAdmission();
work.get(1, TimeUnit.SECONDS);
assertThat(calls.get()).isEqualTo(1);
assertThatThrownBy(quota::awaitPermit).hasMessageContaining("stopping");
}
}
@Test
void interruptionPreservesFlagAndStopsFurtherAcquisitions() throws Exception {
var calls = new AtomicInteger();
var preserved = new AtomicBoolean();
var quota = new WorkerQuota(() -> { calls.incrementAndGet(); return new Decision(Outcome.LIMITED, 5000); },
5000, new SimpleMeterRegistry());
var thread = new Thread(() -> {
assertThatThrownBy(quota::awaitPermit).hasMessageContaining("interrupted");
preserved.set(Thread.currentThread().isInterrupted());
});
thread.start();
try {
await().atMost(Duration.ofSeconds(1)).until(() -> calls.get() == 1);
thread.interrupt(); thread.join(1000);
assertThat(thread.isAlive()).isFalse();
assertThat(preserved).isTrue();
assertThat(calls.get()).isEqualTo(1);
} finally { thread.interrupt(); }
}
@Test
void absentClientBypassesQuotaAndInvalidWaitBoundsAreRejected() {
var quota = new WorkerQuota((Supplier<Decision>) null, 2000, new SimpleMeterRegistry());
assertThat(quota.enabled()).isFalse();
quota.awaitPermit();
for (int timeout : new int[]{0, 5001}) assertThatThrownBy(() -> new WorkerQuota((Supplier<Decision>) null,
timeout, new SimpleMeterRegistry())).isInstanceOf(IllegalArgumentException.class);
}
}