Skip to content

Modern Docker Management, Designed for Everyone

6.9 KB
Raw Blame
package ws

import (
	"context"
	"net/http"
	"net/http/httptest"
	"strings"
	"testing"
	"time"

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

// allowAnyOriginForTest stands in for the caller-supplied Origin validator;
// these tests exercise the proxy bridge, not the Origin policy.
func allowAnyOriginForTest(*http.Request) bool { return true }

func TestProxyHTTP_RequiresOriginValidator(t *testing.T) {
	err := ProxyHTTP(httptest.NewRecorder(), httptest.NewRequest(http.MethodGet, "/", http.NoBody), "ws://127.0.0.1:1", nil, nil, http.DefaultClient)
	require.Error(t, err, "proxy must refuse to upgrade without an origin validator")
}

func TestProxyHTTP_BidirectionalMessages(t *testing.T) {
	// 1. Create a "remote" WebSocket server that echoes messages
	remoteServer := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		conn, err := websocket.Accept(w, r, nil)
		if err != nil {
			return
		}
		defer func() { _ = conn.CloseNow() }()

		for {
			mt, msg, readErr := conn.Read(r.Context())
			if readErr != nil {
				return
			}
			// Echo with prefix
			if writeErr := conn.Write(r.Context(), mt, append([]byte("echo:"), msg...)); writeErr != nil {
				return
			}
		}
	}))
	defer remoteServer.Close()

	remoteWS := "ws" + strings.TrimPrefix(remoteServer.URL, "http")

	// 2. Create a "proxy" server that uses ProxyHTTP
	proxyServer := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		_ = ProxyHTTP(w, r, remoteWS, nil, allowAnyOriginForTest, http.DefaultClient)
	}))
	defer proxyServer.Close()

	// 3. Connect a client to the proxy
	proxyURL := "ws" + strings.TrimPrefix(proxyServer.URL, "http")
	clientConn, _, err := websocket.Dial(t.Context(), proxyURL, nil)
	require.NoError(t, err)
	defer func() {
		_ = clientConn.CloseNow()
	}()

	// 4. Send messages and verify they get proxied and echoed
	testMessages := []string{"hello", "world", "test123"}
	for _, msg := range testMessages {
		writeErr := clientConn.Write(t.Context(), websocket.MessageText, []byte(msg))
		require.NoError(t, writeErr)

		readCtx, readCancel := context.WithTimeout(t.Context(), 2*time.Second)
		_, received, writeErr := clientConn.Read(readCtx)
		readCancel()
		require.NoError(t, writeErr)
		assert.Equal(t, "echo:"+msg, string(received))
	}
}

func TestProxyHTTP_RemoteClose(t *testing.T) {
	// Remote server that closes immediately after upgrade
	remoteServer := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		conn, err := websocket.Accept(w, r, nil)
		if err != nil {
			return
		}
		// Close immediately
		if closeErr := conn.Close(websocket.StatusNormalClosure, "bye"); closeErr != nil {
			t.Logf("close websocket connection: %v", closeErr)
		}
	}))
	defer remoteServer.Close()

	remoteWS := "ws" + strings.TrimPrefix(remoteServer.URL, "http")

	proxyDone := make(chan error, 1)
	proxyServer := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		proxyDone <- ProxyHTTP(w, r, remoteWS, nil, allowAnyOriginForTest, http.DefaultClient)
	}))
	defer proxyServer.Close()

	proxyURL := "ws" + strings.TrimPrefix(proxyServer.URL, "http")
	clientConn, _, err := websocket.Dial(t.Context(), proxyURL, nil)
	require.NoError(t, err)
	defer func() {
		_ = clientConn.CloseNow()
	}()
	clientConn.CloseRead(t.Context())

	// The proxy should complete (not hang)
	select {
	case proxyErr := <-proxyDone:
		require.NoError(t, proxyErr)
	case <-time.After(5 * time.Second):
		require.FailNow(t, "ProxyHTTP did not return after remote closed")
	}
}

func TestProxyHTTP_InvalidRemoteURL(t *testing.T) {
	proxyDone := make(chan error, 1)
	proxyServer := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		proxyDone <- ProxyHTTP(w, r, "ws://127.0.0.1:1", nil, allowAnyOriginForTest, http.DefaultClient)
	}))
	defer proxyServer.Close()

	proxyURL := "ws" + strings.TrimPrefix(proxyServer.URL, "http")
	clientConn, _, err := websocket.Dial(t.Context(), proxyURL, nil)
	require.NoError(t, err)
	defer func() {
		_ = clientConn.CloseNow()
	}()

	select {
	case operationErr := <-proxyDone:
		require.Error(t, operationErr, "ProxyHTTP should return error when remote is unreachable")
	case <-time.After(50 * time.Second):
		require.FailNow(t, "ProxyHTTP did not return after failed dial")
	}
}

func TestProxyHTTP_BinaryMessages(t *testing.T) {
	// Remote server that echoes binary messages
	remoteServer := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		conn, err := websocket.Accept(w, r, nil)
		if err != nil {
			return
		}
		defer func() { _ = conn.CloseNow() }()

		for {
			mt, msg, readErr := conn.Read(r.Context())
			if readErr != nil {
				return
			}
			if writeErr := conn.Write(r.Context(), mt, msg); writeErr != nil {
				return
			}
		}
	}))
	defer remoteServer.Close()

	remoteWS := "ws" + strings.TrimPrefix(remoteServer.URL, "http")

	proxyServer := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		_ = ProxyHTTP(w, r, remoteWS, nil, allowAnyOriginForTest, http.DefaultClient)
	}))
	defer proxyServer.Close()

	proxyURL := "ws" + strings.TrimPrefix(proxyServer.URL, "http")
	clientConn, _, err := websocket.Dial(t.Context(), proxyURL, nil)
	require.NoError(t, err)
	defer func() {
		_ = clientConn.CloseNow()
	}()

	binaryData := []byte{0x00, 0x01, 0x02, 0xFF, 0xFE, 0xFD}
	err = clientConn.Write(t.Context(), websocket.MessageBinary, binaryData)
	require.NoError(t, err)

	readCtx, readCancel := context.WithTimeout(t.Context(), 2*time.Second)
	defer readCancel()
	mt, received, err := clientConn.Read(readCtx)
	require.NoError(t, err)
	assert.Equal(t, websocket.MessageBinary, mt)
	assert.Equal(t, binaryData, received)
}

func TestProxyHTTP_HeadersForwarded(t *testing.T) {
	headersCh := make(chan http.Header, 1)
	remoteServer := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		headersCh <- r.Header.Clone()
		conn, err := websocket.Accept(w, r, nil)
		if err != nil {
			return
		}
		_ = conn.CloseNow()
	}))
	defer remoteServer.Close()

	remoteWS := "ws" + strings.TrimPrefix(remoteServer.URL, "http")

	customHeaders := http.Header{
		"X-Custom-Header": {"test-value"},
		"Authorization":   {"Bearer token123"},
	}

	proxyServer := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		_ = ProxyHTTP(w, r, remoteWS, customHeaders, allowAnyOriginForTest, http.DefaultClient)
	}))
	defer proxyServer.Close()

	proxyURL := "ws" + strings.TrimPrefix(proxyServer.URL, "http")
	clientConn, _, err := websocket.Dial(t.Context(), proxyURL, nil)
	require.NoError(t, err)
	defer func() {
		_ = clientConn.CloseNow()
	}()

	select {
	case receivedHeaders := <-headersCh:
		assert.Equal(t, "test-value", receivedHeaders.Get("X-Custom-Header"))
		assert.Equal(t, "Bearer token123", receivedHeaders.Get("Authorization"))
	case <-time.After(2 * time.Second):
		require.FailNow(t, "timed out waiting for headers")
	}
}