Skip to content

Modern Docker Management, Designed for Everyone

4.3 KB
Raw Blame
package remenv

import (
	"context"
	"errors"
	"io"
	"net"
	"net/http"
	"net/http/httptest"
	"syscall"
	"testing"

	"github.com/stretchr/testify/assert"
	"github.com/stretchr/testify/require"
)

func TestApplyAgentTokenHeaders(t *testing.T) {
	headers := http.Header{}
	ApplyAgentTokenHeaders(headers, nil)
	require.Empty(t, headers.Get(HeaderAPIKey))
	require.Empty(t, headers.Get(HeaderAgentToken))

	token := "token-123"
	ApplyAgentTokenHeaders(headers, &token)
	require.Equal(t, token, headers.Get(HeaderAPIKey))
	require.Equal(t, token, headers.Get(HeaderAgentToken))

	headerMap := map[string]string{}
	ApplyAgentTokenHeaderMap(headerMap, &token)
	require.Equal(t, token, headerMap[HeaderAPIKey])
	require.Equal(t, token, headerMap[HeaderAgentToken])
}

func TestRedactedTokenFingerprint(t *testing.T) {
	require.Equal(t, "***", RedactedTokenFingerprint(""))
	require.Equal(t, "***", RedactedTokenFingerprint("short"))
	require.Equal(t, "***", RedactedTokenFingerprint("1234567890"))
	require.Equal(t, "123456...cdef", RedactedTokenFingerprint(" 1234567890abcdef "))
}

func TestClientDo_DirectHTTPSuccess(t *testing.T) {
	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		if !assert.Equal(t, http.MethodPost, r.Method) {
			return
		}
		if !assert.Equal(t, "/api/registries/sync", r.URL.Path) {
			return
		}
		if !assert.Equal(t, "application/json", r.Header.Get("Content-Type")) {
			return
		}
		w.Header().Set("Content-Type", "application/json")
		w.WriteHeader(http.StatusAccepted)
		_, _ = w.Write([]byte(`{"ok":true}`))
	}))
	defer server.Close()

	client := NewClient(server.Client(), nil)
	resp, err := client.Do(t.Context(), Request{
		Method:  http.MethodPost,
		URL:     server.URL + "/api/registries/sync",
		Path:    "/api/registries/sync",
		Headers: map[string]string{"Content-Type": "application/json"},
		Body:    []byte(`{"sync":true}`),
	})
	require.NoError(t, err)
	require.Equal(t, http.StatusAccepted, resp.StatusCode)
	require.Equal(t, `{"ok":true}`, string(resp.Body))
	require.Equal(t, "application/json", resp.Headers["Content-Type"])
}

func TestClientDo_EdgeUsesTunnelTransport(t *testing.T) {
	var ensured bool
	client := NewClient(nil, TunnelTransportFuncs{
		EnsureAvailableFunc: func(ctx context.Context, envID string) error {
			ensured = true
			require.Equal(t, "env-edge-1", envID)
			return nil
		},
		DoFunc: func(ctx context.Context, envID, method, path string, headers map[string]string, body []byte) (*Response, error) {
			require.Equal(t, "env-edge-1", envID)
			require.Equal(t, http.MethodGet, method)
			require.Equal(t, "/api/health", path)
			return &Response{
				StatusCode: http.StatusOK,
				Body:       []byte(`{"edge":true}`),
				Headers:    map[string]string{"Content-Type": "application/json"},
			}, nil
		},
	})

	resp, err := client.Do(t.Context(), Request{
		EnvironmentID: "env-edge-1",
		IsEdge:        true,
		Method:        http.MethodGet,
		Path:          "/api/health",
	})
	require.NoError(t, err)
	require.True(t, ensured)
	require.Equal(t, http.StatusOK, resp.StatusCode)
	require.Equal(t, `{"edge":true}`, string(resp.Body))
}

func TestClientDo_WrapsTransportErrors(t *testing.T) {
	client := NewClient(nil, TunnelTransportFuncs{
		EnsureAvailableFunc: func(ctx context.Context, envID string) error {
			return ErrEnvironmentUnavailable
		},
	})

	_, err := client.Do(t.Context(), Request{
		EnvironmentID: "env-edge-2",
		IsEdge:        true,
		Method:        http.MethodGet,
		Path:          "/api/health",
	})
	var transportErr *TransportError
	require.ErrorAs(t, err, &transportErr)
	require.Contains(t, transportErr.Error(), "not connected")
	require.True(t, transportErr.Unavailable())
	for _, test := range []struct {
		name        string
		cause       error
		unavailable bool
	}{
		{"deadline", context.DeadlineExceeded, true},
		{"connection refused", &net.OpError{Op: "dial", Net: "tcp", Err: syscall.ECONNREFUSED}, true},
		{"response truncated", io.ErrUnexpectedEOF, false},
		{"invalid request", errors.New("invalid URL"), false},
		{"invalid address", &net.OpError{Op: "dial", Err: &net.AddrError{Err: "invalid port", Addr: "agent:invalid"}}, false},
		{"canceled", context.Canceled, false},
		{"canceled dial", &net.OpError{Op: "dial", Err: context.Canceled}, false},
	} {
		t.Run(test.name, func(t *testing.T) {
			require.Equal(t, test.unavailable, (&TransportError{Err: test.cause}).Unavailable())
		})
	}
}