Skip to content

Lightweight server monitoring with historical data, docker stats, and alerts.

4.1 KB
Raw Blame
//go:build testing

package agent

import (
	"context"
	"crypto/ed25519"
	"net"
	"net/http"
	"net/http/httptest"
	"testing"
	"time"

	"github.com/stretchr/testify/require"
	"golang.org/x/crypto/ssh"
)

func TestAgentCancellationReleasesListener(t *testing.T) {
	t.Setenv("BESZEL_AGENT_HUB_URL", "")
	opts := createTestServerOptions(t)
	for range 2 {
		a := createTestAgent(t)
		ctx, cancel := context.WithCancel(t.Context())
		done := make(chan error, 1)
		go func() { done <- a.Start(ctx, opts) }()
		require.Eventually(t, func() bool {
			conn, err := net.DialTimeout("tcp", opts.Addr, 20*time.Millisecond)
			if err != nil {
				return false
			}
			conn.Close()
			return true
		}, 2*time.Second, 10*time.Millisecond)
		cancel()
		requireAgentStopped(t, done, "agent did not stop after cancellation")
		requirePortReleased(t, opts.Addr)
	}
}

func TestAgentCancellationJoinsReconnect(t *testing.T) {
	hub := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		http.Error(w, "unavailable", http.StatusServiceUnavailable)
	}))
	defer hub.Close()
	t.Setenv("BESZEL_AGENT_HUB_URL", hub.URL)
	t.Setenv("BESZEL_AGENT_TOKEN", "test-token")
	a := createTestAgent(t)
	opts := createTestServerOptions(t)
	_, key, err := ed25519.GenerateKey(nil)
	require.NoError(t, err)
	signer, err := ssh.NewSignerFromKey(key)
	require.NoError(t, err)
	opts.Keys = []ssh.PublicKey{signer.PublicKey()}
	ctx, cancel := context.WithCancel(t.Context())
	defer cancel()
	done := make(chan error, 1)
	go func() { done <- a.Start(ctx, opts) }()
	var client *ssh.Client
	require.Eventually(t, func() bool {
		client, err = ssh.Dial("tcp", opts.Addr, &ssh.ClientConfig{
			User: "test", Auth: []ssh.AuthMethod{ssh.PublicKeys(signer)},
			HostKeyCallback: ssh.InsecureIgnoreHostKey(), Timeout: time.Second,
		})
		return err == nil
	}, 2*time.Second, 10*time.Millisecond)
	defer client.Close()
	session, err := client.NewSession()
	require.NoError(t, err)
	require.NoError(t, session.Shell())
	cm := a.connectionManager
	require.Eventually(t, func() bool { return cm.getState() == SSHConnected }, time.Second, time.Millisecond)
	require.NoError(t, client.Close())
	require.Eventually(t, cm.isConnectingNow, time.Second, time.Millisecond)
	cancel()
	requireAgentStopped(t, done, "agent did not join its pending reconnect")
	require.False(t, cm.isConnectingNow())
	requirePortReleased(t, opts.Addr)
}

// requireAgentStopped waits for Start to return after the context is cancelled.
// The window is a liveness bound, not a performance assertion: `go test ./...`
// runs packages in parallel, and on a loaded machine shutdown can take several
// seconds, which made a 2s wait flake.
func requireAgentStopped(t *testing.T, done <-chan error, msg string) {
	t.Helper()
	select {
	case err := <-done:
		require.NoError(t, err)
	case <-time.After(30 * time.Second):
		t.Fatal(msg)
	}
}

// requirePortReleased fails unless addr becomes bindable again. The kernel can
// hold the port for a moment after the agent closes its listener, so a single
// immediate bind flakes with "address already in use".
func requirePortReleased(t *testing.T, addr string) {
	t.Helper()
	require.Eventually(t, func() bool {
		listener, err := net.Listen("tcp", addr)
		if err != nil {
			return false
		}
		_ = listener.Close()
		return true
	}, 2*time.Second, 10*time.Millisecond, "stopped agent must release its listening port %s", addr)
}

func TestAgentCancellationDuringHandshake(t *testing.T) {
	entered := make(chan struct{})
	hub := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		close(entered)
		<-r.Context().Done()
	}))
	defer hub.Close()
	t.Setenv("BESZEL_AGENT_HUB_URL", hub.URL)
	t.Setenv("BESZEL_AGENT_TOKEN", "test-token")
	a := createTestAgent(t)
	opts := createTestServerOptions(t)
	ctx, cancel := context.WithCancel(t.Context())
	defer cancel()
	done := make(chan error, 1)
	go func() { done <- a.Start(ctx, opts) }()
	select {
	case <-entered:
	case <-time.After(2 * time.Second):
		t.Fatal("agent did not reach the HTTP upgrade")
	}
	cancel()
	requireAgentStopped(t, done, "agent did not cancel its pending handshake")
}