test: [health] add status handler test (#896)

Signed-off-by: Chris Randles <randles.chris@gmail.com>

Author: crandles

pkg/backends/healthcheck/healthcheck.go

@@ -25,17 +25,26 @@ import (
 
 // HealthChecker defines the Health Checker interface
 type HealthChecker interface {
-	Register(string, string, *ho.Options, *http.Client) (*Status, error)
-	Unregister(string)
-	Status(string) *Status
+	// Register a health check Target
+	Register(name string, description string, options *ho.Options, client *http.Client) (*Status, error)
+	// Remove a health check Target
+	Unregister(name string)
+	// Resolve status of named Target
+	Status(name string) *Status
+	// Retrieve all Target statuses
 	Statuses() StatusLookup
+	// Shutdown the health checker
 	Shutdown()
+	// Listen to be notified that status updates or shutdown has occurred
 	Subscribe(chan bool)
 }
 
 // Lookup is a map of named Target references
 type Lookup map[string]*target
 
+// StatusLookup is a map of named Status references
+type StatusLookup map[string]*Status
+
 type healthChecker struct {
 	targets     Lookup
 	statuses    StatusLookup

pkg/backends/healthcheck/status.go

@@ -48,8 +48,24 @@ type Status struct {
 	prober       func(http.ResponseWriter)
 }
 
-// StatusLookup is a map of named Status references
-type StatusLookup map[string]*Status
+func NewStatus(
+	name string,
+	description,
+	detail string,
+	status int32,
+	failingSince time.Time,
+	prober func(http.ResponseWriter),
+) *Status {
+	s := &Status{
+		name:         name,
+		description:  description,
+		detail:       detail,
+		prober:       prober,
+		failingSince: failingSince,
+	}
+	s.status.Store(status)
+	return s
+}
 
 func (s *Status) String() string {
 	sb := &strings.Builder{}

pkg/proxy/handlers/health/health.go

@@ -151,12 +151,17 @@ func (hs *healthStatus) Tabular() string {
 // This handler spins up an infinitely looping background goroutine ("builder")
 // that updates the status text in real-time. So long as the HealthChecker
 // is closed with ShutDown(), the builder goroutine will exit
-func StatusHandler(hc healthcheck.HealthChecker, backends backends.Backends) http.Handler {
+func StatusHandler(now func() time.Time, hc healthcheck.HealthChecker, backends backends.Backends) http.Handler {
 	if hc == nil {
 		return nil
 	}
-	hd := &healthDetail{}        // stores the status text in JSON and Text
-	go builder(hc, hd, backends) // listens for rebuild notifications and updates the texts
+	hd := &healthDetail{} // stores the status text in JSON and Text
+	ready := make(chan bool, 1)
+	if now == nil {
+		now = time.Now
+	}
+	go builder(now, hc, hd, backends, ready) // listens for rebuild notifications and updates the texts
+	<-ready                                  // wait for the builder to be ready before returning the handler
 
 	// the handler, when requested, simply prints out the static text stored in the healthDetail
 	// which is being updated in real time by the builder.
@@ -196,8 +201,8 @@ func StatusHandler(hc healthcheck.HealthChecker, backends backends.Backends) htt
 	})
 }
 
-func builder(hc healthcheck.HealthChecker, hd *healthDetail, backends backends.Backends) {
-	updateStatusText(hc, hd, backends) // setup the initial status page text
+func builder(now func() time.Time, hc healthcheck.HealthChecker, hd *healthDetail, backends backends.Backends, ready chan<- bool) {
+	updateStatusText(now, hc, hd, backends) // setup the initial status page text
 	notifier := make(chan bool, 32)
 	for _, c := range hc.Statuses() {
 		c.RegisterSubscriber(notifier)
@@ -206,22 +211,24 @@ func builder(hc healthcheck.HealthChecker, hd *healthDetail, backends backends.B
 	hc.Subscribe(closer)
 	for {
 		select {
+		case ready <- true:
+			// signal that the builder is in its ready state
 		case <-closer: // a bool comes over closer when the Health Checker is closing down, so the builder should as well
 			return
 		case <-notifier: // a bool comes over notifier when the status text should be rebuilt
-			updateStatusText(hc, hd, backends)
+			updateStatusText(now, hc, hd, backends)
 		}
 	}
 }
 
 const title = "Trickster Backend Health Status"
 
-func updateStatusText(hc healthcheck.HealthChecker, hd *healthDetail, backends backends.Backends) {
+func updateStatusText(now func() time.Time, hc healthcheck.HealthChecker, hd *healthDetail, backends backends.Backends) {
 	updateLock.Lock()
 	defer updateLock.Unlock()
 
 	// HTTP Spec prefers GMT in RFC1123 Headers
-	lastModified := time.Now().Truncate(time.Second).In(time.FixedZone("GMT", 0))
+	lastModified := now().Truncate(time.Second).In(time.FixedZone("GMT", 0))
 	// use UTC in the response body
 	ut := lastModified.String()[:20] + "UTC"
 

pkg/proxy/handlers/health/health_test.go

@@ -0,0 +1,197 @@
+/*
+ * Copyright 2018 The Trickster Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package health
+
+import (
+	"maps"
+	"net/http"
+	"net/http/httptest"
+	"net/url"
+	"testing"
+	"time"
+
+	"github.com/stretchr/testify/require"
+	"github.com/trickstercache/trickster/v2/pkg/backends"
+	"github.com/trickstercache/trickster/v2/pkg/backends/healthcheck"
+	ho "github.com/trickstercache/trickster/v2/pkg/backends/healthcheck/options"
+	bo "github.com/trickstercache/trickster/v2/pkg/backends/options"
+	"github.com/trickstercache/trickster/v2/pkg/cache"
+	"github.com/trickstercache/trickster/v2/pkg/proxy/handlers"
+	po "github.com/trickstercache/trickster/v2/pkg/proxy/paths/options"
+)
+
+var _ healthcheck.HealthChecker = (*mockHealthChecker)(nil)
+
+type mockTarget struct {
+	description string
+	options     *ho.Options
+	client      *http.Client
+	status      *healthcheck.Status
+}
+
+type mockHealthChecker struct {
+	// map of registered targets, with configurable status
+	targets map[string]mockTarget
+	// if configured, return status for all targets
+	globalStatus *healthcheck.Status
+	// list of subscribers to notify of activity
+	subscribers []chan bool
+}
+
+func newMockHealthChecker() *mockHealthChecker {
+	return &mockHealthChecker{
+		targets: make(map[string]mockTarget),
+	}
+}
+
+func (m *mockHealthChecker) Register(name string, description string, options *ho.Options, client *http.Client) (*healthcheck.Status, error) {
+	target := mockTarget{
+		description: description,
+		options:     options,
+		client:      client,
+	}
+	if m.globalStatus != nil {
+		target.status = m.globalStatus
+	} else {
+		target.status = healthcheck.NewStatus(name, description, "initializing", 0, time.Time{}, nil)
+	}
+	m.targets[name] = target
+	return &healthcheck.Status{}, nil
+}
+
+func (m *mockHealthChecker) Unregister(name string) {
+	delete(m.targets, name)
+}
+
+func (m *mockHealthChecker) Status(name string) *healthcheck.Status {
+	if m.globalStatus != nil {
+		return m.globalStatus
+	}
+
+	if t, ok := m.targets[name]; ok {
+		return t.status
+	}
+	return nil
+}
+
+func (m *mockHealthChecker) Subscribe(ch chan bool) {
+	m.subscribers = append(m.subscribers, ch)
+}
+
+// no-op for mock
+func (m *mockHealthChecker) Statuses() healthcheck.StatusLookup {
+	lookup := make(healthcheck.StatusLookup, len(m.targets))
+	for name, t := range m.targets {
+		status := t.status
+		if t.status == nil {
+			if m.globalStatus == nil {
+				continue // no status or global status, skip
+			}
+			t.status = m.globalStatus
+		}
+		lookup[name] = status
+	}
+	return lookup
+}
+
+func (m *mockHealthChecker) notify(status bool) {
+	for _, ch := range m.subscribers {
+		ch <- status
+	}
+}
+
+func (m *mockHealthChecker) Shutdown() {
+	m.notify(true)
+	// no-op for mock, no background processes to stop
+}
+
+type mockBackend struct {
+	name     string
+	handlers handlers.Lookup
+}
+
+func (m *mockBackend) RegisterHandlers(hl handlers.Lookup) {
+	maps.Copy(m.handlers, hl)
+}
+
+func (m *mockBackend) Handlers() handlers.Lookup {
+	return m.handlers
+}
+
+func (m *mockBackend) DefaultPathConfigs(*bo.Options) po.List {
+	return nil
+}
+
+func (m *mockBackend) Configuration() *bo.Options {
+	return nil
+}
+func (m *mockBackend) Name() string {
+	return m.name
+}
+func (m *mockBackend) HTTPClient() *http.Client {
+	return nil
+}
+func (m *mockBackend) SetCache(cache.Cache) {}
+func (m *mockBackend) Router() http.Handler {
+	return nil
+}
+func (m *mockBackend) Cache() cache.Cache {
+	return nil
+}
+func (m *mockBackend) BaseUpstreamURL() *url.URL {
+	return nil
+}
+func (m *mockBackend) SetHealthCheckProbe(healthcheck.DemandProbe)      {}
+func (m *mockBackend) HealthHandler(http.ResponseWriter, *http.Request) {}
+func (m *mockBackend) DefaultHealthCheckConfig() *ho.Options {
+	return nil
+}
+func (m *mockBackend) HealthCheckHTTPClient() *http.Client {
+	return nil
+}
+
+func TestStatusHandler(t *testing.T) {
+	const (
+		name = "mock-backend"
+	)
+
+	hc := newMockHealthChecker()
+	hc.globalStatus = healthcheck.NewStatus(name, "mock health checker", "mock detail", 1, time.Time{}, nil)
+	backends := make(backends.Backends)
+	backends[name] = &mockBackend{
+		name: name,
+	}
+	status, err := hc.Register(name, "test backend", &ho.Options{}, &http.Client{})
+	require.NoError(t, err)
+	require.NotNil(t, status)
+
+	sh := StatusHandler(func() time.Time {
+		return time.Time{}
+	}, hc, backends)
+	require.NotNil(t, sh)
+
+	req, err := http.NewRequest("GET", "/", nil)
+	req.Header.Set("Accept", "application/json")
+	require.NoError(t, err)
+
+	w := httptest.NewRecorder()
+
+	sh.ServeHTTP(w, req)
+	require.Equal(t, http.StatusOK, w.Result().StatusCode)
+	expected := `{"title":"Trickster Backend Health Status","updateTime":"0001-01-01 00:00:00 UTC","available":[{"name":"mock-backend","provider":"mock health checker"}]}`
+	require.Equal(t, expected, w.Body.String())
+}

pkg/routing/routing.go

@@ -130,7 +130,7 @@ func RegisterProxyRoutes(conf *config.Config, clients backends.Backends,
 func RegisterHealthHandler(router router.Router, path string,
 	hc healthcheck.HealthChecker, backends backends.Backends,
 ) {
-	router.RegisterRoute(path, nil, nil, false, health.StatusHandler(hc, backends))
+	router.RegisterRoute(path, nil, nil, false, health.StatusHandler(nil, hc, backends))
 }
 
 func registerBackendRoutes(r router.Router, metricsRouter router.Router,