fs storage

2026-03-13 21:07:23 +02:00
parent 43039a79bf
commit 9ade76e21d
117 changed files with 1734 additions and 176 deletions
@@ -0,0 +1,595 @@
+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
+}