From 406b4d440122ad05fe878e4c7b9165ebfc486afa Mon Sep 17 00:00:00 2001
From: "xin.li" <xin.li@daocloud.io>
Date: Sun, 12 Feb 2023 16:39:24 +0800
Subject: [PATCH] [UT] add increase coverage for probe/util.go

Signed-off-by: xin.li <xin.li@daocloud.io>
---
 pkg/probe/util_test.go | 157 ++++++++++++++++++++++++++---------------
 1 file changed, 102 insertions(+), 55 deletions(-)

diff --git a/pkg/probe/util_test.go b/pkg/probe/util_test.go
index 85aee2bedb16..c56ee5b742c0 100644
--- a/pkg/probe/util_test.go
+++ b/pkg/probe/util_test.go
@@ -24,29 +24,80 @@ import (
 )
 
 func TestFindPortByName(t *testing.T) {
-	container := v1.Container{
-		Ports: []v1.ContainerPort{
-			{
-				Name:          "foo",
-				ContainerPort: 8080,
+	t.Parallel()
+	type args struct {
+		container *v1.Container
+		portName  string
+	}
+	tests := []struct {
+		name    string
+		args    args
+		want    int
+		wantErr bool
+	}{
+		{
+			name: "get port from exist port name",
+			args: args{
+				container: &v1.Container{
+					Ports: []v1.ContainerPort{
+						{
+							Name:          "foo",
+							ContainerPort: 8080,
+						},
+						{
+							Name:          "bar",
+							ContainerPort: 9000,
+						},
+					},
+				},
+				portName: "foo",
 			},
-			{
-				Name:          "bar",
-				ContainerPort: 9000,
+			want:    8080,
+			wantErr: false,
+		},
+		{
+			name: "get port from not exist port name",
+			args: args{
+				container: &v1.Container{
+					Ports: []v1.ContainerPort{
+						{
+							Name:          "foo",
+							ContainerPort: 8080,
+						},
+						{
+							Name:          "bar",
+							ContainerPort: 9000,
+						},
+					},
+				},
+				portName: "http",
 			},
+			want:    0,
+			wantErr: true,
 		},
 	}
-	want := 8080
-	got, err := findPortByName(&container, "foo")
-	if got != want || err != nil {
-		t.Errorf("Expected %v, got %v, err: %v", want, got, err)
+
+	for _, tt := range tests {
+		tt := tt
+		t.Run(tt.name, func(t *testing.T) {
+			t.Parallel()
+			got, err := findPortByName(tt.args.container, tt.args.portName)
+			if (err != nil) != tt.wantErr {
+				t.Errorf("findPortByName() error = %v, wantErr %v", err, tt.wantErr)
+				return
+			}
+			if got != tt.want {
+				t.Errorf("findPortByName() = %v, want %v", got, tt.want)
+			}
+		})
 	}
 }
 
 func TestResolveContainerPort(t *testing.T) {
+	t.Parallel()
 	type args struct {
 		param     intstr.IntOrString
-		container v1.Container
+		container *v1.Container
 	}
 	tests := []struct {
 		name    string
@@ -55,39 +106,37 @@ func TestResolveContainerPort(t *testing.T) {
 		wantErr bool
 	}{
 		{
-			name: "get port by int val ",
+			name: "get port by int type",
 			args: args{
-				param: intstr.IntOrString{
-					Type:   0,
-					IntVal: 80,
-					StrVal: "foo",
-				},
-				container: v1.Container{
-					Ports: []v1.ContainerPort{
-						{
-							Name:          "foo",
-							ContainerPort: 8080,
-						},
-					},
-				},
+				param:     intstr.IntOrString{Type: 0, IntVal: 443},
+				container: &v1.Container{},
 			},
-			want:    80,
+			want:    443,
 			wantErr: false,
 		},
 		{
-			name: "get port by string val",
+			name: "invalid port",
 			args: args{
-				param: intstr.IntOrString{
-					Type:   1,
-					IntVal: 80,
-					StrVal: "foo",
-				},
-				container: v1.Container{
+				param:     intstr.IntOrString{Type: 0, IntVal: 66666},
+				container: &v1.Container{},
+			},
+			want:    66666,
+			wantErr: true,
+		},
+		{
+			name: "get port by port name",
+			args: args{
+				param: intstr.IntOrString{Type: 1, StrVal: "foo"},
+				container: &v1.Container{
 					Ports: []v1.ContainerPort{
 						{
 							Name:          "foo",
 							ContainerPort: 8080,
 						},
+						{
+							Name:          "bar",
+							ContainerPort: 9000,
+						},
 					},
 				},
 			},
@@ -95,49 +144,47 @@ func TestResolveContainerPort(t *testing.T) {
 			wantErr: false,
 		},
 		{
-			name: "get port by invalid type",
+			name: "no port name",
 			args: args{
-				param: intstr.IntOrString{
-					Type:   20,
-					IntVal: 80,
-					StrVal: "foo",
-				},
-				container: v1.Container{
+				param: intstr.IntOrString{Type: 1, StrVal: "foo"},
+				container: &v1.Container{
 					Ports: []v1.ContainerPort{
 						{
-							Name:          "foo",
-							ContainerPort: 8080,
+							Name:          "bar",
+							ContainerPort: 9000,
 						},
 					},
 				},
 			},
-			want:    -1,
+			want:    0,
 			wantErr: true,
 		},
 		{
-			name: "get invalid container port",
+			name: "invalid param type",
 			args: args{
-				param: intstr.IntOrString{
-					Type:   1,
-					StrVal: "foo",
-				},
-				container: v1.Container{
+				param: intstr.IntOrString{Type: 2, StrVal: "foo"},
+				container: &v1.Container{
 					Ports: []v1.ContainerPort{
 						{
 							Name:          "foo",
-							ContainerPort: 80800,
+							ContainerPort: 8080,
+						},
+						{
+							Name:          "bar",
+							ContainerPort: 9000,
 						},
 					},
 				},
 			},
-			want:    80800,
+			want:    -1,
 			wantErr: true,
 		},
 	}
-
 	for _, tt := range tests {
+		tt := tt
 		t.Run(tt.name, func(t *testing.T) {
-			got, err := ResolveContainerPort(tt.args.param, &tt.args.container)
+			t.Parallel()
+			got, err := ResolveContainerPort(tt.args.param, tt.args.container)
 			if (err != nil) != tt.wantErr {
 				t.Errorf("ResolveContainerPort() error = %v, wantErr %v", err, tt.wantErr)
 				return