kubeprobes/kubeprobes_test.go

package kubeprobes

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

func getStatusFromEndpoint(t *testing.T, client *http.Client, endpoint string) int {
	t.Helper()
	resp, err := client.Get(endpoint)
	if err != nil {
		t.Errorf("error getting status from endpoint: %s", err)
	}
	return resp.StatusCode
}

func TestValidation(t *testing.T) {
	var (
		live, _  = NewManualProbe("live")
		ready, _ = NewManualProbe("ready")
	)

	tests := map[string]struct {
		opts          []Option
		expectedError bool
	}{
		"no modifications and no error": {
			opts: []Option{
				WithLivenessProbes(live),
				WithReadinessProbes(ready),
			},
		},
		"modifications and no error": {
			opts: []Option{
				WithLivenessProbes(live),
				WithReadinessProbes(ready),
				WithLivenessPath("/livez"),
				WithReadinessPath("/readyz"),
			},
		},
		"missing liveness probes": {
			opts: []Option{
				WithReadinessProbes(ready),
			},
			expectedError: true,
		},
		"missing readiness probes": {
			opts: []Option{
				WithLivenessProbes(live),
			},
			expectedError: true,
		},
		"liveness probe path empty": {
			opts: []Option{
				WithLivenessProbes(live),
				WithReadinessProbes(ready),
				WithLivenessPath(""),
			},
			expectedError: true,
		},
		"readiness probe path empty": {
			opts: []Option{
				WithLivenessProbes(live),
				WithReadinessProbes(ready),
				WithReadinessPath(""),
			},
			expectedError: true,
		},
		"liveness probe path does not start with slash": {
			opts: []Option{
				WithLivenessProbes(live),
				WithReadinessProbes(ready),
				WithLivenessPath("livez"),
			},
			expectedError: true,
		},
		"readiness probe path does not start with slash": {
			opts: []Option{
				WithLivenessProbes(live),
				WithReadinessProbes(ready),
				WithReadinessPath("readyz"),
			},
			expectedError: true,
		},
		"liveness and readiness probe paths are equal": {
			opts: []Option{
				WithLivenessProbes(live),
				WithReadinessProbes(ready),
				WithLivenessPath("/check"),
				WithReadinessPath("/check"),
			},
			expectedError: true,
		},
	}

	for name, tc := range tests {
		name, tc := name, tc
		t.Run(name, func(t *testing.T) {
			_, err := New(tc.opts...)
			switch {
			case err == nil && tc.expectedError:
				t.Error("expected error, but no error was returned")
			case err != nil && !tc.expectedError:
				t.Errorf("expected no error but got %v", err)
			}
		})
	}
}

func TestHandler(t *testing.T) {
	var (
		live, _  = NewManualProbe("live")
		ready, _ = NewManualProbe("ready")
	)

	tests := map[string]struct {
		livenessProbeTransformation  func(*testing.T, ManualProbe)
		readinessProbeTransformation func(*testing.T, ManualProbe)
		expectedLiveStatus           int
		expectedReadyStatus          int
	}{
		"not live": {
			livenessProbeTransformation:  markAsDown,
			readinessProbeTransformation: markAsDown,
			expectedLiveStatus:           http.StatusServiceUnavailable,
			expectedReadyStatus:          http.StatusServiceUnavailable,
		},
		"live but not ready": {
			livenessProbeTransformation:  markAsUp,
			readinessProbeTransformation: markAsDown,
			expectedLiveStatus:           http.StatusOK,
			expectedReadyStatus:          http.StatusServiceUnavailable,
		},
		"live and ready": {
			livenessProbeTransformation:  markAsUp,
			readinessProbeTransformation: markAsUp,
			expectedLiveStatus:           http.StatusOK,
			expectedReadyStatus:          http.StatusOK,
		},
		"ready but not live - should never happen": {
			livenessProbeTransformation:  markAsDown,
			readinessProbeTransformation: markAsUp,
			expectedLiveStatus:           http.StatusServiceUnavailable,
			expectedReadyStatus:          http.StatusServiceUnavailable,
		},
	}

	kp, err := New(
		WithLivenessProbes(live),
		WithReadinessProbes(ready),
	)
	if err != nil {
		t.Errorf("expected no error, got %v", err)
	}

	srv := httptest.NewServer(kp)
	defer srv.Close()
	client := srv.Client()

	for name, test := range tests {
		name, test := name, test
		t.Run(name, func(t *testing.T) {
			test.livenessProbeTransformation(t, live)
			test.readinessProbeTransformation(t, ready)

			liveStatus := getStatusFromEndpoint(t, client, srv.URL+defaultLivenessPath)
			readyStatus := getStatusFromEndpoint(t, client, srv.URL+defaultReadinessPath)
			otherStatus := getStatusFromEndpoint(t, client, srv.URL+"/something")

			if liveStatus != test.expectedLiveStatus {
				t.Errorf("expected live status %d, got %d", test.expectedLiveStatus, liveStatus)
			}
			if readyStatus != test.expectedReadyStatus {
				t.Errorf("expected ready status %d, got %d", test.expectedReadyStatus, readyStatus)
			}
			if otherStatus != http.StatusNotFound {
				t.Errorf("expected 404 status, got %d", otherStatus)
			}
		})
	}
}