Skip to content

armgit / Pulse

Public Imported from GitHub
0

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.

4.9 KB
Raw Blame
package api

import (
	"bytes"
	"encoding/json"
	"net/http"
	"net/http/httptest"
	"sync"
	"testing"
	"time"

	"github.com/rcourtman/pulse-go-rewrite/internal/license"
	pkglicensing "github.com/rcourtman/pulse-go-rewrite/pkg/licensing"
	licensetestsupport "github.com/rcourtman/pulse-go-rewrite/pkg/licensing/testsupport"
)

// activateAndCaptureRuntime activates a key through the handler against a fake
// license server and returns the runtime identity the server received.
func activateAndCaptureRuntime(t *testing.T, handler *LicenseHandlers, server *captureActivationServer) *pkglicensing.RuntimeIdentity {
	t.Helper()
	t.Cleanup(handler.StopAllBackgroundLoops)

	body, _ := json.Marshal(map[string]string{"license_key": "ppk_live_runtime_identity"})
	req := httptest.NewRequest(http.MethodPost, "/api/license/activate", bytes.NewReader(body))
	rec := httptest.NewRecorder()
	handler.HandleActivateLicense(rec, req)
	if rec.Code != http.StatusOK {
		t.Fatalf("expected status %d, got %d: %s", http.StatusOK, rec.Code, rec.Body.String())
	}
	return server.capturedRuntime(t)
}

type captureActivationServer struct {
	mu      sync.Mutex
	request *pkglicensing.ActivateInstallationRequest
}

func (s *captureActivationServer) capturedRuntime(t *testing.T) *pkglicensing.RuntimeIdentity {
	t.Helper()
	s.mu.Lock()
	defer s.mu.Unlock()
	if s.request == nil {
		t.Fatal("license server never received an activation request")
	}
	return s.request.Runtime
}

func newCaptureActivationServer(t *testing.T) *captureActivationServer {
	t.Helper()
	t.Setenv("PULSE_LICENSE_DEV_MODE", "false")

	grantJWT, grantPublicKey, err := licensetestsupport.GenerateGrantJWTForTesting(pkglicensing.GrantClaims{
		LicenseID:      "lic_v6_runtime",
		LicenseVersion: 1,
		Tier:           "pro",
		State:          "active",
		Features:       []string{"relay"},
		IssuedAt:       time.Now().Unix(),
		ExpiresAt:      time.Now().Add(72 * time.Hour).Unix(),
		Email:          "[email protected]",
	})
	if err != nil {
		t.Fatalf("generate grant jwt: %v", err)
	}
	license.SetPublicKey(grantPublicKey)
	t.Cleanup(func() { license.SetPublicKey(nil) })

	captured := &captureActivationServer{}
	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		if handleTestInstallationStatus(w, r, 1) {
			return
		}
		if r.URL.Path != "/v1/activate" {
			t.Errorf("path = %q, want /v1/activate", r.URL.Path)
			http.NotFound(w, r)
			return
		}
		var activation pkglicensing.ActivateInstallationRequest
		if err := json.NewDecoder(r.Body).Decode(&activation); err != nil {
			t.Errorf("decode activation request: %v", err)
			http.Error(w, "bad request", http.StatusBadRequest)
			return
		}
		captured.mu.Lock()
		captured.request = &activation
		captured.mu.Unlock()

		w.WriteHeader(http.StatusCreated)
		_ = json.NewEncoder(w).Encode(map[string]any{
			"license": map[string]any{
				"license_id":            "lic_v6_runtime",
				"state":                 "active",
				"tier":                  "pro",
				"features":              []string{"relay"},
				"max_monitored_systems": 10,
			},
			"installation": map[string]any{
				"installation_id":    "inst_v6_runtime",
				"installation_token": "pit_live_runtime",
				"status":             "active",
			},
			"grant": map[string]any{
				"jwt":        grantJWT,
				"jti":        "grant_v6_runtime",
				"expires_at": time.Now().Add(72 * time.Hour).UTC().Format(time.RFC3339),
			},
		})
	}))
	t.Cleanup(server.Close)
	t.Setenv("PULSE_LICENSE_SERVER_URL", server.URL)
	return captured
}

// A Pro build must tell the license server it is a Pro runtime when it
// activates a key, whether the tenant's license service is created by the
// activation itself or was already cached by an earlier request.
func TestHandleActivateLicense_ReportsRuntimeIdentityToLicenseServer(t *testing.T) {
	t.Run("new tenant service", func(t *testing.T) {
		server := newCaptureActivationServer(t)
		handler := createTestHandler(t)
		handler.SetRuntimeIdentity(pkglicensing.ProRuntimeIdentity())

		runtime := activateAndCaptureRuntime(t, handler, server)
		if runtime == nil || runtime.Build != pkglicensing.RuntimeBuildPro {
			t.Fatalf("activation runtime = %+v, want %q build", runtime, pkglicensing.RuntimeBuildPro)
		}
	})

	t.Run("cached tenant service", func(t *testing.T) {
		server := newCaptureActivationServer(t)
		handler := createTestHandler(t)

		// An earlier request caches the tenant service while the handler still
		// reports the community runtime.
		probe := httptest.NewRequest(http.MethodGet, "/api/license/status", nil)
		if _, _, err := handler.getTenantComponents(probe.Context()); err != nil {
			t.Fatalf("getTenantComponents: %v", err)
		}
		handler.SetRuntimeIdentity(pkglicensing.ProRuntimeIdentity())

		runtime := activateAndCaptureRuntime(t, handler, server)
		if runtime == nil || runtime.Build != pkglicensing.RuntimeBuildPro {
			t.Fatalf("activation runtime = %+v, want %q build", runtime, pkglicensing.RuntimeBuildPro)
		}
	})
}