149 lines
5.3 KiB
Go
149 lines
5.3 KiB
Go
package main
|
|
|
|
import (
|
|
"context"
|
|
"errors"
|
|
"fmt"
|
|
"net"
|
|
"sync/atomic"
|
|
"testing"
|
|
"time"
|
|
)
|
|
|
|
type timeoutErr struct{}
|
|
|
|
func (timeoutErr) Error() string { return "i/o timeout" }
|
|
func (timeoutErr) Timeout() bool { return true }
|
|
func (timeoutErr) Temporary() bool { return true }
|
|
|
|
var _ net.Error = timeoutErr{}
|
|
|
|
func TestClassify(t *testing.T) {
|
|
for _, c := range []struct {
|
|
res result
|
|
want string
|
|
}{
|
|
{result{status: 201, instance: "a"}, "ok"},
|
|
{result{status: 200, instance: "a"}, "ok"},
|
|
{result{status: 409, instance: "a"}, "http_409"},
|
|
{result{status: 503, instance: "a"}, "http_503"},
|
|
{result{status: 503}, "http_503_lb"},
|
|
{result{status: 502}, "http_502_lb"},
|
|
{result{err: context.DeadlineExceeded}, "client_timeout"},
|
|
{result{err: fmt.Errorf("post: %w", timeoutErr{})}, "client_timeout"},
|
|
{result{err: errors.New("connection refused")}, "conn_error"},
|
|
} {
|
|
if got := classify(c.res); got != c.want {
|
|
t.Errorf("classify(%+v) = %q, want %q", c.res, got, c.want)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestPercentileNearestRank(t *testing.T) {
|
|
ms := func(v ...int) []time.Duration {
|
|
out := make([]time.Duration, len(v))
|
|
for i, x := range v {
|
|
out[i] = time.Duration(x) * time.Millisecond
|
|
}
|
|
return out
|
|
}
|
|
sorted := ms(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
|
|
for p, want := range map[float64]time.Duration{50: 5 * time.Millisecond, 95: 10 * time.Millisecond, 99: 10 * time.Millisecond, 10: time.Millisecond} {
|
|
if got := percentile(sorted, p); got != want {
|
|
t.Errorf("p%v = %v, want %v", p, got, want)
|
|
}
|
|
}
|
|
if got := percentile(nil, 99); got != 0 {
|
|
t.Errorf("empty p99 = %v, want 0", got)
|
|
}
|
|
}
|
|
|
|
// A step is invalid when the generator itself fell behind its schedule: the
|
|
// system was then offered less than the nominal rate.
|
|
func TestStepSummaryValidityAndErrorShare(t *testing.T) {
|
|
samples := []sample{
|
|
{class: "ok", latency: 10 * time.Millisecond, lag: time.Millisecond},
|
|
{class: "ok", latency: 20 * time.Millisecond, lag: time.Millisecond},
|
|
{class: "client_timeout", latency: 2 * time.Second, lag: time.Millisecond},
|
|
{class: "http_503_lb", latency: time.Millisecond, lag: time.Millisecond},
|
|
}
|
|
s := summarize(4, time.Second, samples)
|
|
if s.Sent != 4 || s.OK != 2 || s.OKRPS != 2 || s.ErrorShare != 0.5 || !s.Valid {
|
|
t.Fatalf("summary = %+v", s)
|
|
}
|
|
if s.Classes["client_timeout"] != 1 || s.Classes["http_503_lb"] != 1 {
|
|
t.Fatalf("classes = %v", s.Classes)
|
|
}
|
|
if s.P99Ms != 20 {
|
|
t.Fatalf("p99 of successful requests = %v ms, want 20", s.P99Ms)
|
|
}
|
|
samples[0].lag = 50 * time.Millisecond
|
|
samples[1].lag = 50 * time.Millisecond
|
|
if s := summarize(4, time.Second, samples); s.Valid {
|
|
t.Fatalf("lagging generator marked valid: %+v", s)
|
|
}
|
|
}
|
|
|
|
// Open loop: requests leave on schedule even when responses are slow. A
|
|
// closed loop with one worker would send only a handful here.
|
|
func TestOpenLoopDoesNotWaitForResponses(t *testing.T) {
|
|
var fired atomic.Int32
|
|
start := time.Now()
|
|
openLoop(context.Background(), 50, time.Second, func(time.Time) func() {
|
|
return func() {
|
|
fired.Add(1)
|
|
time.Sleep(200 * time.Millisecond)
|
|
}
|
|
})
|
|
if n := fired.Load(); n < 45 || n > 50 {
|
|
t.Fatalf("fired %d requests in 1 s at 50/s, want about 50", n)
|
|
}
|
|
// About 1.2 s; the bound leaves room for -race on a shared CI runner and
|
|
// still fails a closed loop, which would need 50 x 200 ms = 10 s.
|
|
if took := time.Since(start); took > 2500*time.Millisecond {
|
|
t.Fatalf("open loop took %v, want about 1.2 s", took)
|
|
}
|
|
}
|
|
|
|
func TestStepPassesOnlyWithinTheObjective(t *testing.T) {
|
|
ok := func(latency, lag time.Duration) sample {
|
|
return sample{class: "ok", latency: latency, lag: lag}
|
|
}
|
|
fast := []sample{ok(10*time.Millisecond, time.Millisecond), ok(20*time.Millisecond, time.Millisecond)}
|
|
if s := summarize(2, time.Second, fast); !s.Passed {
|
|
t.Fatalf("fast clean step must pass: %+v", s)
|
|
}
|
|
slow := []sample{ok(10*time.Millisecond, time.Millisecond), ok(600*time.Millisecond, time.Millisecond)}
|
|
if s := summarize(2, time.Second, slow); s.Passed {
|
|
t.Fatalf("p99 above 500 ms must fail: %+v", s)
|
|
}
|
|
failing := append(fast, sample{class: "http_503_lb", lag: time.Millisecond})
|
|
if s := summarize(3, time.Second, failing); s.Passed {
|
|
t.Fatalf("errors above 1 %% must fail: %+v", s)
|
|
}
|
|
late := []sample{ok(10*time.Millisecond, 50*time.Millisecond), ok(10*time.Millisecond, 50*time.Millisecond)}
|
|
if s := summarize(2, time.Second, late); s.Passed {
|
|
t.Fatalf("an invalid step must fail: %+v", s)
|
|
}
|
|
}
|
|
|
|
// The ladder stops when the system leaves the objective, not when the
|
|
// generator alone fell behind: a later step may still be valid and pass.
|
|
func TestOnlyTheSystemEndsTheLadder(t *testing.T) {
|
|
ok := func(latency, lag time.Duration) sample {
|
|
return sample{class: "ok", latency: latency, lag: lag}
|
|
}
|
|
late := []sample{ok(10*time.Millisecond, 50*time.Millisecond), ok(10*time.Millisecond, 50*time.Millisecond)}
|
|
if s := summarize(2, time.Second, late); s.overloaded() {
|
|
t.Fatalf("a lagging generator must not end the ladder: %+v", s)
|
|
}
|
|
slow := []sample{ok(10*time.Millisecond, time.Millisecond), ok(600*time.Millisecond, time.Millisecond)}
|
|
if s := summarize(2, time.Second, slow); !s.overloaded() {
|
|
t.Fatalf("p99 above 500 ms must end the ladder: %+v", s)
|
|
}
|
|
failing := []sample{ok(10*time.Millisecond, time.Millisecond), {class: "client_timeout", lag: time.Millisecond}}
|
|
if s := summarize(2, time.Second, failing); !s.overloaded() {
|
|
t.Fatalf("errors above 1 %% must end the ladder: %+v", s)
|
|
}
|
|
}
|