Ilia Denisov
596 lines
16 KiB
Go
596 lines
16 KiB
Go
package http
|
|
|
|
import (
|
|
"context"
|
|
"errors"
|
|
"galaxy/connector"
|
|
"io"
|
|
"net"
|
|
stdhttp "net/http"
|
|
"net/http/httptest"
|
|
"net/url"
|
|
"reflect"
|
|
"strings"
|
|
"testing"
|
|
"time"
|
|
)
|
|
|
|
// checkConnectionCase describes one CheckConnection behavior scenario.
|
|
type checkConnectionCase struct {
|
|
name string
|
|
setup func(t *testing.T) (*httpConnector, <-chan string)
|
|
want bool
|
|
wantPath string
|
|
}
|
|
|
|
// checkVersionCase describes one CheckVersion behavior scenario.
|
|
type checkVersionCase struct {
|
|
name string
|
|
setup func(t *testing.T) (*httpConnector, <-chan string)
|
|
want []connector.VersionInfo
|
|
wantErr bool
|
|
wantPath string
|
|
}
|
|
|
|
// TestCheckConnection verifies backend reachability probe behavior.
|
|
func TestCheckConnection(t *testing.T) {
|
|
tests := []checkConnectionCase{
|
|
{
|
|
name: "status 200 returns true",
|
|
setup: func(t *testing.T) (*httpConnector, <-chan string) {
|
|
return newServerConnector(t, context.Background(), stdhttp.StatusOK, "")
|
|
},
|
|
want: true,
|
|
wantPath: "/api/v1/status",
|
|
},
|
|
{
|
|
name: "non-2xx status returns true",
|
|
setup: func(t *testing.T) (*httpConnector, <-chan string) {
|
|
return newServerConnector(t, context.Background(), stdhttp.StatusServiceUnavailable, "")
|
|
},
|
|
want: true,
|
|
wantPath: "/api/v1/status",
|
|
},
|
|
{
|
|
name: "canceled context returns false",
|
|
setup: func(t *testing.T) (*httpConnector, <-chan string) {
|
|
ctx, cancel := context.WithCancel(context.Background())
|
|
cancel()
|
|
conn, err := NewHttpConnector(ctx, "http://127.0.0.1")
|
|
if err != nil {
|
|
t.Fatalf("NewHttpConnector() error = %v", err)
|
|
}
|
|
return conn, nil
|
|
},
|
|
want: false,
|
|
},
|
|
{
|
|
name: "transport failure returns false",
|
|
setup: func(t *testing.T) (*httpConnector, <-chan string) {
|
|
return newUnreachableConnector(t, context.Background()), nil
|
|
},
|
|
want: false,
|
|
},
|
|
{
|
|
name: "backend path prefix is preserved",
|
|
setup: func(t *testing.T) (*httpConnector, <-chan string) {
|
|
return newServerConnector(t, context.Background(), stdhttp.StatusOK, "/base")
|
|
},
|
|
want: true,
|
|
wantPath: "/base/api/v1/status",
|
|
},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
conn, pathCh := tt.setup(t)
|
|
|
|
got := conn.CheckConnection()
|
|
if got != tt.want {
|
|
t.Fatalf("CheckConnection() = %v, want %v", got, tt.want)
|
|
}
|
|
|
|
if tt.wantPath == "" {
|
|
return
|
|
}
|
|
|
|
select {
|
|
case gotPath := <-pathCh:
|
|
if gotPath != tt.wantPath {
|
|
t.Fatalf("request path = %q, want %q", gotPath, tt.wantPath)
|
|
}
|
|
default:
|
|
t.Fatalf("expected request path %q, got no request", tt.wantPath)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
// TestCheckVersion verifies versions retrieval behavior.
|
|
func TestCheckVersion(t *testing.T) {
|
|
tests := []checkVersionCase{
|
|
{
|
|
name: "status 200 with valid body returns versions",
|
|
setup: func(t *testing.T) (*httpConnector, <-chan string) {
|
|
return newVersionServerConnector(
|
|
t,
|
|
context.Background(),
|
|
stdhttp.StatusOK,
|
|
`[{"os":"darwin","version":"1.2.3","url":"https://example.com/darwin"}]`,
|
|
"",
|
|
)
|
|
},
|
|
want: []connector.VersionInfo{
|
|
{OS: "darwin", Version: "1.2.3", URL: "https://example.com/darwin"},
|
|
},
|
|
wantPath: "/api/v1/versions",
|
|
},
|
|
{
|
|
name: "status 200 with invalid json returns error",
|
|
setup: func(t *testing.T) (*httpConnector, <-chan string) {
|
|
return newVersionServerConnector(
|
|
t,
|
|
context.Background(),
|
|
stdhttp.StatusOK,
|
|
`{"versions":`,
|
|
"",
|
|
)
|
|
},
|
|
wantErr: true,
|
|
wantPath: "/api/v1/versions",
|
|
},
|
|
{
|
|
name: "non-200 status returns error",
|
|
setup: func(t *testing.T) (*httpConnector, <-chan string) {
|
|
return newVersionServerConnector(
|
|
t,
|
|
context.Background(),
|
|
stdhttp.StatusServiceUnavailable,
|
|
`[]`,
|
|
"",
|
|
)
|
|
},
|
|
wantErr: true,
|
|
wantPath: "/api/v1/versions",
|
|
},
|
|
{
|
|
name: "canceled context returns error",
|
|
setup: func(t *testing.T) (*httpConnector, <-chan string) {
|
|
ctx, cancel := context.WithCancel(context.Background())
|
|
cancel()
|
|
conn, err := NewHttpConnector(ctx, "http://127.0.0.1")
|
|
if err != nil {
|
|
t.Fatalf("NewHttpConnector() error = %v", err)
|
|
}
|
|
return conn, nil
|
|
},
|
|
wantErr: true,
|
|
},
|
|
{
|
|
name: "transport failure returns error",
|
|
setup: func(t *testing.T) (*httpConnector, <-chan string) {
|
|
return newUnreachableConnector(t, context.Background()), nil
|
|
},
|
|
wantErr: true,
|
|
},
|
|
{
|
|
name: "backend path prefix is preserved",
|
|
setup: func(t *testing.T) (*httpConnector, <-chan string) {
|
|
return newVersionServerConnector(
|
|
t,
|
|
context.Background(),
|
|
stdhttp.StatusOK,
|
|
`[{"os":"linux","version":"2.0.0","url":"https://example.com/linux"}]`,
|
|
"/base",
|
|
)
|
|
},
|
|
want: []connector.VersionInfo{
|
|
{OS: "linux", Version: "2.0.0", URL: "https://example.com/linux"},
|
|
},
|
|
wantPath: "/base/api/v1/versions",
|
|
},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
conn, pathCh := tt.setup(t)
|
|
|
|
got, err := conn.CheckVersion()
|
|
if tt.wantErr {
|
|
if err == nil {
|
|
t.Fatal("CheckVersion() error = nil, want non-nil")
|
|
}
|
|
} else {
|
|
if err != nil {
|
|
t.Fatalf("CheckVersion() error = %v, want nil", err)
|
|
}
|
|
if !reflect.DeepEqual(got, tt.want) {
|
|
t.Fatalf("CheckVersion() = %#v, want %#v", got, tt.want)
|
|
}
|
|
}
|
|
|
|
if tt.wantPath == "" {
|
|
return
|
|
}
|
|
|
|
select {
|
|
case gotPath := <-pathCh:
|
|
if gotPath != tt.wantPath {
|
|
t.Fatalf("request path = %q, want %q", gotPath, tt.wantPath)
|
|
}
|
|
default:
|
|
t.Fatalf("expected request path %q, got no request", tt.wantPath)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
// TestDoRequestUsesPassedContext verifies request context is provided by caller.
|
|
func TestDoRequestUsesPassedContext(t *testing.T) {
|
|
conn, pathCh := newServerConnector(t, context.Background(), stdhttp.StatusOK, "")
|
|
|
|
ctx, cancel := context.WithCancel(context.Background())
|
|
cancel()
|
|
|
|
_, err := conn.doRequest(ctx, checkConnectionPath)
|
|
if err == nil {
|
|
t.Fatal("doRequest() error = nil, want non-nil")
|
|
}
|
|
if !errors.Is(err, context.Canceled) {
|
|
t.Fatalf("doRequest() error = %v, want context canceled", err)
|
|
}
|
|
|
|
select {
|
|
case gotPath := <-pathCh:
|
|
t.Fatalf("expected no request with canceled context, got %q", gotPath)
|
|
default:
|
|
}
|
|
}
|
|
|
|
// TestDoRequestResponseHeaderTimeout verifies client distinguishes response timeout.
|
|
func TestDoRequestResponseHeaderTimeout(t *testing.T) {
|
|
const (
|
|
dialTimeout = time.Second
|
|
headerTimeout = 30 * time.Millisecond
|
|
serverHeaderDelayTime = 150 * time.Millisecond
|
|
)
|
|
|
|
server := httptest.NewServer(stdhttp.HandlerFunc(func(w stdhttp.ResponseWriter, r *stdhttp.Request) {
|
|
time.Sleep(serverHeaderDelayTime)
|
|
w.WriteHeader(stdhttp.StatusOK)
|
|
}))
|
|
t.Cleanup(server.Close)
|
|
|
|
backendURL, err := url.Parse(server.URL)
|
|
if err != nil {
|
|
t.Fatalf("parse backend URL error = %v", err)
|
|
}
|
|
|
|
conn := &httpConnector{
|
|
ctx: context.Background(),
|
|
backendURL: backendURL,
|
|
httpClient: newHTTPClient(dialTimeout, headerTimeout),
|
|
}
|
|
|
|
start := time.Now()
|
|
_, err = conn.doRequest(context.Background(), checkConnectionPath)
|
|
elapsed := time.Since(start)
|
|
if err == nil {
|
|
t.Fatal("doRequest() error = nil, want timeout")
|
|
}
|
|
if elapsed < headerTimeout {
|
|
t.Fatalf("doRequest() elapsed = %v, want >= %v", elapsed, headerTimeout)
|
|
}
|
|
|
|
var netErr net.Error
|
|
if !errors.As(err, &netErr) || !netErr.Timeout() {
|
|
t.Fatalf("doRequest() error = %v, want timeout error", err)
|
|
}
|
|
}
|
|
|
|
// TestDoRequestSuccessFirstAttemptNoRetry verifies successful call does not schedule retries.
|
|
func TestDoRequestSuccessFirstAttemptNoRetry(t *testing.T) {
|
|
attempts := 0
|
|
sleepCalls := 0
|
|
jitterCalls := 0
|
|
|
|
conn := newTransportConnector(t, func(req *stdhttp.Request) (*stdhttp.Response, error) {
|
|
attempts++
|
|
return &stdhttp.Response{
|
|
StatusCode: stdhttp.StatusOK,
|
|
Body: io.NopCloser(strings.NewReader("")),
|
|
}, nil
|
|
})
|
|
conn.jitterFn = func(cap time.Duration) time.Duration {
|
|
jitterCalls++
|
|
return cap
|
|
}
|
|
conn.sleepFn = func(ctx context.Context, d time.Duration) error {
|
|
sleepCalls++
|
|
return nil
|
|
}
|
|
|
|
resp, err := conn.doRequest(context.Background(), checkConnectionPath)
|
|
if err != nil {
|
|
t.Fatalf("doRequest() error = %v, want nil", err)
|
|
}
|
|
defer resp.Body.Close()
|
|
|
|
if attempts != 1 {
|
|
t.Fatalf("attempts = %d, want 1", attempts)
|
|
}
|
|
if jitterCalls != 0 {
|
|
t.Fatalf("jitter calls = %d, want 0", jitterCalls)
|
|
}
|
|
if sleepCalls != 0 {
|
|
t.Fatalf("sleep calls = %d, want 0", sleepCalls)
|
|
}
|
|
}
|
|
|
|
// TestDoRequestConnectTimeoutRetriesWithJitter verifies retries for connect timeout errors.
|
|
func TestDoRequestConnectTimeoutRetriesWithJitter(t *testing.T) {
|
|
attempts := 0
|
|
jitterCaps := make([]time.Duration, 0)
|
|
sleepDurations := make([]time.Duration, 0)
|
|
|
|
conn := newTransportConnector(t, func(req *stdhttp.Request) (*stdhttp.Response, error) {
|
|
attempts++
|
|
if attempts <= 2 {
|
|
return nil, newDialTimeoutError()
|
|
}
|
|
return &stdhttp.Response{
|
|
StatusCode: stdhttp.StatusOK,
|
|
Body: io.NopCloser(strings.NewReader("")),
|
|
}, nil
|
|
})
|
|
conn.jitterFn = func(cap time.Duration) time.Duration {
|
|
jitterCaps = append(jitterCaps, cap)
|
|
return cap
|
|
}
|
|
conn.sleepFn = func(ctx context.Context, d time.Duration) error {
|
|
sleepDurations = append(sleepDurations, d)
|
|
return nil
|
|
}
|
|
|
|
resp, err := conn.doRequest(context.Background(), checkConnectionPath)
|
|
if err != nil {
|
|
t.Fatalf("doRequest() error = %v, want nil", err)
|
|
}
|
|
defer resp.Body.Close()
|
|
|
|
if attempts != 3 {
|
|
t.Fatalf("attempts = %d, want 3", attempts)
|
|
}
|
|
|
|
wantCaps := []time.Duration{5 * time.Second, 15 * time.Second}
|
|
if !reflect.DeepEqual(jitterCaps, wantCaps) {
|
|
t.Fatalf("jitter caps = %v, want %v", jitterCaps, wantCaps)
|
|
}
|
|
if !reflect.DeepEqual(sleepDurations, wantCaps) {
|
|
t.Fatalf("sleep durations = %v, want %v", sleepDurations, wantCaps)
|
|
}
|
|
}
|
|
|
|
// TestDoRequestConnectTimeoutExhaustsRetries verifies retry count and final timeout error.
|
|
func TestDoRequestConnectTimeoutExhaustsRetries(t *testing.T) {
|
|
attempts := 0
|
|
jitterCaps := make([]time.Duration, 0)
|
|
sleepDurations := make([]time.Duration, 0)
|
|
|
|
conn := newTransportConnector(t, func(req *stdhttp.Request) (*stdhttp.Response, error) {
|
|
attempts++
|
|
return nil, newDialTimeoutError()
|
|
})
|
|
conn.jitterFn = func(cap time.Duration) time.Duration {
|
|
jitterCaps = append(jitterCaps, cap)
|
|
return cap
|
|
}
|
|
conn.sleepFn = func(ctx context.Context, d time.Duration) error {
|
|
sleepDurations = append(sleepDurations, d)
|
|
return nil
|
|
}
|
|
|
|
_, err := conn.doRequest(context.Background(), checkConnectionPath)
|
|
if err == nil {
|
|
t.Fatal("doRequest() error = nil, want timeout")
|
|
}
|
|
if !isConnectTimeout(err) {
|
|
t.Fatalf("doRequest() error = %v, want connect timeout", err)
|
|
}
|
|
|
|
wantCaps := append([]time.Duration(nil), defaultRetryCaps...)
|
|
if attempts != len(wantCaps)+1 {
|
|
t.Fatalf("attempts = %d, want %d", attempts, len(wantCaps)+1)
|
|
}
|
|
if !reflect.DeepEqual(jitterCaps, wantCaps) {
|
|
t.Fatalf("jitter caps = %v, want %v", jitterCaps, wantCaps)
|
|
}
|
|
if !reflect.DeepEqual(sleepDurations, wantCaps) {
|
|
t.Fatalf("sleep durations = %v, want %v", sleepDurations, wantCaps)
|
|
}
|
|
}
|
|
|
|
// TestDoRequestResponseTimeoutNoRetry verifies response timeout does not trigger retries.
|
|
func TestDoRequestResponseTimeoutNoRetry(t *testing.T) {
|
|
attempts := 0
|
|
sleepCalls := 0
|
|
jitterCalls := 0
|
|
|
|
conn := newTransportConnector(t, func(req *stdhttp.Request) (*stdhttp.Response, error) {
|
|
attempts++
|
|
return nil, newResponseHeaderTimeoutError()
|
|
})
|
|
conn.jitterFn = func(cap time.Duration) time.Duration {
|
|
jitterCalls++
|
|
return cap
|
|
}
|
|
conn.sleepFn = func(ctx context.Context, d time.Duration) error {
|
|
sleepCalls++
|
|
return nil
|
|
}
|
|
|
|
_, err := conn.doRequest(context.Background(), checkConnectionPath)
|
|
if err == nil {
|
|
t.Fatal("doRequest() error = nil, want timeout")
|
|
}
|
|
|
|
var netErr net.Error
|
|
if !errors.As(err, &netErr) || !netErr.Timeout() {
|
|
t.Fatalf("doRequest() error = %v, want timeout error", err)
|
|
}
|
|
if attempts != 1 {
|
|
t.Fatalf("attempts = %d, want 1", attempts)
|
|
}
|
|
if jitterCalls != 0 {
|
|
t.Fatalf("jitter calls = %d, want 0", jitterCalls)
|
|
}
|
|
if sleepCalls != 0 {
|
|
t.Fatalf("sleep calls = %d, want 0", sleepCalls)
|
|
}
|
|
}
|
|
|
|
// TestDoRequestContextCanceledDuringBackoff verifies cancellation interrupts retry wait.
|
|
func TestDoRequestContextCanceledDuringBackoff(t *testing.T) {
|
|
attempts := 0
|
|
sleepCalls := 0
|
|
|
|
conn := newTransportConnector(t, func(req *stdhttp.Request) (*stdhttp.Response, error) {
|
|
attempts++
|
|
return nil, newDialTimeoutError()
|
|
})
|
|
ctx, cancel := context.WithCancel(context.Background())
|
|
conn.jitterFn = func(cap time.Duration) time.Duration {
|
|
return cap
|
|
}
|
|
conn.sleepFn = func(ctx context.Context, d time.Duration) error {
|
|
sleepCalls++
|
|
cancel()
|
|
return ctx.Err()
|
|
}
|
|
|
|
_, err := conn.doRequest(ctx, checkConnectionPath)
|
|
if !errors.Is(err, context.Canceled) {
|
|
t.Fatalf("doRequest() error = %v, want context canceled", err)
|
|
}
|
|
if attempts != 1 {
|
|
t.Fatalf("attempts = %d, want 1", attempts)
|
|
}
|
|
if sleepCalls != 1 {
|
|
t.Fatalf("sleep calls = %d, want 1", sleepCalls)
|
|
}
|
|
}
|
|
|
|
type roundTripperFunc func(req *stdhttp.Request) (*stdhttp.Response, error)
|
|
|
|
// RoundTrip implements [http.RoundTripper].
|
|
func (f roundTripperFunc) RoundTrip(req *stdhttp.Request) (*stdhttp.Response, error) {
|
|
return f(req)
|
|
}
|
|
|
|
// timeoutError simulates a timeout error returned by transport.
|
|
type timeoutError struct {
|
|
message string
|
|
}
|
|
|
|
func (e timeoutError) Error() string {
|
|
return e.message
|
|
}
|
|
|
|
func (e timeoutError) Timeout() bool {
|
|
return true
|
|
}
|
|
|
|
func (e timeoutError) Temporary() bool {
|
|
return true
|
|
}
|
|
|
|
// newDialTimeoutError builds a connect timeout shaped like dial failure.
|
|
func newDialTimeoutError() error {
|
|
return &net.OpError{
|
|
Op: "dial",
|
|
Net: "tcp",
|
|
Err: timeoutError{message: "i/o timeout"},
|
|
}
|
|
}
|
|
|
|
// newResponseHeaderTimeoutError builds timeout error for response header wait.
|
|
func newResponseHeaderTimeoutError() error {
|
|
return timeoutError{message: "net/http: timeout awaiting response headers"}
|
|
}
|
|
|
|
// newTransportConnector creates connector with custom round tripper for request tests.
|
|
func newTransportConnector(t *testing.T, transport roundTripperFunc) *httpConnector {
|
|
t.Helper()
|
|
|
|
backendURL, err := url.Parse("http://example.com")
|
|
if err != nil {
|
|
t.Fatalf("parse backend URL error = %v", err)
|
|
}
|
|
|
|
return &httpConnector{
|
|
ctx: context.Background(),
|
|
backendURL: backendURL,
|
|
httpClient: &stdhttp.Client{Transport: transport},
|
|
retryCaps: append([]time.Duration(nil), defaultRetryCaps...),
|
|
}
|
|
}
|
|
|
|
// newServerConnector creates connector backed by an HTTP test server and captures requested path.
|
|
func newServerConnector(t *testing.T, ctx context.Context, status int, backendPath string) (*httpConnector, <-chan string) {
|
|
t.Helper()
|
|
|
|
pathCh := make(chan string, 1)
|
|
server := httptest.NewServer(stdhttp.HandlerFunc(func(w stdhttp.ResponseWriter, r *stdhttp.Request) {
|
|
pathCh <- r.URL.Path
|
|
w.WriteHeader(status)
|
|
}))
|
|
t.Cleanup(server.Close)
|
|
|
|
conn, err := NewHttpConnector(ctx, server.URL+backendPath)
|
|
if err != nil {
|
|
t.Fatalf("NewHttpConnector() error = %v", err)
|
|
}
|
|
|
|
return conn, pathCh
|
|
}
|
|
|
|
// newVersionServerConnector creates connector with configurable response body for versions endpoint tests.
|
|
func newVersionServerConnector(t *testing.T, ctx context.Context, status int, body, backendPath string) (*httpConnector, <-chan string) {
|
|
t.Helper()
|
|
|
|
pathCh := make(chan string, 1)
|
|
server := httptest.NewServer(stdhttp.HandlerFunc(func(w stdhttp.ResponseWriter, r *stdhttp.Request) {
|
|
pathCh <- r.URL.Path
|
|
w.WriteHeader(status)
|
|
_, _ = w.Write([]byte(body))
|
|
}))
|
|
t.Cleanup(server.Close)
|
|
|
|
conn, err := NewHttpConnector(ctx, server.URL+backendPath)
|
|
if err != nil {
|
|
t.Fatalf("NewHttpConnector() error = %v", err)
|
|
}
|
|
|
|
return conn, pathCh
|
|
}
|
|
|
|
// newUnreachableConnector creates connector pointing to a closed localhost TCP address.
|
|
func newUnreachableConnector(t *testing.T, ctx context.Context) *httpConnector {
|
|
t.Helper()
|
|
|
|
ln, err := net.Listen("tcp", "127.0.0.1:0")
|
|
if err != nil {
|
|
t.Fatalf("listen error = %v", err)
|
|
}
|
|
addr := ln.Addr().String()
|
|
if err := ln.Close(); err != nil {
|
|
t.Fatalf("close listener error = %v", err)
|
|
}
|
|
|
|
conn, err := NewHttpConnector(ctx, "http://"+addr)
|
|
if err != nil {
|
|
t.Fatalf("NewHttpConnector() error = %v", err)
|
|
}
|
|
return conn
|
|
}
|