Fix unit tests from refactoring

Move scheduling unit tests to new telemetry scheduler file.
Fix composite literal for unkeyed fields

Author: togashidm

cmd/tas-scheduler-extender/main.go

@@ -20,7 +20,7 @@ func main() {
 	flag.Parse()
 	cacheReader := cache.RemoteClient{}
 	cacheReader.RegisterEndpoint(cacheEndpoint)
-	telemetry := telemetryscheduler.NewMetricsExtender(&cacheReader)
-	sch := scheduler.Server{ExtenderScheduler: telemetry}
+	tscheduler := telemetryscheduler.NewMetricsExtender(&cacheReader)
+	sch := scheduler.Server{ExtenderScheduler: tscheduler}
 	sch.StartServer(port, certFile, keyFile, caFile, unsafe)
 }

pkg/scheduler/scheduler.go

@@ -4,6 +4,7 @@ package scheduler
 import (
 	"crypto/tls"
 	"crypto/x509"
+	"io/ioutil"
 	"log"
 	"net/http"
 	"os"
@@ -40,18 +41,34 @@ func requestContentType(next http.HandlerFunc) http.HandlerFunc {
 		requestContentType := r.Header.Get("Content-Type")
 		if requestContentType != "application/json" {
 			w.WriteHeader(http.StatusNotFound)
-			log.Print("request size too large")
+			log.Print("request content type not application/json")
 			return
 		}
 		next.ServeHTTP(w, r)
 	}
 }
 
+/*
+handlerWithMiddleware runs each function in sequence starting from the outermost function. These middleware functions
+are pass/fail checks on the scheduling request. If a check fails the response with an appropriate error is immediately
+written and returned.
+i.e. with this version of the code:
+	return requestContentType(
+			contentLength(
+				postOnly(handle),
+				),
+			)
+if the content type is not correct - i.e. NOT application/json - the response will be written. contentLength or postOnly
+will not run.
+*/
+
 //handlerWithMiddleware is handler wrapped with middleware to serve the prechecks at endpoint
 func handlerWithMiddleware(handle http.HandlerFunc) http.HandlerFunc {
 	return requestContentType(
-		contentLength(
-			postOnly(handle)))
+				contentLength(
+					postOnly(handle),
+				),
+			)
 }
 
 //error handler deals with requests sent to an invalid endpoint and returns a 404.

pkg/scheduler/types.go

@@ -11,12 +11,12 @@ type ExtenderScheduler interface {
 	Filter(w http.ResponseWriter, r *http.Request)
 }
 
-//Server declares ExtenderScheduler
+//Server type wraps the implementation of the scheduler.
 type Server struct {
 	ExtenderScheduler
 }
 
-//TODO: These types are in the k8s.io/kubernes/scheduler/api package
+//TODO: These types are in the k8s.io/kubernetes/scheduler/api package
 // Some import issue is making them tough to access, so they are reimplemented here pending a solution.
 
 // HostPriority represents the priority of scheduling to a particular host, higher priority is better.

pkg/scheduler/scheduler_test.go renamed to pkg/telemetryscheduler/scheduler_test.go

@@ -1,12 +1,13 @@
 //Logic for the scheduler extender - including the server it starts and prioritize + filter methods - is implemented in this package.
-package scheduler
+package telemetryscheduler
 
 import (
 	"bytes"
 	"encoding/json"
 	"errors"
 	"github.com/intel/telemetry-aware-scheduling/pkg/cache"
 	"github.com/intel/telemetry-aware-scheduling/pkg/metrics"
+	"github.com/intel/telemetry-aware-scheduling/pkg/scheduler"
 	telpolv1 "github.com/intel/telemetry-aware-scheduling/pkg/telemetrypolicy/api/v1alpha1"
 	telpolclient "github.com/intel/telemetry-aware-scheduling/pkg/telemetrypolicy/client/v1alpha1"
 	"io/ioutil"
@@ -20,19 +21,19 @@ import (
 	"testing"
 )
 
-var prioritizerArgs1 = ExtenderArgs{
+var prioritizerArgs1 = scheduler.ExtenderArgs{
 	Pod:       v1.Pod{TypeMeta: metav1.TypeMeta{}, ObjectMeta: metav1.ObjectMeta{Name: "big pod", Labels: map[string]string{"telemetry-policy": "test-policy"}, Namespace: "default"}},
 	Nodes:     &v1.NodeList{Items: []v1.Node{{TypeMeta: metav1.TypeMeta{}, ObjectMeta: metav1.ObjectMeta{Name: "node A"}, Spec: v1.NodeSpec{}, Status: v1.NodeStatus{}}}},
 	NodeNames: &[]string{"node A", "node B"},
 }
 
-var twoNodeArgument = ExtenderArgs{
+var twoNodeArgument = scheduler.ExtenderArgs{
 	Pod:       v1.Pod{TypeMeta: metav1.TypeMeta{}, ObjectMeta: metav1.ObjectMeta{Name: "big pod", Labels: map[string]string{"telemetry-policy": "test-policy"}, Namespace: "default"}},
 	Nodes:     &v1.NodeList{Items: []v1.Node{{TypeMeta: metav1.TypeMeta{}, ObjectMeta: metav1.ObjectMeta{Name: "node A"}, Spec: v1.NodeSpec{}, Status: v1.NodeStatus{}}, {TypeMeta: metav1.TypeMeta{}, ObjectMeta: metav1.ObjectMeta{Name: "node B"}, Spec: v1.NodeSpec{}, Status: v1.NodeStatus{}}}},
 	NodeNames: &[]string{"node A", "node B"},
 }
 
-var noPolicyPod = ExtenderArgs{
+var noPolicyPod = scheduler.ExtenderArgs{
 	Pod:       v1.Pod{TypeMeta: metav1.TypeMeta{}, ObjectMeta: metav1.ObjectMeta{Name: "big pod", Labels: map[string]string{"useless-label": "test-policy"}, Namespace: "default"}},
 	Nodes:     &v1.NodeList{Items: []v1.Node{{TypeMeta: metav1.TypeMeta{}, ObjectMeta: metav1.ObjectMeta{Name: "node A"}, Spec: v1.NodeSpec{}, Status: v1.NodeStatus{}}}},
 	NodeNames: &[]string{"node A", "node B"},
@@ -93,8 +94,8 @@ func TestMetricsExtender_prescheduleChecks(t *testing.T) {
 		fields         fields
 		args           args
 		metric         metrics.NodeMetricsInfo
-		prioritizeArgs ExtenderArgs
-		wanted         HostPriorityList
+		prioritizeArgs scheduler.ExtenderArgs
+		wanted         scheduler.HostPriorityList
 		wantErr        bool
 	}{
 		{name: "unlabelled pod",
@@ -103,7 +104,7 @@ func TestMetricsExtender_prescheduleChecks(t *testing.T) {
 			args:           args{httptest.NewRequest("POST", "http://localhost/scheduler/prioritize", nil)},
 			metric:         map[string]metrics.NodeMetric{"node A": {Value: *resource.NewQuantity(100, resource.DecimalSI)}, "node B": {Value: *resource.NewQuantity(90, resource.DecimalSI)}},
 			prioritizeArgs: noPolicyPod,
-			wanted:         []HostPriority{{"node A", 10}, {"node B", 9}},
+			wanted:         []scheduler.HostPriority{{Host: "node A", Score: 10}, {Host: "node B", Score: 9}},
 			wantErr:        true,
 		},
 	}
@@ -128,7 +129,7 @@ func TestMetricsExtender_prescheduleChecks(t *testing.T) {
 			tt.args.r.Body = ioutil.NopCloser(bytes.NewReader(argsAsJSON))
 			w := httptest.NewRecorder()
 			m.Prioritize(w, tt.args.r)
-			result := HostPriorityList{}
+			result := scheduler.HostPriorityList{}
 			b := w.Body.Bytes()
 			err = json.Unmarshal(b, &result)
 			log.Print(result)
@@ -154,8 +155,8 @@ func TestMetricsExtender_Prioritize(t *testing.T) {
 		fields         fields
 		args           args
 		metric         metrics.NodeMetricsInfo
-		prioritizeArgs ExtenderArgs
-		wanted         HostPriorityList
+		prioritizeArgs scheduler.ExtenderArgs
+		wanted         scheduler.HostPriorityList
 		wantErr        bool
 	}{
 		{"get and return node test",
@@ -164,7 +165,7 @@ func TestMetricsExtender_Prioritize(t *testing.T) {
 			args{httptest.NewRequest("POST", "http://localhost/scheduler/prioritize", nil)},
 			map[string]metrics.NodeMetric{"node A": {Value: *resource.NewQuantity(100, resource.DecimalSI)}, "node B": {Value: *resource.NewQuantity(90, resource.DecimalSI)}},
 			twoNodeArgument,
-			[]HostPriority{{"node A", 10}, {"node B", 9}},
+			[]scheduler.HostPriority{{Host: "node A", Score: 10}, {Host: "node B", Score: 9}},
 			false,
 		},
 		{"policy not found",
@@ -173,7 +174,7 @@ func TestMetricsExtender_Prioritize(t *testing.T) {
 			args{httptest.NewRequest("POST", "http://localhost/scheduler/prioritize", nil)},
 			map[string]metrics.NodeMetric{"node A": {Value: *resource.NewQuantity(90, resource.DecimalSI)}, "node B": {Value: *resource.NewQuantity(100, resource.DecimalSI)}},
 			twoNodeArgument,
-			[]HostPriority{},
+			[]scheduler.HostPriority{},
 			true,
 		},
 		{"cache returns error if empty",
@@ -182,15 +183,15 @@ func TestMetricsExtender_Prioritize(t *testing.T) {
 			args{httptest.NewRequest("POST", "http://localhost/scheduler/prioritize", nil)},
 			map[string]metrics.NodeMetric{"node A": {Value: *resource.NewQuantity(100, resource.DecimalSI)}},
 			prioritizerArgs1,
-			[]HostPriority{{"node B", 10}},
+			[]scheduler.HostPriority{{Host: "node B", Score: 10}},
 			true,
 		},
-		{"malformed arguments return error", fields{*dummyClient, cache.MockEmptySelfUpdatingCache(),
-			testPolicy1},
+		{"malformed arguments return error",fields{*dummyClient, cache.MockEmptySelfUpdatingCache(),
+				testPolicy1},
 			args{httptest.NewRequest("POST", "http://localhost/scheduler/prioritize", nil)},
 			map[string]metrics.NodeMetric{"node A": {Value: *resource.NewQuantity(100, resource.DecimalSI)}},
-			ExtenderArgs{},
-			[]HostPriority{{"node B", 10}},
+			scheduler.ExtenderArgs{},
+			[]scheduler.HostPriority{{Host: "node B", Score: 10}},
 			true,
 		},
 	}
@@ -216,7 +217,7 @@ func TestMetricsExtender_Prioritize(t *testing.T) {
 			tt.args.r.Body = ioutil.NopCloser(bytes.NewReader(argsAsJSON))
 			w := httptest.NewRecorder()
 			m.Prioritize(w, tt.args.r)
-			result := HostPriorityList{}
+			result := scheduler.HostPriorityList{}
 			b := w.Body.Bytes()
 			err = json.Unmarshal(b, &result)
 			if err != nil && tt.wantErr {
@@ -265,7 +266,7 @@ func TestMetricsExtender_Filter(t *testing.T) {
 		name    string
 		fields  fields
 		args    args
-		wanted  ExtenderFilterResult
+		wanted  scheduler.ExtenderFilterResult
 		wantErr bool
 	}{
 		{name: "get and return node test",
@@ -275,14 +276,14 @@ func TestMetricsExtender_Filter(t *testing.T) {
 				testPolicy1},
 			args: args{
 				httptest.NewRequest("POST", "http://localhost/scheduler/prioritize", nil), metrics.TestNodeMetricCustomInfo([]string{"node A", "node B"}, []int64{10, 30})},
-			wanted: ExtenderFilterResult{&v1.NodeList{}, &[]string{"node A"}, map[string]string{}, ""},
+			wanted: scheduler.ExtenderFilterResult{Nodes: &v1.NodeList{}, NodeNames: &[]string{"node A"}, FailedNodes: map[string]string{}},
 		},
 		{name: "filter out one node",
 			fields: fields{*dummyClient, cache.MockSelfUpdatingCache(),
 				metrics.NewDummyMetricsClient(metrics.InstanceOfMockMetricClientMap),
 				testPolicy1},
 			args:   args{httptest.NewRequest("POST", "http://localhost/scheduler/prioritize", nil), metrics.TestNodeMetricCustomInfo([]string{"node A", "node B"}, []int64{50, 30})},
-			wanted: ExtenderFilterResult{&v1.NodeList{}, &[]string{"node A"}, map[string]string{"node A": ""}, ""},
+			wanted: scheduler.ExtenderFilterResult{Nodes: &v1.NodeList{}, NodeNames: &[]string{"node A"}, FailedNodes: map[string]string{"node A": ""}},
 		},
 	}
 	for _, tt := range tests {
@@ -308,7 +309,7 @@ func TestMetricsExtender_Filter(t *testing.T) {
 			tt.args.r.Header.Add("Content-Type", "application/json")
 			w := httptest.NewRecorder()
 			m.Filter(w, tt.args.r)
-			result := ExtenderFilterResult{}
+			result := scheduler.ExtenderFilterResult{}
 			b := w.Body.Bytes()
 			err = json.Unmarshal(b, &result)
 			if err != nil {

pkg/telemetryscheduler/telemetryscheduler.go

@@ -47,7 +47,7 @@ func (m MetricsExtender) Prioritize(w http.ResponseWriter, r *http.Request) {
 		return
 	}
 	if _, ok := extenderArgs.Pod.Labels[tasPolicy]; !ok {
-		err = fmt.Errorf("no policy associated with pod")
+		log.Printf("no policy associated with pod")
 		w.WriteHeader(http.StatusBadRequest)
 	}
 	prioritizedNodes := m.prioritizeNodes(extenderArgs)