mirror of
https://github.com/juanfont/headscale.git
synced 2026-03-28 12:12:06 +01:00
init
This commit is contained in:
kradalby
372
integration/serve_cli_test.go
Normal file
372
integration/serve_cli_test.go
Normal file
@@ -0,0 +1,372 @@
|
||||
package integration
|
||||
|
||||
import (
|
||||
"context"
|
||||
"fmt"
|
||||
"net/http"
|
||||
"strings"
|
||||
"testing"
|
||||
"time"
|
||||
|
||||
"github.com/juanfont/headscale/integration/hsic"
|
||||
"github.com/juanfont/headscale/integration/tsic"
|
||||
"github.com/stretchr/testify/assert"
|
||||
)
|
||||
|
||||
func TestServeCommand(t *testing.T) {
|
||||
IntegrationSkip(t)
|
||||
|
||||
spec := ScenarioSpec{
|
||||
Users: []string{"serve-user"},
|
||||
}
|
||||
|
||||
scenario, err := NewScenario(spec)
|
||||
assertNoErr(t, err)
|
||||
defer scenario.ShutdownAssertNoPanics(t)
|
||||
|
||||
err = scenario.CreateHeadscaleEnv([]tsic.Option{}, hsic.WithTestName("cliserve"))
|
||||
assertNoErr(t, err)
|
||||
|
||||
headscale, err := scenario.Headscale()
|
||||
assertNoErr(t, err)
|
||||
|
||||
t.Run("test_serve_help", func(t *testing.T) {
|
||||
// Test serve command help
|
||||
result, err := headscale.Execute(
|
||||
[]string{
|
||||
"headscale",
|
||||
"serve",
|
||||
"--help",
|
||||
},
|
||||
)
|
||||
assertNoErr(t, err)
|
||||
|
||||
// Help text should contain expected information
|
||||
assert.Contains(t, result, "serve", "help should mention serve command")
|
||||
assert.Contains(t, result, "Launches the headscale server", "help should contain command description")
|
||||
})
|
||||
}
|
||||
|
||||
func TestServeCommandValidation(t *testing.T) {
|
||||
IntegrationSkip(t)
|
||||
|
||||
spec := ScenarioSpec{
|
||||
Users: []string{"serve-validation-user"},
|
||||
}
|
||||
|
||||
scenario, err := NewScenario(spec)
|
||||
assertNoErr(t, err)
|
||||
defer scenario.ShutdownAssertNoPanics(t)
|
||||
|
||||
err = scenario.CreateHeadscaleEnv([]tsic.Option{}, hsic.WithTestName("cliservevalidation"))
|
||||
assertNoErr(t, err)
|
||||
|
||||
headscale, err := scenario.Headscale()
|
||||
assertNoErr(t, err)
|
||||
|
||||
t.Run("test_serve_with_invalid_config", func(t *testing.T) {
|
||||
// Test serve command with invalid config file
|
||||
_, err := headscale.Execute(
|
||||
[]string{
|
||||
"headscale",
|
||||
"--config", "/nonexistent/config.yaml",
|
||||
"serve",
|
||||
},
|
||||
)
|
||||
// Should fail for invalid config file
|
||||
assert.Error(t, err, "should fail for invalid config file")
|
||||
})
|
||||
|
||||
t.Run("test_serve_with_extra_args", func(t *testing.T) {
|
||||
// Test serve command with unexpected extra arguments
|
||||
// Note: This is a tricky test since serve runs a server
|
||||
// We'll test that it accepts extra args without crashing immediately
|
||||
ctx, cancel := context.WithTimeout(context.Background(), 2*time.Second)
|
||||
defer cancel()
|
||||
|
||||
// Use a goroutine to test that the command doesn't immediately fail
|
||||
done := make(chan error, 1)
|
||||
go func() {
|
||||
_, err := headscale.Execute(
|
||||
[]string{
|
||||
"headscale",
|
||||
"serve",
|
||||
"extra",
|
||||
"args",
|
||||
},
|
||||
)
|
||||
done <- err
|
||||
}()
|
||||
|
||||
select {
|
||||
case err := <-done:
|
||||
// If it returns an error quickly, it should be about args validation
|
||||
// or config issues, not a panic
|
||||
if err != nil {
|
||||
assert.NotContains(t, err.Error(), "panic", "should not panic on extra arguments")
|
||||
}
|
||||
case <-ctx.Done():
|
||||
// If it times out, that's actually good - it means the server started
|
||||
// and didn't immediately crash due to extra arguments
|
||||
}
|
||||
})
|
||||
}
|
||||
|
||||
func TestServeCommandHealthCheck(t *testing.T) {
|
||||
IntegrationSkip(t)
|
||||
|
||||
spec := ScenarioSpec{
|
||||
Users: []string{"serve-health-user"},
|
||||
}
|
||||
|
||||
scenario, err := NewScenario(spec)
|
||||
assertNoErr(t, err)
|
||||
defer scenario.ShutdownAssertNoPanics(t)
|
||||
|
||||
err = scenario.CreateHeadscaleEnv([]tsic.Option{}, hsic.WithTestName("cliservehealth"))
|
||||
assertNoErr(t, err)
|
||||
|
||||
headscale, err := scenario.Headscale()
|
||||
assertNoErr(t, err)
|
||||
|
||||
t.Run("test_serve_health_endpoint", func(t *testing.T) {
|
||||
// Test that the serve command starts a server that responds to health checks
|
||||
// This is effectively testing that the server is running and accessible
|
||||
|
||||
// Get the server endpoint
|
||||
endpoint := headscale.GetEndpoint()
|
||||
assert.NotEmpty(t, endpoint, "headscale endpoint should not be empty")
|
||||
|
||||
// Make a simple HTTP request to verify the server is running
|
||||
healthURL := fmt.Sprintf("%s/health", endpoint)
|
||||
|
||||
// Use a timeout to avoid hanging
|
||||
client := &http.Client{
|
||||
Timeout: 5 * time.Second,
|
||||
}
|
||||
|
||||
resp, err := client.Get(healthURL)
|
||||
if err != nil {
|
||||
// If we can't connect, check if it's because server isn't ready
|
||||
assert.Contains(t, err.Error(), "connection",
|
||||
"health check failure should be connection-related if server not ready")
|
||||
} else {
|
||||
defer resp.Body.Close()
|
||||
// If we can connect, verify we get a reasonable response
|
||||
assert.True(t, resp.StatusCode >= 200 && resp.StatusCode < 500,
|
||||
"health endpoint should return reasonable status code")
|
||||
}
|
||||
})
|
||||
|
||||
t.Run("test_serve_api_endpoint", func(t *testing.T) {
|
||||
// Test that the serve command starts a server with API endpoints
|
||||
endpoint := headscale.GetEndpoint()
|
||||
assert.NotEmpty(t, endpoint, "headscale endpoint should not be empty")
|
||||
|
||||
// Try to access a known API endpoint (version info)
|
||||
// This tests that the gRPC gateway is running
|
||||
versionURL := fmt.Sprintf("%s/api/v1/version", endpoint)
|
||||
|
||||
client := &http.Client{
|
||||
Timeout: 5 * time.Second,
|
||||
}
|
||||
|
||||
resp, err := client.Get(versionURL)
|
||||
if err != nil {
|
||||
// Connection errors are acceptable if server isn't fully ready
|
||||
assert.Contains(t, err.Error(), "connection",
|
||||
"API endpoint failure should be connection-related if server not ready")
|
||||
} else {
|
||||
defer resp.Body.Close()
|
||||
// If we can connect, check that we get some response
|
||||
assert.True(t, resp.StatusCode >= 200 && resp.StatusCode < 500,
|
||||
"API endpoint should return reasonable status code")
|
||||
}
|
||||
})
|
||||
}
|
||||
|
||||
func TestServeCommandServerBehavior(t *testing.T) {
|
||||
IntegrationSkip(t)
|
||||
|
||||
spec := ScenarioSpec{
|
||||
Users: []string{"serve-behavior-user"},
|
||||
}
|
||||
|
||||
scenario, err := NewScenario(spec)
|
||||
assertNoErr(t, err)
|
||||
defer scenario.ShutdownAssertNoPanics(t)
|
||||
|
||||
err = scenario.CreateHeadscaleEnv([]tsic.Option{}, hsic.WithTestName("cliservebenavior"))
|
||||
assertNoErr(t, err)
|
||||
|
||||
headscale, err := scenario.Headscale()
|
||||
assertNoErr(t, err)
|
||||
|
||||
t.Run("test_serve_accepts_connections", func(t *testing.T) {
|
||||
// Test that the server accepts connections from clients
|
||||
// This is a basic integration test to ensure serve works
|
||||
|
||||
// Create a user for testing
|
||||
user := spec.Users[0]
|
||||
_, err := headscale.Execute(
|
||||
[]string{
|
||||
"headscale",
|
||||
"users",
|
||||
"create",
|
||||
user,
|
||||
},
|
||||
)
|
||||
assertNoErr(t, err)
|
||||
|
||||
// Create a pre-auth key
|
||||
result, err := headscale.Execute(
|
||||
[]string{
|
||||
"headscale",
|
||||
"preauthkeys",
|
||||
"create",
|
||||
"--user", user,
|
||||
"--output", "json",
|
||||
},
|
||||
)
|
||||
assertNoErr(t, err)
|
||||
|
||||
// Verify the preauth key creation worked
|
||||
assert.NotEmpty(t, result, "preauth key creation should produce output")
|
||||
assert.Contains(t, result, "key", "preauth key output should contain key field")
|
||||
})
|
||||
|
||||
t.Run("test_serve_handles_node_operations", func(t *testing.T) {
|
||||
// Test that the server can handle basic node operations
|
||||
_ = spec.Users[0] // Test user for context
|
||||
|
||||
// List nodes (should work even if empty)
|
||||
result, err := headscale.Execute(
|
||||
[]string{
|
||||
"headscale",
|
||||
"nodes",
|
||||
"list",
|
||||
"--output", "json",
|
||||
},
|
||||
)
|
||||
assertNoErr(t, err)
|
||||
|
||||
// Should return valid JSON array (even if empty)
|
||||
trimmed := strings.TrimSpace(result)
|
||||
assert.True(t, strings.HasPrefix(trimmed, "[") && strings.HasSuffix(trimmed, "]"),
|
||||
"nodes list should return JSON array")
|
||||
})
|
||||
|
||||
t.Run("test_serve_handles_user_operations", func(t *testing.T) {
|
||||
// Test that the server can handle user operations
|
||||
result, err := headscale.Execute(
|
||||
[]string{
|
||||
"headscale",
|
||||
"users",
|
||||
"list",
|
||||
"--output", "json",
|
||||
},
|
||||
)
|
||||
assertNoErr(t, err)
|
||||
|
||||
// Should return valid JSON array
|
||||
trimmed := strings.TrimSpace(result)
|
||||
assert.True(t, strings.HasPrefix(trimmed, "[") && strings.HasSuffix(trimmed, "]"),
|
||||
"users list should return JSON array")
|
||||
|
||||
// Should contain our test user
|
||||
assert.Contains(t, result, spec.Users[0], "users list should contain test user")
|
||||
})
|
||||
}
|
||||
|
||||
func TestServeCommandEdgeCases(t *testing.T) {
|
||||
IntegrationSkip(t)
|
||||
|
||||
spec := ScenarioSpec{
|
||||
Users: []string{"serve-edge-user"},
|
||||
}
|
||||
|
||||
scenario, err := NewScenario(spec)
|
||||
assertNoErr(t, err)
|
||||
defer scenario.ShutdownAssertNoPanics(t)
|
||||
|
||||
err = scenario.CreateHeadscaleEnv([]tsic.Option{}, hsic.WithTestName("cliserverecge"))
|
||||
assertNoErr(t, err)
|
||||
|
||||
headscale, err := scenario.Headscale()
|
||||
assertNoErr(t, err)
|
||||
|
||||
t.Run("test_serve_multiple_rapid_commands", func(t *testing.T) {
|
||||
// Test that the server can handle multiple rapid commands
|
||||
// This tests the server's ability to handle concurrent requests
|
||||
user := spec.Users[0]
|
||||
|
||||
// Create user first
|
||||
_, err := headscale.Execute(
|
||||
[]string{
|
||||
"headscale",
|
||||
"users",
|
||||
"create",
|
||||
user,
|
||||
},
|
||||
)
|
||||
assertNoErr(t, err)
|
||||
|
||||
// Execute multiple commands rapidly
|
||||
for i := 0; i < 3; i++ {
|
||||
result, err := headscale.Execute(
|
||||
[]string{
|
||||
"headscale",
|
||||
"users",
|
||||
"list",
|
||||
},
|
||||
)
|
||||
assertNoErr(t, err)
|
||||
assert.Contains(t, result, user, "users list should consistently contain test user")
|
||||
}
|
||||
})
|
||||
|
||||
t.Run("test_serve_handles_empty_commands", func(t *testing.T) {
|
||||
// Test that the server gracefully handles edge case commands
|
||||
_, err := headscale.Execute(
|
||||
[]string{
|
||||
"headscale",
|
||||
"--help",
|
||||
},
|
||||
)
|
||||
assertNoErr(t, err)
|
||||
|
||||
// Basic help should work
|
||||
result, err := headscale.Execute(
|
||||
[]string{
|
||||
"headscale",
|
||||
"--version",
|
||||
},
|
||||
)
|
||||
if err == nil {
|
||||
assert.NotEmpty(t, result, "version command should produce output")
|
||||
}
|
||||
})
|
||||
|
||||
t.Run("test_serve_handles_malformed_requests", func(t *testing.T) {
|
||||
// Test that the server handles malformed CLI requests gracefully
|
||||
_, err := headscale.Execute(
|
||||
[]string{
|
||||
"headscale",
|
||||
"nonexistent-command",
|
||||
},
|
||||
)
|
||||
// Should fail gracefully for non-existent commands
|
||||
assert.Error(t, err, "should fail gracefully for non-existent commands")
|
||||
|
||||
// Should not cause server to crash (we can still execute other commands)
|
||||
result, err := headscale.Execute(
|
||||
[]string{
|
||||
"headscale",
|
||||
"users",
|
||||
"list",
|
||||
},
|
||||
)
|
||||
assertNoErr(t, err)
|
||||
assert.NotEmpty(t, result, "server should still work after malformed request")
|
||||
})
|
||||
}
|
||||
Reference in New Issue
Block a user