Real-time monitoring dashboard for Proxmox VE, PBS, Docker, Kubernetes, TrueNAS and vSphere. Self-hosted, with alerts for failed backups, full disks, unhealthy containers and offline nodes.
Go aialertsdashboarddockerdocker-monitoringgohomelabinfrastructure-monitoringkubernetesmonitoringmspproxmoxproxmox-backup-serverproxmox-mail-gatewayproxmox-veself-hostedtruenastypescriptvspherewebhooks
package api
import (
"encoding/json"
"fmt"
"net/http"
"net/http/httptest"
"net/url"
"strings"
"testing"
"github.com/rcourtman/pulse-go-rewrite/internal/config"
"github.com/rcourtman/pulse-go-rewrite/internal/relay"
internalauth "github.com/rcourtman/pulse-go-rewrite/pkg/auth"
)
func TestOnboardingQRPayloadStructure(t *testing.T) {
router, rawToken, _ := newOnboardingContractRouter(t)
wantRelayURL := "wss://relay.example.test/ws/app"
req := httptest.NewRequest(http.MethodGet, "https://pulse.example.test/api/onboarding/qr", nil)
req.Header.Set("X-API-Token", rawToken)
rec := httptest.NewRecorder()
router.handleGetOnboardingQR(rec, req)
if rec.Code != http.StatusOK {
t.Fatalf("expected status 200, got %d", rec.Code)
}
var payload onboardingQRResponse
if err := json.NewDecoder(rec.Body).Decode(&payload); err != nil {
t.Fatalf("decode QR response: %v", err)
}
if payload.Schema != onboardingSchemaVersion {
t.Fatalf("unexpected schema: got %q want %q", payload.Schema, onboardingSchemaVersion)
}
if payload.InstanceURL != "https://pulse.example.test" {
t.Fatalf("unexpected instance_url: %q", payload.InstanceURL)
}
if payload.InstanceID != "instance-local" {
t.Fatalf("unexpected instance_id: got %q want %q", payload.InstanceID, "instance-local")
}
if payload.Relay.URL != wantRelayURL {
t.Fatalf("unexpected relay URL: got %q want %q", payload.Relay.URL, wantRelayURL)
}
if !payload.Relay.Enabled {
t.Fatalf("expected relay.enabled=true")
}
if payload.AuthToken != rawToken {
t.Fatalf("unexpected auth token in QR payload")
}
if payload.DeepLink == "" {
t.Fatalf("expected deep_link to be populated")
}
}
func TestOnboardingQROmitsNonHTTPSInstanceURL(t *testing.T) {
router, rawToken, _ := newOnboardingContractRouter(t)
router.config.PublicURL = ""
router.config.AgentConnectURL = ""
req := httptest.NewRequest(http.MethodGet, "http://pulse.local.test/api/onboarding/qr", nil)
req.Header.Set("X-API-Token", rawToken)
rec := httptest.NewRecorder()
router.handleGetOnboardingQR(rec, req)
if rec.Code != http.StatusOK {
t.Fatalf("expected status 200, got %d: %s", rec.Code, rec.Body.String())
}
body := rec.Body.String()
var raw map[string]json.RawMessage
if err := json.Unmarshal([]byte(body), &raw); err != nil {
t.Fatalf("decode raw QR response: %v", err)
}
if _, ok := raw["instance_url"]; ok {
t.Fatalf("expected unsafe top-level instance_url to be omitted from QR response, got %s", body)
}
var payload onboardingQRResponse
if err := json.NewDecoder(strings.NewReader(body)).Decode(&payload); err != nil {
t.Fatalf("decode QR response: %v", err)
}
if payload.InstanceURL != "" {
t.Fatalf("expected empty instance_url, got %q", payload.InstanceURL)
}
if strings.Contains(payload.DeepLink, "instance_url") {
t.Fatalf("expected unsafe instance_url to be omitted from deep link, got %q", payload.DeepLink)
}
if !diagnosticCodePresent(payload.Diagnostics, "instance_url_not_https") {
t.Fatalf("expected instance_url_not_https diagnostic, got %#v", payload.Diagnostics)
}
}
func TestOnboardingQRRejectsIncompleteRelayRegistration(t *testing.T) {
router, rawToken, _ := newOnboardingContractRouter(t)
router.relayClient = nil
req := httptest.NewRequest(http.MethodGet, "https://pulse.example.test/api/onboarding/qr", nil)
req.Header.Set("X-API-Token", rawToken)
rec := httptest.NewRecorder()
router.handleGetOnboardingQR(rec, req)
if rec.Code != http.StatusConflict {
t.Fatalf("expected status 409, got %d: %s", rec.Code, rec.Body.String())
}
var response onboardingNotReadyResponse
if err := json.NewDecoder(rec.Body).Decode(&response); err != nil {
t.Fatalf("decode not-ready response: %v", err)
}
if response.Code != onboardingNotReadyCode {
t.Fatalf("unexpected code: got %q want %q", response.Code, onboardingNotReadyCode)
}
if !diagnosticCodePresent(response.Diagnostics, "relay_registration_unavailable") {
t.Fatalf("expected relay_registration_unavailable diagnostic, got %#v", response.Diagnostics)
}
}
func TestOnboardingQRRejectsMissingMobileToken(t *testing.T) {
router, _, _ := newOnboardingContractRouter(t)
req := httptest.NewRequest(http.MethodGet, "https://pulse.example.test/api/onboarding/qr", nil)
rec := httptest.NewRecorder()
router.handleGetOnboardingQR(rec, req)
if rec.Code != http.StatusConflict {
t.Fatalf("expected status 409, got %d: %s", rec.Code, rec.Body.String())
}
var response onboardingNotReadyResponse
if err := json.NewDecoder(rec.Body).Decode(&response); err != nil {
t.Fatalf("decode not-ready response: %v", err)
}
if !diagnosticCodePresent(response.Diagnostics, "auth_token_missing") {
t.Fatalf("expected auth_token_missing diagnostic, got %#v", response.Diagnostics)
}
}
func TestOnboardingValidateSuccessAndFailure(t *testing.T) {
router, rawToken, _ := newOnboardingContractRouter(t)
successBody := fmt.Sprintf(`{"instance_id":"instance-local","relay_url":"%s","auth_token":"%s"}`, "wss://relay.example.test/ws/app", rawToken)
successReq := httptest.NewRequest(http.MethodPost, "/api/onboarding/validate", strings.NewReader(successBody))
successRec := httptest.NewRecorder()
router.handleValidateOnboardingConnection(successRec, successReq)
if successRec.Code != http.StatusOK {
t.Fatalf("expected status 200 for success path, got %d", successRec.Code)
}
var successResp onboardingValidationResponse
if err := json.NewDecoder(successRec.Body).Decode(&successResp); err != nil {
t.Fatalf("decode success response: %v", err)
}
if !successResp.Success {
t.Fatalf("expected success=true, got false with diagnostics: %#v", successResp.Diagnostics)
}
if hasOnboardingError(successResp.Diagnostics) {
t.Fatalf("expected no error diagnostics on success path, got %#v", successResp.Diagnostics)
}
failureBody := `{"instance_id":"instance-local","relay_url":"https://relay.example.test/ws/instance","auth_token":"bad-token"}`
failureReq := httptest.NewRequest(http.MethodPost, "/api/onboarding/validate", strings.NewReader(failureBody))
failureRec := httptest.NewRecorder()
router.handleValidateOnboardingConnection(failureRec, failureReq)
if failureRec.Code != http.StatusOK {
t.Fatalf("expected status 200 for failure path, got %d", failureRec.Code)
}
var failureResp onboardingValidationResponse
if err := json.NewDecoder(failureRec.Body).Decode(&failureResp); err != nil {
t.Fatalf("decode failure response: %v", err)
}
if failureResp.Success {
t.Fatalf("expected success=false for invalid payload")
}
if !diagnosticCodePresent(failureResp.Diagnostics, "relay_url_invalid") {
t.Fatalf("expected relay_url_invalid diagnostic, got %#v", failureResp.Diagnostics)
}
if !diagnosticCodePresent(failureResp.Diagnostics, "auth_token_invalid") {
t.Fatalf("expected auth_token_invalid diagnostic, got %#v", failureResp.Diagnostics)
}
}
func TestOnboardingDeepLinkFormat(t *testing.T) {
router, rawToken, _ := newOnboardingContractRouter(t)
req := httptest.NewRequest(http.MethodGet, "https://pulse.example.test/api/onboarding/deep-link", nil)
req.Header.Set("Authorization", "Bearer "+rawToken)
rec := httptest.NewRecorder()
router.handleGetOnboardingDeepLink(rec, req)
if rec.Code != http.StatusOK {
t.Fatalf("expected status 200, got %d", rec.Code)
}
var response onboardingDeepLinkResponse
if err := json.NewDecoder(rec.Body).Decode(&response); err != nil {
t.Fatalf("decode deep-link response: %v", err)
}
if response.URL == "" {
t.Fatalf("expected deep-link URL in response")
}
parsed, err := url.Parse(response.URL)
if err != nil {
t.Fatalf("parse deep-link URL: %v", err)
}
if parsed.Scheme != "pulse" {
t.Fatalf("unexpected deep-link scheme: %q", parsed.Scheme)
}
if parsed.Host != "connect" {
t.Fatalf("unexpected deep-link host: %q", parsed.Host)
}
query := parsed.Query()
if query.Get("schema") != onboardingSchemaVersion {
t.Fatalf("unexpected deep-link schema: %q", query.Get("schema"))
}
if query.Get("instance_url") != "https://pulse.example.test" {
t.Fatalf("unexpected deep-link instance_url: %q", query.Get("instance_url"))
}
if query.Get("relay_url") != "wss://relay.example.test/ws/app" {
t.Fatalf("unexpected deep-link relay_url: got %q want %q", query.Get("relay_url"), "wss://relay.example.test/ws/app")
}
if query.Get("auth_token") != rawToken {
t.Fatalf("unexpected deep-link auth_token")
}
}
func TestOnboardingDeepLinkRejectsIncompleteRelayRegistration(t *testing.T) {
router, rawToken, _ := newOnboardingContractRouter(t)
router.relayClient = nil
req := httptest.NewRequest(http.MethodGet, "https://pulse.example.test/api/onboarding/deep-link", nil)
req.Header.Set("Authorization", "Bearer "+rawToken)
rec := httptest.NewRecorder()
router.handleGetOnboardingDeepLink(rec, req)
if rec.Code != http.StatusConflict {
t.Fatalf("expected status 409, got %d: %s", rec.Code, rec.Body.String())
}
var response onboardingNotReadyResponse
if err := json.NewDecoder(rec.Body).Decode(&response); err != nil {
t.Fatalf("decode not-ready response: %v", err)
}
if !diagnosticCodePresent(response.Diagnostics, "relay_registration_unavailable") {
t.Fatalf("expected relay_registration_unavailable diagnostic, got %#v", response.Diagnostics)
}
}
func TestOnboardingResponsesUseCanonicalEmptyCollections(t *testing.T) {
qrJSON, err := json.Marshal(emptyOnboardingQRResponse())
if err != nil {
t.Fatalf("marshal empty onboarding QR response: %v", err)
}
if !strings.Contains(string(qrJSON), `"diagnostics":[]`) {
t.Fatalf("expected empty onboarding QR response to retain diagnostics array, got %s", qrJSON)
}
deepLinkJSON, err := json.Marshal(emptyOnboardingDeepLinkResponse())
if err != nil {
t.Fatalf("marshal empty onboarding deep-link response: %v", err)
}
if !strings.Contains(string(deepLinkJSON), `"diagnostics":[]`) {
t.Fatalf("expected empty onboarding deep-link response to retain diagnostics array, got %s", deepLinkJSON)
}
validationJSON, err := json.Marshal(emptyOnboardingValidationResponse())
if err != nil {
t.Fatalf("marshal empty onboarding validation response: %v", err)
}
if !strings.Contains(string(validationJSON), `"diagnostics":[]`) {
t.Fatalf("expected empty onboarding validation response to retain diagnostics array, got %s", validationJSON)
}
}
func TestNormalizeOnboardingRelayAppURL(t *testing.T) {
tests := []struct {
name string
in string
want string
}{
{
name: "instance endpoint becomes app endpoint",
in: "wss://relay.example.test/ws/instance",
want: "wss://relay.example.test/ws/app",
},
{
name: "bare relay host appends app endpoint",
in: "wss://relay.example.test",
want: "wss://relay.example.test/ws/app",
},
{
name: "existing app endpoint stays stable",
in: "wss://relay.example.test/ws/app",
want: "wss://relay.example.test/ws/app",
},
{
name: "invalid values fail closed to trimmed original",
in: "not-a-websocket-url",
want: "not-a-websocket-url",
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
if got := normalizeOnboardingRelayAppURL(tt.in); got != tt.want {
t.Fatalf("normalizeOnboardingRelayAppURL(%q) = %q, want %q", tt.in, got, tt.want)
}
})
}
}
func TestOnboardingAuthTokenFromRequest(t *testing.T) {
t.Run("prefers X-API-Token header", func(t *testing.T) {
req := httptest.NewRequest(http.MethodGet, "/api/onboarding/qr?auth_token=query-token", nil)
req.Header.Set("X-API-Token", " header-token ")
req.Header.Set("Authorization", "Bearer bearer-token")
if got := onboardingAuthTokenFromRequest(req); got != "header-token" {
t.Fatalf("expected X-API-Token header, got %q", got)
}
})
t.Run("falls back to bearer token", func(t *testing.T) {
req := httptest.NewRequest(http.MethodGet, "/api/onboarding/qr?auth_token=query-token", nil)
req.Header.Set("Authorization", "Bearer bearer-token")
if got := onboardingAuthTokenFromRequest(req); got != "bearer-token" {
t.Fatalf("expected bearer token, got %q", got)
}
})
t.Run("ignores query auth_token", func(t *testing.T) {
req := httptest.NewRequest(http.MethodGet, "/api/onboarding/qr?auth_token=query-token", nil)
if got := onboardingAuthTokenFromRequest(req); got != "" {
t.Fatalf("expected empty auth token, got %q", got)
}
})
}
func newOnboardingContractRouter(t *testing.T) (*Router, string, relay.Config) {
t.Helper()
dataPath := t.TempDir()
cfg := &config.Config{
DataPath: dataPath,
FrontendPort: 7655,
PublicURL: "https://pulse.example.test",
}
rawToken, err := internalauth.GenerateAPIToken()
if err != nil {
t.Fatalf("generate API token: %v", err)
}
record, err := config.NewAPITokenRecord(rawToken, "Onboarding test token", []string{config.ScopeWildcard})
if err != nil {
t.Fatalf("create token record: %v", err)
}
cfg.APITokens = append(cfg.APITokens, *record)
cfg.SortAPITokens()
router := &Router{
config: cfg,
persistence: config.NewConfigPersistence(dataPath),
relayClient: fakeRelayRuntimeClient{
status: relay.ClientStatus{
Connected: true,
InstanceID: "instance-local",
},
},
}
relayCfg := relay.Config{
Enabled: true,
ServerURL: "wss://relay.example.test/ws/instance",
IdentityPublicKey: "pub-key",
IdentityFingerprint: "AA:BB:CC",
}
if err := router.persistence.SaveRelayConfig(relayCfg); err != nil {
t.Fatalf("save relay config: %v", err)
}
return router, rawToken, relayCfg
}
type fakeRelayRuntimeClient struct {
status relay.ClientStatus
}
func (f fakeRelayRuntimeClient) Status() relay.ClientStatus {
return f.status
}
func (f fakeRelayRuntimeClient) Close() {}
func (f fakeRelayRuntimeClient) SendPushNotification(relay.PushNotificationPayload) error {
return nil
}
func diagnosticCodePresent(diagnostics []onboardingDiagnostic, code string) bool {
for _, diagnostic := range diagnostics {
if diagnostic.Code == code {
return true
}
}
return false
}