Skip to content

Modern Docker Management, Designed for Everyone

5.8 KB
Raw Blame
package edge

import (
	"context"
	"encoding/json"
	"io"
	"net/http"
	"net/http/httptest"
	"strings"
	"testing"
	"time"

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

	tunnelpb "github.com/getarcaneapp/arcane/backend/v2/proto/tunnel/v1"
)

func newWebSocketAgentTunnel(envID string, conn *websocket.Conn) *AgentTunnel {
	return NewAgentTunnelWithConn(envID, NewTunnelConn(conn))
}

func TestTunnelMessage_MarshalJSON(t *testing.T) {
	msg := &TunnelMessage{
		ID:   "test-id",
		Type: MessageTypeRequest,
		Body: nil,
	}

	data, err := json.Marshal(msg)
	require.NoError(t, err)

	// Check that fields are present
	strData := string(data)
	assert.Contains(t, strData, `"id":"test-id"`)
	assert.Contains(t, strData, `"type":"request"`)
}

func TestTunnelConn(t *testing.T) {
	// Start a test server
	server := 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, message, readErr := conn.Read(r.Context())
			if readErr != nil {
				break
			}
			// Echo back
			readErr = conn.Write(r.Context(), mt, message)
			if readErr != nil {
				break
			}
		}
	}))
	defer server.Close()

	// Connect to the server
	url := "ws" + strings.TrimPrefix(server.URL, "http")
	conn, _, err := websocket.Dial(t.Context(), url, nil)
	require.NoError(t, err)
	defer func() { _ = conn.CloseNow() }()

	tunnelConn := NewTunnelConn(conn)

	// Test Send and Receive
	msg := &TunnelMessage{
		ID:   "test-id",
		Type: MessageTypeRequest,
		Body: []byte("test-body"),
	}

	err = tunnelConn.Send(msg)
	require.NoError(t, err)

	received, err := tunnelConn.Receive()
	require.NoError(t, err)
	assert.Equal(t, msg.ID, received.ID)
	assert.Equal(t, msg.Type, received.Type)
	assert.Equal(t, msg.Body, received.Body)

	// Test IsClosed
	assert.False(t, tunnelConn.IsClosed())

	err = tunnelConn.Close()
	require.NoError(t, err)
	assert.True(t, tunnelConn.IsClosed())

	// Test Send on closed connection
	err = tunnelConn.Send(msg)
	require.Error(t, err)
	assert.ErrorIs(t, err, ErrTunnelConnectionClosed)
}

func TestGRPCManagerTunnelConn_CloseCancelsReceive(t *testing.T) {
	baseCtx := t.Context()

	stream := &blockingGRPCManagerStream{
		ctx:         baseCtx,
		recvStarted: make(chan struct{}, 1),
	}
	conn := NewGRPCManagerTunnelConn(stream)

	errCh := make(chan error, 1)
	go func() {
		_, err := conn.Receive()
		errCh <- err
	}()

	select {
	case <-stream.recvStarted:
	case <-time.After(time.Second):
		require.FailNow(t, "timed out waiting for stream recv start")
	}

	require.NoError(t, conn.Close())

	select {
	case err := <-errCh:
		require.Error(t, err)
		require.ErrorIs(t, err, context.Canceled)
	case <-time.After(time.Second):
		require.FailNow(t, "timed out waiting for receive to unblock")
	}
}

type blockingGRPCManagerStream struct {
	ctx         context.Context
	recvStarted chan struct{}
}

func (b *blockingGRPCManagerStream) Send(*tunnelpb.ManagerMessage) error { return nil }

func (b *blockingGRPCManagerStream) Recv() (*tunnelpb.AgentMessage, error) {
	select {
	case b.recvStarted <- struct{}{}:
	default:
	}
	<-b.ctx.Done()
	return nil, b.ctx.Err()
}

func (b *blockingGRPCManagerStream) Context() context.Context { return b.ctx }

func TestTunnelConn_CloseSendsCloseFrame(t *testing.T) {
	peerRead := make(chan error, 1)
	server := 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() }()
		_, _, err = conn.Read(r.Context())
		peerRead <- err
	}))
	defer server.Close()

	wsURL := "ws" + strings.TrimPrefix(server.URL, "http")
	conn, _, err := websocket.Dial(t.Context(), wsURL, nil)
	require.NoError(t, err)

	tunnelConn := NewTunnelConn(conn)
	require.NoError(t, tunnelConn.Close())

	select {
	case operationErr := <-peerRead:
		assert.Equal(t, websocket.StatusNormalClosure, websocket.CloseStatus(operationErr),
			"peer should observe a normal closure, got: %v", operationErr)
	case <-time.After(5 * time.Second):
		require.FailNow(t, "timed out waiting for peer read to return")
	}
}

func TestTunnelConn_ReceiveDeadlineMarksClosed(t *testing.T) {
	previousReadWait := tunnelReadWait
	tunnelReadWait = 100 * time.Millisecond
	t.Cleanup(func() { tunnelReadWait = previousReadWait })

	server := 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() }()
		// Keep the socket open but never send anything.
		_, _, _ = conn.Read(r.Context())
	}))
	defer server.Close()

	wsURL := "ws" + strings.TrimPrefix(server.URL, "http")
	conn, _, err := websocket.Dial(t.Context(), wsURL, nil)
	require.NoError(t, err)

	tunnelConn := NewTunnelConn(conn)
	_, err = tunnelConn.Receive()
	require.Error(t, err)
	assert.True(t, tunnelConn.IsClosed())
}

type closeOrderAgentStream struct {
	ctx    context.Context
	events []string
}

func (s *closeOrderAgentStream) Send(*tunnelpb.AgentMessage) error { return nil }

func (s *closeOrderAgentStream) Recv() (*tunnelpb.ManagerMessage, error) { return nil, io.EOF }

func (s *closeOrderAgentStream) Context() context.Context { return s.ctx }

func (s *closeOrderAgentStream) CloseSend() error {
	s.events = append(s.events, "close_send")
	return nil
}

func TestGRPCAgentTunnelConn_CloseHalfClosesBeforeCancel(t *testing.T) {
	stream := &closeOrderAgentStream{ctx: t.Context()}
	conn := NewGRPCAgentTunnelConn(stream, func() { stream.events = append(stream.events, "cancel") })

	require.NoError(t, conn.Close())
	assert.Equal(t, []string{"close_send", "cancel"}, stream.events)

	// A second close is a no-op.
	require.NoError(t, conn.Close())
	assert.Equal(t, []string{"close_send", "cancel"}, stream.events)
}