Beginning to write tests

.github/workflows/tests.yaml

@@ -0,0 +1,20 @@
+name: Run tests
+on:
+  push:
+    branches: [main]
+  pull_request:
+    branches: [main]
+
+jobs:
+  run_tests:
+
+    runs-on: ubuntu-20.04
+
+    steps:
+    - uses: actions/checkout@v2
+    - name: Install Go
+      uses: actions/setup-go@v2
+      with:
+        go-version: 1.15.x
+    - name: Test
+      run: go test ./...

Makefile

@@ -4,6 +4,10 @@ INTERCEPTOR_DOCKER_IMG?=arschles/keda-http-interceptor:${GIT_TAG}
 OPERATOR_DOCKER_IMG?=arschles/keda-http-operator:${GIT_TAG}
 NAMESPACE?=kedahttp
 
+#####
+# scaler targets
+#####
+
 .PHONY: gen-scaler
 gen-scaler:
 	protoc \
@@ -17,6 +21,10 @@ gen-scaler:
 build-scaler:
 	go build -o bin/scaler ./scaler
 
+.PHONY: test-scaler
+test-scaler:
+	go test ./scaler/...
+
 .PHONY: docker-build-scaler
 docker-build-scaler:
 	docker build -t ${SCALER_DOCKER_IMG} -f scaler/Dockerfile .
@@ -25,10 +33,18 @@ docker-build-scaler:
 docker-push-scaler: docker-build-scaler
 	docker push ${SCALER_DOCKER_IMG}
 
+#####
+# Interceptor targets
+#####
+
 .PHONY: build-interceptor
 build-interceptor:
 	go build -o bin/interceptor ./interceptor
 
+.PHONY: test-interceptor
+test-interceptor:
+	go test ./interceptor/...
+
 .PHONY: docker-build-interceptor
 docker-build-interceptor:
 	docker build -t ${INTERCEPTOR_DOCKER_IMG} -f interceptor/Dockerfile .
@@ -37,14 +53,18 @@ docker-build-interceptor:
 docker-push-interceptor: docker-build-interceptor
 	docker push ${INTERCEPTOR_DOCKER_IMG}
 
-# .PHONY: build-operator
-# build-operator-cli:
-# 	cargo build --bin operator
+#####
+# operator targets
+#####
 
 .PHONY: build-operator
 build-operator:
 	go build -o bin/operator ./operator
 
+.PHONY: test-operator
+test-operator:
+	go test ./operator/...
+
 .PHONY: docker-build-operator
 docker-build-operator:
 	docker build -t ${OPERATOR_DOCKER_IMG} -f operator/Dockerfile .
@@ -67,9 +87,16 @@ helm-upgrade-operator:
 helm-delete-operator:
 	helm delete -n ${NAMESPACE} kedahttp
 
+#####
+# universal targets
+#####
+
 .PHONY: build-all
 build-all: build-scaler build-interceptor build-operator
 
+.PHONY: test-all
+test-all: test-scaler test-interceptor test-operator
+
 .PHONY: docker-build-all
 docker-build-all: docker-build-scaler docker-build-interceptor docker-build-operator
 

go.mod

@@ -9,6 +9,7 @@ require (
 	github.com/onsi/ginkgo v1.14.1
 	github.com/onsi/gomega v1.10.2
 	github.com/pkg/errors v0.9.1
+	github.com/stretchr/testify v1.6.1
 	google.golang.org/grpc v1.33.2
 	google.golang.org/protobuf v1.25.0
 	k8s.io/api v0.20.2

interceptor/admin_handlers_test.go

@@ -0,0 +1,41 @@
+package main
+
+import (
+	"encoding/json"
+	"errors"
+)
+
+func (i *InterceptorSuite) TestQueueSizeHandlerSuccess() {
+	reader := &fakeQueueCountReader{
+		current: 123,
+		err:     nil,
+	}
+
+	handler := newQueueSizeHandler(reader)
+	_, echoCtx, rec := newTestCtx("GET", "/queue")
+	err := handler(echoCtx)
+	i.NoError(err)
+	i.Equal(200, rec.Code, "response code")
+	respMap := map[string]int{}
+	decodeErr := json.NewDecoder(rec.Body).Decode(&respMap)
+	i.NoError(decodeErr)
+	i.Equalf(1, len(respMap), "response JSON length was not 1")
+	sizeVal, ok := respMap["current_size"]
+	i.Truef(ok, "'current_size' entry not available in return JSON")
+	i.Equalf(reader.current, sizeVal, "returned JSON queue size was wrong")
+	reader.err = errors.New("test error")
+	i.Error(handler(echoCtx))
+}
+
+func (i *InterceptorSuite) TestQueueSizeHandlerFail() {
+	reader := &fakeQueueCountReader{
+		current: 0,
+		err:     errors.New("test error"),
+	}
+
+	handler := newQueueSizeHandler(reader)
+	_, echoCtx, rec := newTestCtx("GET", "/queue")
+	err := handler(echoCtx)
+	i.Error(err)
+	i.Equal(500, rec.Code, "response code")
+}

interceptor/interceptor_suite_test.go

@@ -0,0 +1,46 @@
+package main
+
+import (
+	"net/http/httptest"
+	"testing"
+
+	echo "github.com/labstack/echo/v4"
+	"github.com/stretchr/testify/suite"
+)
+
+type InterceptorSuite struct {
+	suite.Suite
+}
+
+func TestInterceptor(t *testing.T) {
+	suite.Run(t, new(InterceptorSuite))
+}
+
+func newTestCtx(method, path string) (*echo.Echo, echo.Context, *httptest.ResponseRecorder) {
+	req := httptest.NewRequest(method, path, nil)
+	rec := httptest.NewRecorder()
+	e := echo.New()
+	return e, e.NewContext(req, rec), rec
+}
+
+type fakeQueueCounter struct {
+	resizedCh chan int
+}
+
+func (f *fakeQueueCounter) Resize(i int) error {
+	f.resizedCh <- i
+	return nil
+}
+
+func (f *fakeQueueCounter) Current() (int, error) {
+	return 0, nil
+}
+
+type fakeQueueCountReader struct {
+	current int
+	err     error
+}
+
+func (f *fakeQueueCountReader) Current() (int, error) {
+	return f.current, f.err
+}

interceptor/middleware_test.go

@@ -0,0 +1,53 @@
+package main
+
+import (
+	"math"
+	"sync"
+	"time"
+
+	echo "github.com/labstack/echo/v4"
+)
+
+func (i *InterceptorSuite) TestCountMiddleware() {
+	queueCounter := &fakeQueueCounter{}
+	middleware := countMiddleware(queueCounter)
+	var wg sync.WaitGroup
+	wg.Add(1)
+	handler := middleware(func(c echo.Context) error {
+		wg.Done()
+		return c.String(200, "OK")
+	})
+	_, echoCtx, _ := newTestCtx("GET", "/something")
+	go func() {
+		i.NoError(handler(echoCtx))
+	}()
+
+	// after the handler was called, first wait for it to complete.
+	// then check to make sure the pending queue size was increased and decreased.
+	//
+	// the increase and decrease operations happen in goroutines, so the ordering
+	// isn't guaranteed
+	wg.Wait()
+	timer := time.NewTimer(200 * time.Millisecond)
+	defer timer.Stop()
+	resizes := []int{}
+	done := false
+	for i := 0; i < 2; i++ {
+		if len(resizes) == 2 || done {
+			break
+		}
+		select {
+		case i := <-queueCounter.resizedCh:
+			resizes = append(resizes, i)
+		case <-timer.C:
+			done = true
+			break
+		}
+	}
+	agg := 0
+	for _, delta := range resizes {
+		i.Equal(1, math.Abs(float64(delta)))
+		agg += delta
+	}
+	i.Equal(0, agg, "sum of all the resize operations")
+}

interceptor/proxy_handlers_test.go

@@ -0,0 +1,28 @@
+package main
+
+import (
+	"net/http"
+	"net/http/httptest"
+	"net/url"
+)
+
+func (i *InterceptorSuite) TestForwardingHandler() {
+	const originReturn = "hello test"
+	forwardedRequests := []*http.Request{}
+	testServer := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		forwardedRequests = append(forwardedRequests, r)
+		w.Write([]byte(originReturn))
+	}))
+	defer testServer.Close()
+
+	forwardURL, err := url.Parse(testServer.URL)
+	i.NoError(err)
+	handler := newForwardingHandler(forwardURL)
+	const path = "/testfwd"
+	_, echoCtx, rec := newTestCtx("GET", path)
+	i.NoError(handler(echoCtx))
+	i.Equal(1, len(forwardedRequests), "number of requests that were forwarded")
+	forwardedRequest := forwardedRequests[0]
+	i.Equal(path, forwardedRequest.URL.Path)
+	i.Equal(originReturn, string(rec.Body.Bytes()))
+}

operator/controllers/external_scaler_test.go

@@ -0,0 +1,76 @@
+package controllers
+
+import (
+	"context"
+	"time"
+
+	logrtest "github.com/go-logr/logr/testing"
+	"github.com/kedacore/http-add-on/operator/api/v1alpha1"
+	"github.com/kedacore/http-add-on/operator/controllers/config"
+	. "github.com/onsi/ginkgo"
+	. "github.com/onsi/gomega"
+	appsv1 "k8s.io/api/apps/v1"
+	corev1 "k8s.io/api/core/v1"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"sigs.k8s.io/controller-runtime/pkg/client"
+	"sigs.k8s.io/controller-runtime/pkg/client/fake"
+)
+
+var _ = Describe("ExternalScaler", func() {
+	Context("Creating the external scaler", func() {
+		It("Should properly create the Deployment and Service", func() {
+			const name = "testapp"
+			const namespace = "testns"
+			ctx := context.Background()
+			cl := fake.NewFakeClient()
+			cfg := config.AppInfo{
+				Name:      name,
+				Port:      8081,
+				Image:     "arschles/testimg",
+				Namespace: namespace,
+			}
+			logger := logrtest.NullLogger{}
+			httpso := &v1alpha1.HTTPScaledObject{
+				ObjectMeta: metav1.ObjectMeta{
+					Namespace: namespace,
+					Name:      name,
+				},
+				Spec: v1alpha1.HTTPScaledObjectSpec{
+					AppName: name,
+					Image:   "arschles/testapp",
+					Port:    8081,
+				},
+			}
+			err := createExternalScaler(ctx, cfg, cl, logger, httpso)
+			Expect(err).To(BeNil())
+
+			// // make sure that httpso has the right conditions on it
+			Expect(len(httpso.Status.Conditions)).To(Equal(1))
+			cond1 := httpso.Status.Conditions[0]
+			cond1ts, err := time.Parse(time.RFC3339, cond1.Timestamp)
+			Expect(err).To(BeNil())
+			Expect(time.Now().Sub(cond1ts) >= 0).To(BeTrue())
+			Expect(cond1.Type).To(Equal(v1alpha1.Created))
+			Expect(cond1.Status).To(Equal(metav1.ConditionTrue))
+			Expect(cond1.Reason).To(Equal(v1alpha1.CreatedExternalScaler))
+
+			// check that the external scaler deployment was created
+			deployment := new(appsv1.Deployment)
+			err = cl.Get(ctx, client.ObjectKey{
+				Name:      cfg.ExternalScalerDeploymentName(),
+				Namespace: cfg.Namespace,
+			}, deployment)
+			Expect(err).To(BeNil())
+
+			// check that the external scaler service was created
+			service := new(corev1.Service)
+			err = cl.Get(ctx, client.ObjectKey{
+				Name:      cfg.ExternalScalerServiceName(),
+				Namespace: cfg.Namespace,
+			}, service)
+			Expect(err).To(BeNil())
+
+		})
+	})
+
+})