147 lines
4.7 KiB
Elixir
147 lines
4.7 KiB
Elixir
defmodule Microwaveprop.Weather.IemRateLimiterTest do
|
|
use ExUnit.Case, async: false
|
|
|
|
alias Microwaveprop.Weather.IemRateLimiter
|
|
|
|
# Each test starts an isolated limiter under a unique name so the
|
|
# app-level IemRateLimiter (started by the application supervisor
|
|
# with interval_ms: 0) doesn't conflict.
|
|
defp start_limiter(interval_ms) do
|
|
name = Module.safe_concat([IemRateLimiter, to_string(System.unique_integer([:positive]))])
|
|
start_supervised!({IemRateLimiter, interval_ms: interval_ms, name: name})
|
|
name
|
|
end
|
|
|
|
describe "acquire/1" do
|
|
test "first call returns immediately when the limiter is idle" do
|
|
name = start_limiter(50)
|
|
|
|
{elapsed_ms, :ok} = :timer.tc(fn -> IemRateLimiter.acquire(name) end, :millisecond)
|
|
|
|
# Allow a generous upper bound for scheduling jitter; the point is that
|
|
# no rate-limit sleep was applied on the first call.
|
|
assert elapsed_ms < 20
|
|
end
|
|
|
|
test "serial calls are spaced at least interval_ms apart" do
|
|
name = start_limiter(50)
|
|
|
|
{elapsed_ms, _} =
|
|
:timer.tc(
|
|
fn ->
|
|
IemRateLimiter.acquire(name)
|
|
IemRateLimiter.acquire(name)
|
|
IemRateLimiter.acquire(name)
|
|
end,
|
|
:millisecond
|
|
)
|
|
|
|
# Three acquires at 50ms gap → floor at 100ms (gap after call 1 and 2).
|
|
assert elapsed_ms >= 100
|
|
end
|
|
|
|
test "concurrent callers each get a non-overlapping slot" do
|
|
name = start_limiter(50)
|
|
parent = self()
|
|
|
|
for _ <- 1..4 do
|
|
spawn(fn ->
|
|
IemRateLimiter.acquire(name)
|
|
send(parent, {:acquired, System.monotonic_time(:millisecond)})
|
|
end)
|
|
end
|
|
|
|
timestamps =
|
|
for _ <- 1..4 do
|
|
assert_receive {:acquired, ts}
|
|
ts
|
|
end
|
|
|
|
sorted = Enum.sort(timestamps)
|
|
gaps = sorted |> Enum.zip(tl(sorted)) |> Enum.map(fn {a, b} -> b - a end)
|
|
min_gap = Enum.min(gaps)
|
|
# Allow 5ms scheduler jitter on the lower bound.
|
|
assert min_gap >= 45
|
|
end
|
|
|
|
test "interval_ms: 0 is a no-op" do
|
|
name = start_limiter(0)
|
|
|
|
{elapsed_ms, _} =
|
|
:timer.tc(
|
|
fn ->
|
|
for _ <- 1..10, do: IemRateLimiter.acquire(name)
|
|
end,
|
|
:millisecond
|
|
)
|
|
|
|
assert elapsed_ms < 20
|
|
end
|
|
end
|
|
|
|
describe "adaptive gap" do
|
|
defp start_adaptive(base, max) do
|
|
name = Module.safe_concat([IemRateLimiter, :adaptive, to_string(System.unique_integer([:positive]))])
|
|
start_supervised!({IemRateLimiter, interval_ms: base, max_interval_ms: max, name: name})
|
|
name
|
|
end
|
|
|
|
test "signal_429 widens the current gap" do
|
|
name = start_adaptive(50, 500)
|
|
IemRateLimiter.signal_429(name)
|
|
IemRateLimiter.signal_429(name)
|
|
gap = IemRateLimiter.current_interval_ms(name)
|
|
assert gap > 50
|
|
assert gap <= 500
|
|
end
|
|
|
|
test "signal_success decays the gap back toward base" do
|
|
name = start_adaptive(50, 500)
|
|
# Inflate the gap
|
|
Enum.each(1..5, fn _ -> IemRateLimiter.signal_429(name) end)
|
|
high_gap = IemRateLimiter.current_interval_ms(name)
|
|
assert high_gap > 50
|
|
|
|
# Successes drive it back down
|
|
Enum.each(1..20, fn _ -> IemRateLimiter.signal_success(name) end)
|
|
low_gap = IemRateLimiter.current_interval_ms(name)
|
|
|
|
assert low_gap < high_gap
|
|
# But never below the configured base.
|
|
assert low_gap >= 50
|
|
end
|
|
|
|
test "max_interval_ms is a hard ceiling" do
|
|
name = start_adaptive(100, 400)
|
|
Enum.each(1..50, fn _ -> IemRateLimiter.signal_429(name) end)
|
|
assert IemRateLimiter.current_interval_ms(name) == 400
|
|
end
|
|
end
|
|
|
|
describe "unregistered server paths" do
|
|
test "acquire/1 with a live PID succeeds via the is_pid clause" do
|
|
name = Module.safe_concat([IemRateLimiter, :pid_test, to_string(System.unique_integer([:positive]))])
|
|
pid = start_supervised!({IemRateLimiter, interval_ms: 0, name: name})
|
|
assert IemRateLimiter.acquire(pid) == :ok
|
|
assert IemRateLimiter.signal_429(pid) == :ok
|
|
assert IemRateLimiter.signal_success(pid) == :ok
|
|
assert IemRateLimiter.current_interval_ms(pid) == 0
|
|
end
|
|
|
|
test "acquire/1 returns :ok when server is not registered" do
|
|
assert IemRateLimiter.acquire(:nonexistent_limiter_12345) == :ok
|
|
end
|
|
|
|
test "signal_429/1 returns :ok when server is not registered" do
|
|
assert IemRateLimiter.signal_429(:nonexistent_limiter_12345) == :ok
|
|
end
|
|
|
|
test "signal_success/1 returns :ok when server is not registered" do
|
|
assert IemRateLimiter.signal_success(:nonexistent_limiter_12345) == :ok
|
|
end
|
|
|
|
test "current_interval_ms/1 returns 0 when server is not registered" do
|
|
assert IemRateLimiter.current_interval_ms(:nonexistent_limiter_12345) == 0
|
|
end
|
|
end
|
|
end
|