Pulse/internal/remoteconfig/client_test.go

package remoteconfig

import (
	"context"
	"net/http"
	"net/http/httptest"
	"strings"
	"testing"
)

func TestClient_Fetch(t *testing.T) {
	t.Run("successful fetch with full config", func(t *testing.T) {
		ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
			if r.URL.Path != "/api/agents/host/agent-1/config" {
				t.Errorf("Expected path /api/agents/host/agent-1/config, got %s", r.URL.Path)
				w.WriteHeader(http.StatusNotFound)
				return
			}
			if r.Header.Get("Authorization") != "Bearer token-123" {
				t.Errorf("Expected Authorization header 'Bearer token-123', got %s", r.Header.Get("Authorization"))
			}

			w.Header().Set("Content-Type", "application/json")
			w.Write([]byte(`{
				"success": true,
				"hostId": "agent-1",
				"config": {
					"commandsEnabled": true,
					"settings": {
						"interval": "1m",
						"enable_docker": false
					}
				}
			}`))
		}))
		defer ts.Close()

		client := New(Config{
			PulseURL: ts.URL,
			APIToken: "token-123",
			AgentID:  "agent-1",
		})

		settings, commandsEnabled, err := client.Fetch(context.Background())
		if err != nil {
			t.Fatalf("Fetch failed: %v", err)
		}

		if commandsEnabled == nil || *commandsEnabled != true {
			t.Errorf("Expected commandsEnabled=true, got %v", commandsEnabled)
		}

		if settings["interval"] != "1m" {
			t.Errorf("Expected interval='1m', got %v", settings["interval"])
		}
		if settings["enable_docker"] != false {
			t.Errorf("Expected enable_docker=false, got %v", settings["enable_docker"])
		}
	})

	t.Run("signature required without signature", func(t *testing.T) {
		t.Setenv("PULSE_AGENT_CONFIG_SIGNATURE_REQUIRED", "true")
		ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
			w.Header().Set("Content-Type", "application/json")
			w.Write([]byte(`{
				"success": true,
				"hostId": "agent-1",
				"config": {
					"commandsEnabled": true,
					"settings": {
						"interval": "1m"
					}
				}
			}`))
		}))
		defer ts.Close()

		client := New(Config{
			PulseURL: ts.URL,
			APIToken: "token-123",
			AgentID:  "agent-1",
		})

		_, _, err := client.Fetch(context.Background())
		if err == nil {
			t.Fatal("Expected error, got nil")
		}
		if !strings.Contains(err.Error(), "signature required") {
			t.Fatalf("Expected signature required error, got %v", err)
		}
	})

	t.Run("server error", func(t *testing.T) {
		ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
			w.WriteHeader(http.StatusInternalServerError)
		}))
		defer ts.Close()

		client := New(Config{PulseURL: ts.URL, APIToken: "t", AgentID: "a"})
		_, _, err := client.Fetch(context.Background())
		if err == nil {
			t.Fatal("Expected error, got nil")
		}
	})

	t.Run("missing agent ID", func(t *testing.T) {
		client := New(Config{PulseURL: "http://localhost", APIToken: "t", AgentID: ""})
		_, _, err := client.Fetch(context.Background())
		if err == nil {
			t.Fatal("Expected error for missing agent ID, got nil")
		}
	})
}

func TestClient_ResolveHostID(t *testing.T) {
	ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		if r.URL.Path != "/api/agents/host/lookup" {
			w.WriteHeader(http.StatusNotFound)
			return
		}

		switch r.URL.Query().Get("hostname") {
		case "known":
			w.Header().Set("Content-Type", "application/json")
			w.Write([]byte(`{"success":true,"host":{"id":"host-123"}}`))
		case "unknown":
			w.Header().Set("Content-Type", "application/json")
			w.Write([]byte(`{"success":false}`))
		case "bad":
			w.WriteHeader(http.StatusInternalServerError)
		case "invalid":
			w.WriteHeader(http.StatusOK)
			w.Write([]byte(`not-json`))
		default:
			w.WriteHeader(http.StatusNotFound)
		}
	}))
	defer ts.Close()

	client := New(Config{
		PulseURL: ts.URL,
		APIToken: "token",
	})

	if got, err := client.resolveHostID(context.Background()); err != nil || got != "" {
		t.Fatalf("expected empty hostID for blank hostname, got %q err=%v", got, err)
	}

	client.cfg.Hostname = "known"
	if got, err := client.resolveHostID(context.Background()); err != nil || got != "host-123" {
		t.Fatalf("expected host-123, got %q err=%v", got, err)
	}

	client.cfg.Hostname = "unknown"
	if got, err := client.resolveHostID(context.Background()); err != nil || got != "" {
		t.Fatalf("expected empty hostID, got %q err=%v", got, err)
	}

	client.cfg.Hostname = "bad"
	if _, err := client.resolveHostID(context.Background()); err == nil {
		t.Fatal("expected error for server failure")
	}

	client.cfg.Hostname = "invalid"
	if _, err := client.resolveHostID(context.Background()); err == nil {
		t.Fatal("expected error for invalid JSON")
	}
}