Skip to content

Modern Docker Management, Designed for Everyone

21.1 KB
Raw Blame
package edge

import (
	"context"
	"crypto/x509"
	"encoding/json"
	"encoding/pem"
	"errors"
	"io"
	"net/http"
	"net/http/httptest"
	"os"
	"path/filepath"
	"strings"
	"testing"
	"time"

	"github.com/coder/websocket"
	"github.com/coder/websocket/wsjson"
	"github.com/labstack/echo/v5"
	"github.com/stretchr/testify/assert"
	"github.com/stretchr/testify/require"
	"google.golang.org/grpc/codes"
	"google.golang.org/grpc/metadata"
	"google.golang.org/grpc/status"
)

func TestTunnelServer_HandleConnect(t *testing.T) {
	resolver := func(ctx context.Context, token string) (string, error) {
		if token == "valid-token" {
			return "env-connected", nil
		}
		return "", errors.New("invalid token")
	}

	statusCallbackCalled := make(chan struct{}, 1)
	callback := func(ctx context.Context, envID string, connected bool) {
		if envID == "env-connected" && connected {
			select {
			case statusCallbackCalled <- struct{}{}:
			default:
			}
		}
	}

	server := NewTunnelServerWithRegistry(GetRegistry(), resolver, callback)

	router := echo.New()
	router.GET("/connect", server.HandleConnect)

	ts := httptest.NewServer(router)
	defer ts.Close()

	// Test Success
	url := "ws" + strings.TrimPrefix(ts.URL, "http") + "/connect"
	headers := http.Header{}
	headers.Set(HeaderAgentToken, "valid-token")

	conn, resp, err := websocket.Dial(t.Context(), url, &websocket.DialOptions{HTTPHeader: headers})
	require.NoError(t, err)
	defer func() { _ = conn.CloseNow() }()

	assert.Equal(t, http.StatusSwitchingProtocols, resp.StatusCode)

	err = wsjson.Write(t.Context(), conn, &TunnelMessage{
		Type:          MessageTypeRegister,
		AgentToken:    "valid-token",
		AgentInstance: "agent-connected",
	})
	require.NoError(t, err)

	var registerResp TunnelMessage
	err = wsjson.Read(t.Context(), conn, &registerResp)
	require.NoError(t, err)
	assert.Equal(t, MessageTypeRegisterResponse, registerResp.Type)
	assert.True(t, registerResp.Accepted)

	// Check registry
	reg := GetRegistry()
	var tunnel *AgentTunnel
	require.Eventually(t, func() bool {
		var ok bool
		tunnel, ok = reg.Get("env-connected").Get()
		return ok && tunnel != nil && tunnel.SessionID != ""
	}, time.Second, 10*time.Millisecond)
	assert.Equal(t, "agent-connected", tunnel.AgentInstance)

	select {
	case <-statusCallbackCalled:
		// callback observed
	case <-time.After(1 * time.Second):
		require.FailNow(t, "timeout waiting for status callback")
	}

	// Test Heartbeat
	heartbeat := &TunnelMessage{
		ID:   "hb-1",
		Type: MessageTypeHeartbeat,
	}
	err = wsjson.Write(t.Context(), conn, heartbeat)
	require.NoError(t, err)

	// Should receive Ack
	var ack TunnelMessage
	err = wsjson.Read(t.Context(), conn, &ack)
	require.NoError(t, err)
	assert.Equal(t, MessageTypeHeartbeatAck, ack.Type)
	assert.Equal(t, "hb-1", ack.ID)

	// Test Response Delivery
	// 1. Setup pending request
	respCh := make(chan *TunnelMessage, 1)
	tunnel.Pending.Store("req-1", &PendingRequest{ResponseCh: respCh})

	// 2. Send response from agent
	respMsg := &TunnelMessage{
		ID:   "req-1",
		Type: MessageTypeResponse,
		Body: []byte("response"),
	}
	err = wsjson.Write(t.Context(), conn, respMsg)
	require.NoError(t, err)

	// 3. Verify received on channel
	select {
	case received := <-respCh:
		assert.Equal(t, "req-1", received.ID)
		assert.Equal(t, []byte("response"), received.Body)
	case <-time.After(1 * time.Second):
		require.FailNow(t, "timeout waiting for response")
	}

	// Test Stream Delivery
	// 1. Setup pending stream
	streamCh := make(chan *TunnelMessage, 1)
	tunnel.Pending.Store("stream-1", &PendingRequest{ResponseCh: streamCh})

	// 2. Send stream data from agent
	streamMsg := &TunnelMessage{
		ID:   "stream-1",
		Type: MessageTypeStreamData,
		Body: []byte("stream"),
	}
	err = wsjson.Write(t.Context(), conn, streamMsg)
	require.NoError(t, err)

	// 3. Verify received
	select {
	case received := <-streamCh:
		assert.Equal(t, "stream-1", received.ID)
	case <-time.After(1 * time.Second):
		require.FailNow(t, "timeout waiting for stream")
	}

	// Test Ignored/Unknown Messages
	ignoredMsg := &TunnelMessage{ID: "ignore", Type: MessageTypeRequest} // Request coming FROM agent is ignored/unexpected
	_ = wsjson.Write(t.Context(), conn, ignoredMsg)

	unknownMsg := &TunnelMessage{ID: "unknown", Type: "unknown_type"}
	_ = wsjson.Write(t.Context(), conn, unknownMsg)

	// Allow time for processing
	time.Sleep(100 * time.Millisecond)

	// Clean up; close the client first so the server-side close handshake
	// does not wait on a peer that is no longer reading.
	_ = conn.CloseNow()
	reg.Unregister("env-connected")
}

func TestTunnelServer_HandleConnect_AcceptsTokenAfterProxyTerminatedMTLS(t *testing.T) {
	server := NewTunnelServerWithRegistry(GetRegistry(), func(ctx context.Context, token string) (string, error) {
		if token == "valid-token" {
			return "env-proxy-mtls", nil
		}
		return "", errors.New("invalid token")
	}, nil)
	server.Config = &Config{
		EdgeMTLSMode: EdgeMTLSModeRequired,
		AppURL:       "https://manager.example.com",
	}

	router := echo.New()
	router.GET("/connect", server.HandleConnect)

	ts := httptest.NewServer(router)
	defer ts.Close()

	url := "ws" + strings.TrimPrefix(ts.URL, "http") + "/connect"
	headers := http.Header{}
	headers.Set(HeaderAgentToken, "valid-token")

	conn, resp, err := websocket.Dial(t.Context(), url, &websocket.DialOptions{HTTPHeader: headers})
	require.NoError(t, err)
	defer func() { _ = conn.CloseNow() }()
	require.Equal(t, http.StatusSwitchingProtocols, resp.StatusCode)

	err = wsjson.Write(t.Context(), conn, &TunnelMessage{
		Type:          MessageTypeRegister,
		AgentToken:    "valid-token",
		AgentInstance: "agent-proxy-mtls",
	})
	require.NoError(t, err)

	var registerResp TunnelMessage
	err = wsjson.Read(t.Context(), conn, &registerResp)
	require.NoError(t, err)
	require.Equal(t, MessageTypeRegisterResponse, registerResp.Type)
	require.True(t, registerResp.Accepted)
	require.Equal(t, "token", registerResp.SecurityMode)

	_ = conn.CloseNow()
	GetRegistry().Unregister("env-proxy-mtls")
}

func TestTunnelServer_HandleConnect_InvalidToken(t *testing.T) {
	resolver := func(ctx context.Context, token string) (string, error) {
		return "", errors.New("invalid")
	}

	server := NewTunnelServerWithRegistry(GetRegistry(), resolver, nil)
	router := echo.New()
	router.GET("/connect", server.HandleConnect)

	ts := httptest.NewServer(router)
	defer ts.Close()

	url := "ws" + strings.TrimPrefix(ts.URL, "http") + "/connect"
	headers := http.Header{}
	headers.Set(HeaderAgentToken, "bad-token")

	conn, resp, err := websocket.Dial(t.Context(), url, &websocket.DialOptions{HTTPHeader: headers})
	require.NoError(t, err)
	defer func() { _ = conn.CloseNow() }()
	assert.Equal(t, http.StatusSwitchingProtocols, resp.StatusCode)

	err = wsjson.Write(t.Context(), conn, &TunnelMessage{Type: MessageTypeRegister, AgentToken: "bad-token"})
	require.NoError(t, err)

	var registerResp TunnelMessage
	err = wsjson.Read(t.Context(), conn, &registerResp)
	require.NoError(t, err)
	assert.Equal(t, MessageTypeRegisterResponse, registerResp.Type)
	assert.False(t, registerResp.Accepted)
	assert.Equal(t, "invalid agent token", registerResp.Error)
}

func TestTunnelServer_HandleConnect_PrefersHeaderTokenOverRegisterMessage(t *testing.T) {
	var resolvedToken string
	resolver := func(ctx context.Context, token string) (string, error) {
		resolvedToken = token
		if token == "valid-token" {
			return "env-header-token", nil
		}
		return "", errors.New("invalid token")
	}

	server := NewTunnelServerWithRegistry(GetRegistry(), resolver, nil)
	router := echo.New()
	router.GET("/connect", server.HandleConnect)

	ts := httptest.NewServer(router)
	defer ts.Close()

	url := "ws" + strings.TrimPrefix(ts.URL, "http") + "/connect"
	headers := http.Header{}
	headers.Set(HeaderAgentToken, "valid-token")

	conn, resp, err := websocket.Dial(t.Context(), url, &websocket.DialOptions{HTTPHeader: headers})
	require.NoError(t, err)
	defer func() { _ = conn.CloseNow() }()
	require.Equal(t, http.StatusSwitchingProtocols, resp.StatusCode)

	err = wsjson.Write(t.Context(), conn, &TunnelMessage{Type: MessageTypeRegister, AgentToken: "bad-token"})
	require.NoError(t, err)

	var registerResp TunnelMessage
	err = wsjson.Read(t.Context(), conn, &registerResp)
	require.NoError(t, err)
	require.Equal(t, MessageTypeRegisterResponse, registerResp.Type)
	require.True(t, registerResp.Accepted)
	require.Equal(t, "valid-token", resolvedToken)

	_ = conn.CloseNow()
	GetRegistry().Unregister("env-header-token")
}

func TestTunnelServer_HandleConnect_NoToken(t *testing.T) {
	server := NewTunnelServerWithRegistry(GetRegistry(), nil, nil)
	router := echo.New()
	router.GET("/connect", server.HandleConnect)

	ts := httptest.NewServer(router)
	defer ts.Close()

	url := "ws" + strings.TrimPrefix(ts.URL, "http") + "/connect"

	conn, resp, err := websocket.Dial(t.Context(), url, nil)
	require.NoError(t, err)
	defer func() { _ = conn.CloseNow() }()
	assert.Equal(t, http.StatusSwitchingProtocols, resp.StatusCode)

	err = wsjson.Write(t.Context(), conn, &TunnelMessage{Type: MessageTypeRegister})
	require.NoError(t, err)

	var registerResp TunnelMessage
	err = wsjson.Read(t.Context(), conn, &registerResp)
	require.NoError(t, err)
	require.Equal(t, MessageTypeRegisterResponse, registerResp.Type)
	require.False(t, registerResp.Accepted)
	require.Equal(t, "agent token required", registerResp.Error)
}

func TestTunnelConnectRouteRegistration(t *testing.T) {
	router := echo.New()
	group := router.Group("/api")

	server := NewTunnelServerWithRegistry(GetRegistry(), nil, nil)
	group.GET("/tunnel/connect", server.HandleConnect)

	// Verify route exists (simplistic check by trying to hit it)
	w := httptest.NewRecorder()
	req := httptest.NewRequest(http.MethodGet, "/api/tunnel/connect", http.NoBody)
	router.ServeHTTP(w, req)

	// Plain HTTP requests hit the route but fail the websocket upgrade;
	// coder/websocket responds with 426 Upgrade Required.
	assert.Equal(t, http.StatusUpgradeRequired, w.Code)
}

func TestTunnelServer_HandleMTLSEnroll(t *testing.T) {
	server := NewTunnelServerWithRegistry(GetRegistry(), func(ctx context.Context, token string) (string, error) {
		if token != "valid-token" {
			return "", errors.New("invalid token")
		}
		return "env-mtls", nil
	}, nil)
	server.NameResolver = func(ctx context.Context, environmentID string) (string, error) {
		require.Equal(t, "env-mtls", environmentID)
		return "Lab Server", nil
	}
	server.Config = &Config{
		EdgeMTLSMode:      EdgeMTLSModeRequired,
		EdgeMTLSAssetsDir: t.TempDir(),
	}

	router := echo.New()
	router.POST("/enroll", server.HandleMTLSEnroll)

	req := httptest.NewRequest(http.MethodPost, "/enroll", http.NoBody)
	req.Header.Set(HeaderAgentToken, "valid-token")
	w := httptest.NewRecorder()
	router.ServeHTTP(w, req)

	require.Equal(t, http.StatusOK, w.Code)
	require.Equal(t, "no-store", w.Header().Get("Cache-Control"))
	require.Equal(t, "no-cache", w.Header().Get("Pragma"))

	var resp enrollMTLSResponse
	require.NoError(t, json.Unmarshal(w.Body.Bytes(), &resp))
	require.Len(t, resp.Files, 3)
	assert.Equal(t, "ca.crt", resp.Files[0].Name)
	assert.Contains(t, resp.Files[0].Content, "BEGIN CERTIFICATE")
	assert.Equal(t, "agent.key", resp.Files[2].Name)
	assert.Contains(t, resp.Files[2].Content, "BEGIN PRIVATE KEY")

	certBlock, _ := pem.Decode([]byte(resp.Files[1].Content))
	require.NotNil(t, certBlock)

	cert, err := x509.ParseCertificate(certBlock.Bytes)
	require.NoError(t, err)
	assert.Equal(t, "Lab-Server-env-mtls", cert.Subject.CommonName)
}

func TestTunnelServer_HandleMTLSEnroll_ServesCachedAssetsDuringCooldown(t *testing.T) {
	server := NewTunnelServerWithRegistry(GetRegistry(), func(ctx context.Context, token string) (string, error) {
		if token != "valid-token" {
			return "", errors.New("invalid token")
		}
		return "env-repeat", nil
	}, nil)
	server.Config = &Config{
		EdgeMTLSMode:      EdgeMTLSModeRequired,
		EdgeMTLSAssetsDir: t.TempDir(),
	}

	router := echo.New()
	router.POST("/enroll", server.HandleMTLSEnroll)

	req := httptest.NewRequest(http.MethodPost, "/enroll", http.NoBody)
	req.Header.Set(HeaderAgentToken, "valid-token")
	w := httptest.NewRecorder()
	router.ServeHTTP(w, req)
	require.Equal(t, http.StatusOK, w.Code)

	var firstResp enrollMTLSResponse
	require.NoError(t, json.Unmarshal(w.Body.Bytes(), &firstResp))
	require.Len(t, firstResp.Files, 3)

	req = httptest.NewRequest(http.MethodPost, "/enroll", http.NoBody)
	req.Header.Set(HeaderAgentToken, "valid-token")
	w = httptest.NewRecorder()
	router.ServeHTTP(w, req)
	require.Equal(t, http.StatusOK, w.Code)

	var secondResp enrollMTLSResponse
	require.NoError(t, json.Unmarshal(w.Body.Bytes(), &secondResp))
	require.Equal(t, firstResp.Files, secondResp.Files)
}

func TestTunnelServer_HandleMTLSEnroll_AllowsRepeatAfterCooldownAndMarksReenrollment(t *testing.T) {
	cfg := &Config{
		EdgeMTLSMode:      EdgeMTLSModeRequired,
		EdgeMTLSAssetsDir: t.TempDir(),
	}
	server := NewTunnelServerWithRegistry(GetRegistry(), func(ctx context.Context, token string) (string, error) {
		if token != "valid-token" {
			return "", errors.New("invalid token")
		}
		return "env-repeat-old", nil
	}, nil)
	server.Config = cfg

	reenrolled := make(chan bool, 2)
	server.EnrollmentCallback = func(ctx context.Context, environmentID, remoteAddr string, certIssued, caGenerated, wasReenrolled bool) {
		require.Equal(t, "env-repeat-old", environmentID)
		reenrolled <- wasReenrolled
	}

	router := echo.New()
	router.POST("/enroll", server.HandleMTLSEnroll)

	req := httptest.NewRequest(http.MethodPost, "/enroll", http.NoBody)
	req.Header.Set(HeaderAgentToken, "valid-token")
	w := httptest.NewRecorder()
	router.ServeHTTP(w, req)
	require.Equal(t, http.StatusOK, w.Code)
	require.False(t, <-reenrolled)

	markerPath := filepath.Join(cfg.EdgeMTLSAssetsDir, generatedClientMTLSSubdir, "env-repeat-old", generatedMTLSEnrolledName)
	oldEnrollment := time.Now().Add(-(managerMTLSReenrollCooldown + time.Minute)).UTC().Format(time.RFC3339Nano) + "\n"
	require.NoError(t, os.WriteFile(markerPath, []byte(oldEnrollment), 0o600))

	req = httptest.NewRequest(http.MethodPost, "/enroll", http.NoBody)
	req.Header.Set(HeaderAgentToken, "valid-token")
	w = httptest.NewRecorder()
	router.ServeHTTP(w, req)
	require.Equal(t, http.StatusOK, w.Code)
	require.True(t, <-reenrolled)
}

func TestTunnelServer_CleanupLoop(t *testing.T) {
	server := NewTunnelServerWithRegistry(GetRegistry(), nil, nil)
	ctx, cancel := context.WithCancel(t.Context())

	// Run cleanup loop
	go server.StartCleanupLoop(ctx)

	// Just ensure it doesn't panic and stops when ctx is cancelled
	time.Sleep(10 * time.Millisecond)
	cancel()
	time.Sleep(10 * time.Millisecond)
}

func TestTunnelServer_resolveEnvironment_TrimsToken(t *testing.T) {
	var resolvedToken string
	server := NewTunnelServerWithRegistry(GetRegistry(), func(ctx context.Context, token string) (string, error) {
		resolvedToken = token
		return "env-trimmed", nil
	}, nil)

	envID, err := server.resolveEnvironment(t.Context(), "  valid-token  ")
	require.NoError(t, err)
	assert.Equal(t, "env-trimmed", envID)
	assert.Equal(t, "valid-token", resolvedToken)
}

func TestTunnelServer_resolveEnvironment_Errors(t *testing.T) {
	t.Run("missing resolver", func(t *testing.T) {
		server := NewTunnelServerWithRegistry(GetRegistry(), nil, nil)
		_, err := server.resolveEnvironment(t.Context(), "token")
		require.Error(t, err)
		assert.Contains(t, err.Error(), "edge resolver is not configured")
	})

	t.Run("missing token", func(t *testing.T) {
		server := NewTunnelServerWithRegistry(GetRegistry(), func(ctx context.Context, token string) (string, error) {
			return "env", nil
		}, nil)

		_, err := server.resolveEnvironment(t.Context(), "   ")
		require.Error(t, err)
		assert.Contains(t, err.Error(), "agent token required")
	})
}

func TestAgentToken(t *testing.T) {
	t.Run("prefers agent token and trims whitespace", func(t *testing.T) {
		md := metadata.Pairs(
			strings.ToLower(HeaderAgentToken), "  agent-token  ",
			strings.ToLower(HeaderAPIKey), "api-token",
		)

		token, source := agentToken(md.Get)
		assert.Equal(t, "agent-token", token)
		assert.Equal(t, HeaderAgentToken, source)
	})

	t.Run("falls back to api key", func(t *testing.T) {
		md := metadata.Pairs(strings.ToLower(HeaderAPIKey), "api-token")

		token, source := agentToken(md.Get)
		assert.Equal(t, "api-token", token)
		assert.Equal(t, HeaderAPIKey, source)
	})

	t.Run("returns empty when metadata missing", func(t *testing.T) {
		var md metadata.MD
		token, source := agentToken(md.Get)
		assert.Empty(t, token)
		assert.Empty(t, source)
	})
}

func TestIsExpectedTunnelReceiveError(t *testing.T) {
	t.Run("nil is not expected", func(t *testing.T) {
		assert.False(t, isExpectedReceiveError(nil))
	})

	t.Run("io eof expected", func(t *testing.T) {
		assert.True(t, isExpectedReceiveError(io.EOF))
	})

	t.Run("context canceled expected", func(t *testing.T) {
		assert.True(t, isExpectedReceiveError(context.Canceled))
	})

	t.Run("context deadline expected", func(t *testing.T) {
		assert.True(t, isExpectedReceiveError(context.DeadlineExceeded))
	})

	t.Run("grpc canceled expected", func(t *testing.T) {
		err := status.Error(codes.Canceled, "context canceled")
		assert.True(t, isExpectedReceiveError(err))
	})

	t.Run("grpc deadline exceeded expected", func(t *testing.T) {
		err := status.Error(codes.DeadlineExceeded, "deadline exceeded")
		assert.True(t, isExpectedReceiveError(err))
	})

	t.Run("unexpected error not expected", func(t *testing.T) {
		assert.False(t, isExpectedReceiveError(errors.New("boom")))
	})
}

func TestTunnelServer_HandleEventCallback(t *testing.T) {
	called := make(chan struct{}, 1)
	registry := NewTunnelRegistry()
	server := NewTunnelServerWithRegistry(registry, nil, nil)
	server.EventCallback = func(ctx context.Context, environmentID string, event *TunnelEvent) error {
		assert.Equal(t, "env-edge", environmentID)
		require.NotNil(t, event)
		assert.Equal(t, "container.start", event.Type)
		assert.Equal(t, "Container started", event.Title)
		select {
		case called <- struct{}{}:
		default:
		}
		return nil
	}

	conn := &fakeServerTunnelConn{messages: []*TunnelMessage{{
		Type: MessageTypeEvent,
		Event: &TunnelEvent{
			Type:  "container.start",
			Title: "Container started",
		},
	}}}
	server.manageConnectedTunnel(t.Context(), "env-edge", conn, &TunnelMessage{Type: MessageTypeRegister}, "token")

	select {
	case <-called:
	case <-time.After(2 * time.Second):
		require.FailNow(t, "timeout waiting for event callback")
	}

	stopCtx, cancelStop := context.WithTimeout(t.Context(), time.Second)
	defer cancelStop()
	require.NoError(t, registry.Stop(stopCtx))
}

// fakeServerTunnelConn delivers messages in order, then reports EOF.
type fakeServerTunnelConn struct {
	messages []*TunnelMessage
}

func (f *fakeServerTunnelConn) Send(msg *TunnelMessage) error { return nil }

func (f *fakeServerTunnelConn) Receive() (*TunnelMessage, error) {
	if len(f.messages) == 0 {
		return nil, io.EOF
	}
	msg := f.messages[0]
	f.messages = f.messages[1:]
	return msg, nil
}

func (f *fakeServerTunnelConn) IsExpectedReceiveError(error) bool { return false }

func (f *fakeServerTunnelConn) Close() error { return nil }

func (f *fakeServerTunnelConn) IsClosed() bool { return false }

func (f *fakeServerTunnelConn) Transport() string { return EdgeTransportWebSocket }

type registerResponseOrderConn struct {
	sendHook func(*TunnelMessage) error
	recvErr  error
}

func (f *registerResponseOrderConn) Send(msg *TunnelMessage) error {
	if f.sendHook != nil {
		return f.sendHook(msg)
	}
	return nil
}

func (f *registerResponseOrderConn) Receive() (*TunnelMessage, error) {
	if f.recvErr != nil {
		return nil, f.recvErr
	}
	return nil, io.EOF
}

func (f *registerResponseOrderConn) IsExpectedReceiveError(error) bool { return false }

func (f *registerResponseOrderConn) Close() error { return nil }

func (f *registerResponseOrderConn) IsClosed() bool { return false }

func (f *registerResponseOrderConn) Transport() string { return EdgeTransportGRPC }

func TestTunnelServer_ManageConnectedTunnel_RegistersBeforeSendingGRPCRegisterResponse(t *testing.T) {
	server := NewTunnelServerWithRegistry(GetRegistry(), nil, nil)
	envID := "env-grpc-register-order"
	server.registry.Unregister(envID)
	t.Cleanup(func() { server.registry.Unregister(envID) })

	conn := &registerResponseOrderConn{recvErr: io.EOF}
	conn.sendHook = func(msg *TunnelMessage) error {
		require.Equal(t, MessageTypeRegisterResponse, msg.Type)
		_, ok := server.registry.Get(envID).Get()
		assert.True(t, ok, "gRPC tunnel should already be registered when the register response is sent")
		return nil
	}

	server.manageConnectedTunnel(t.Context(), envID, conn, &TunnelMessage{Type: MessageTypeRegister}, "token")

	_, ok := server.registry.Get(envID).Get()
	assert.False(t, ok)
}

func TestTunnelServer_ManageConnectedTunnel_UnregistersAfterConnectionContextCancellation(t *testing.T) {
	registry := NewTunnelRegistry()
	server := NewTunnelServerWithRegistry(registry, nil, nil)
	envID := "env-cancelled-disconnect"
	conn := &registerResponseOrderConn{recvErr: context.Canceled}

	connectionCtx, cancelConnection := context.WithCancel(t.Context())
	cancelConnection()
	server.manageConnectedTunnel(connectionCtx, envID, conn, &TunnelMessage{Type: MessageTypeRegister}, "token")

	_, ok := registry.Get(envID).Get()
	require.False(t, ok)

	stopCtx, cancelStop := context.WithTimeout(t.Context(), time.Second)
	defer cancelStop()
	require.NoError(t, registry.Stop(stopCtx))
}