test: add tests in vpa package

cli/flags.go

@@ -95,12 +95,10 @@ func (f *Flags) AddFlags(flags *pflag.FlagSet) {
 		"Selector (field query) to filter on, supports '=', '==', and '!=' (e.g. --field-selector key1=value1,key2=value2)")
 
 	flags.StringVarP(&f.Output, flagOutput, flagOutputShorthand, f.Output,
-		"Output format. Empty string or 'wide'",
-	)
+		"Output format. Empty string or 'wide'")
 
 	flags.Var(&f.RecommendationType, flagRecommendationType,
-		fmt.Sprintf("The type of recommendation to use in comparisons. One of: %s", strings.Join(recommendationTypeFlagValues(), ", ")),
-	)
+		fmt.Sprintf("The type of recommendation to use in comparisons. One of: %s", strings.Join(recommendationTypeFlagValues(), ", ")))
 }
 
 func sortColumnsFlagValues() []string {

vpa/recommendation_test.go

@@ -0,0 +1,151 @@
+package vpa
+
+import (
+	"encoding/json"
+	"os"
+	"strings"
+	"testing"
+
+	"github.com/spf13/pflag"
+	"k8s.io/apimachinery/pkg/api/resource"
+	vpav1 "k8s.io/autoscaler/vertical-pod-autoscaler/pkg/apis/autoscaling.k8s.io/v1"
+)
+
+func TestParseRecommendationTypeFlag(t *testing.T) {
+	testcases := []struct {
+		Argv    string
+		Value   RecommendationType
+		Success bool
+	}{
+		{
+			"--recommendation-type target",
+			RecommendationTarget,
+			true,
+		},
+		{
+			"--recommendation-type=lower-bound",
+			RecommendationLowerBound,
+			true,
+		},
+		{
+			"--recommendation-type=lower-bound --recommendation-type upper-bound",
+			RecommendationUpperBound,
+			true,
+		},
+		{
+			"--recommendation-type target --recommendation-type=uncapped-target",
+			RecommendationUncappedTarget,
+			true,
+		},
+		{
+			"--recommendation-type foo",
+			"",
+			false,
+		},
+		{
+			"--recommendation-type=bar",
+			"",
+			false,
+		},
+		{
+			"--recommendation-type invalid --recommendation-type target",
+			"",
+			false,
+		},
+		{
+			"--recommendation-type=uncapped-target --recommendation-type=invalid",
+			"",
+			false,
+		},
+	}
+	for _, tc := range testcases {
+		var rt RecommendationType
+
+		fs := pflag.NewFlagSet("", pflag.ContinueOnError)
+		fs.Var(&rt, "recommendation-type", "")
+
+		err := fs.Parse(strings.Split(tc.Argv, " "))
+		if err != nil && tc.Success {
+			t.Fatal(err)
+		}
+		if err == nil {
+			if !tc.Success {
+				t.Fatalf("expected a parse error but it succeeded")
+			} else if tc.Value != rt {
+				t.Errorf("got %q, want %q", rt, tc.Value)
+			}
+		}
+	}
+}
+
+func TestTotalRecommendations(t *testing.T) {
+	f, err := os.Open("testdata/vpa.json")
+	if err != nil {
+		t.Fatal(err)
+	}
+	vpa := &vpav1.VerticalPodAutoscaler{}
+	dec := json.NewDecoder(f)
+
+	if err = dec.Decode(vpa); err != nil {
+		t.Fatal(err)
+	}
+	t.Run("valid", func(t *testing.T) {
+		for _, tc := range []struct {
+			Type   RecommendationType
+			CPU    *resource.Quantity
+			Memory *resource.Quantity
+		}{
+			{
+				RecommendationLowerBound,
+				resource.NewScaledQuantity(65, resource.Milli),
+				resource.NewScaledQuantity(132, resource.Mega),
+			},
+			{
+				RecommendationTarget,
+				resource.NewScaledQuantity(350, resource.Milli),
+				resource.NewScaledQuantity(184, resource.Mega),
+			},
+			{
+				RecommendationUncappedTarget,
+				resource.NewScaledQuantity(650, resource.Milli),
+				resource.NewScaledQuantity(288, resource.Mega),
+			},
+			{
+				RecommendationUpperBound,
+				resource.NewScaledQuantity(966, resource.Milli),
+				resource.NewScaledQuantity(436, resource.Mega),
+			},
+		} {
+			recos := TotalRecommendations(vpa, tc.Type)
+
+			if recos.CPU == nil {
+				t.Fatal("expected non-nil cpu quantity")
+			}
+			if recos.Memory == nil {
+				t.Fatal("expected non-nil mem quantity")
+			}
+			t.Logf("\n%s\n\tcpu: %v\n\tmem: %v", tc.Type, recos.CPU, recos.Memory)
+
+			if !recos.CPU.Equal(*tc.CPU) {
+				t.Errorf("got cpu=%q, want %q", recos.CPU, tc.CPU)
+			}
+			if !recos.Memory.Equal(*tc.Memory) {
+				t.Errorf("got mem=%q, want %q", recos.Memory, tc.Memory)
+			}
+		}
+	})
+	t.Run("invalid", func(t *testing.T) {
+		vpa.Status.Recommendation = nil // test with no recommendation
+
+		for _, tc := range []struct {
+			Recommendations ResourceQuantities
+		}{
+			{TotalRecommendations(nil, RecommendationTarget)},
+			{TotalRecommendations(nil, RecommendationLowerBound)},
+		} {
+			if tc.Recommendations.CPU != nil || tc.Recommendations.Memory != nil {
+				t.Fatal("expected cpu/mem recommendation to be nil")
+			}
+		}
+	})
+}

vpa/testdata/vpa.json

@@ -0,0 +1,72 @@
+{
+    "apiVersion": "autoscaling.k8s.io/v1",
+    "kind": "VerticalPodAutoscaler",
+    "metadata": {
+        "creationTimestamp": "2022-01-01T00:00:00Z",
+        "generation": 666,
+        "name": "vpa-foo",
+        "namespace": "default",
+        "uid": "037b5ff4-250f-439b-8608-49f7e546f3ec"
+    },
+    "spec": {
+        "targetRef": {
+            "apiVersion": "apps/v1",
+            "kind": "Deployment",
+            "name": "foo"
+        },
+        "updatePolicy": {
+            "updateMode": "Off"
+        }
+    },
+    "status": {
+        "conditions": [
+            {
+                "lastTransitionTime": "2022-01-01T00:01:00Z",
+                "status": "True",
+                "type": "RecommendationProvided"
+            }
+        ],
+        "recommendation": {
+            "containerRecommendations": [
+                {
+                    "containerName": "bar",
+                    "lowerBound": {
+                        "cpu": "25m",
+                        "memory": "32M"
+                    },
+                    "target": {
+                        "cpu": "100m",
+                        "memory": "64M"
+                    },
+                    "uncappedTarget": {
+                        "cpu": "150m",
+                        "memory": "128M"
+                    },
+                    "upperBound": {
+                        "cpu": "300m",
+                        "memory": "256M"
+                    }
+                },
+                {
+                    "containerName": "baz",
+                    "lowerBound": {
+                        "cpu": "40m",
+                        "memory": "100M"
+                    },
+                    "target": {
+                        "cpu": "250m",
+                        "memory": "120M"
+                    },
+                    "uncappedTarget": {
+                        "cpu": "500m",
+                        "memory": "160M"
+                    },
+                    "upperBound": {
+                        "cpu": "666m",
+                        "memory": "180M"
+                    }
+                }
+            ]
+        }
+    }
+}