pkg/scheduler/util/utils_test.go - third_party/kubernetes - Git at Google

 /*
 Copyright 2017 The Kubernetes Authors.

 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.
 You may obtain a copy of the License at

     http://www.apache.org/licenses/LICENSE-2.0

 Unless required by applicable law or agreed to in writing, software
 distributed under the License is distributed on an "AS IS" BASIS,
 WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 See the License for the specific language governing permissions and
 limitations under the License.
 */

 package util

 import (
 	"context"
 	"errors"
 	"fmt"
 	"syscall"
 	"testing"
 	"time"

 	"github.com/google/go-cmp/cmp"
 	v1 "k8s.io/api/core/v1"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/apimachinery/pkg/runtime"
 	"k8s.io/apimachinery/pkg/util/net"
 	clientsetfake "k8s.io/client-go/kubernetes/fake"
 	clienttesting "k8s.io/client-go/testing"
 	"k8s.io/klog/v2"
 	extenderv1 "k8s.io/kube-scheduler/extender/v1"
 )

 func TestGetPodFullName(t *testing.T) {
 	pod := &v1.Pod{
 		ObjectMeta: metav1.ObjectMeta{
 			Namespace: "test",
 			Name:      "pod",
 		},
 	}
 	got := GetPodFullName(pod)
 	expected := fmt.Sprintf("%s_%s", pod.Name, pod.Namespace)
 	if got != expected {
 		t.Errorf("Got wrong full name, got: %s, expected: %s", got, expected)
 	}
 }

 func newPriorityPodWithStartTime(name string, priority int32, startTime time.Time) *v1.Pod {
 	return &v1.Pod{
 		ObjectMeta: metav1.ObjectMeta{
 			Name: name,
 		},
 		Spec: v1.PodSpec{
 			Priority: &priority,
 		},
 		Status: v1.PodStatus{
 			StartTime: &metav1.Time{Time: startTime},
 		},
 	}
 }

 func TestGetEarliestPodStartTime(t *testing.T) {
 	var priority int32 = 1
 	currentTime := time.Now()
 	tests := []struct {
 		name              string
 		pods              []*v1.Pod
 		expectedStartTime *metav1.Time
 	}{
 		{
 			name:              "Pods length is 0",
 			pods:              []*v1.Pod{},
 			expectedStartTime: nil,
 		},
 		{
 			name: "generate new startTime",
 			pods: []*v1.Pod{
 				newPriorityPodWithStartTime("pod1", 1, currentTime.Add(-time.Second)),
 				{
 					ObjectMeta: metav1.ObjectMeta{
 						Name: "pod2",
 					},
 					Spec: v1.PodSpec{
 						Priority: &priority,
 					},
 				},
 			},
 			expectedStartTime: &metav1.Time{Time: currentTime.Add(-time.Second)},
 		},
 		{
 			name: "Pod with earliest start time last in the list",
 			pods: []*v1.Pod{
 				newPriorityPodWithStartTime("pod1", 1, currentTime.Add(time.Second)),
 				newPriorityPodWithStartTime("pod2", 2, currentTime.Add(time.Second)),
 				newPriorityPodWithStartTime("pod3", 2, currentTime),
 			},
 			expectedStartTime: &metav1.Time{Time: currentTime},
 		},
 		{
 			name: "Pod with earliest start time first in the list",
 			pods: []*v1.Pod{
 				newPriorityPodWithStartTime("pod1", 2, currentTime),
 				newPriorityPodWithStartTime("pod2", 2, currentTime.Add(time.Second)),
 				newPriorityPodWithStartTime("pod3", 2, currentTime.Add(2*time.Second)),
 			},
 			expectedStartTime: &metav1.Time{Time: currentTime},
 		},
 	}
 	for _, test := range tests {
 		t.Run(test.name, func(t *testing.T) {
 			startTime := GetEarliestPodStartTime(&extenderv1.Victims{Pods: test.pods})
 			if !startTime.Equal(test.expectedStartTime) {
 				t.Errorf("startTime is not the expected result,got %v, expected %v", startTime, test.expectedStartTime)
 			}
 		})
 	}
 }

 func TestMoreImportantPod(t *testing.T) {
 	currentTime := time.Now()
 	pod1 := newPriorityPodWithStartTime("pod1", 1, currentTime)
 	pod2 := newPriorityPodWithStartTime("pod2", 2, currentTime.Add(time.Second))
 	pod3 := newPriorityPodWithStartTime("pod3", 2, currentTime)

 	tests := map[string]struct {
 		p1       *v1.Pod
 		p2       *v1.Pod
 		expected bool
 	}{
 		"Pod with higher priority": {
 			p1:       pod1,
 			p2:       pod2,
 			expected: false,
 		},
 		"Pod with older created time": {
 			p1:       pod2,
 			p2:       pod3,
 			expected: false,
 		},
 		"Pods with same start time": {
 			p1:       pod3,
 			p2:       pod1,
 			expected: true,
 		},
 	}

 	for k, v := range tests {
 		t.Run(k, func(t *testing.T) {
 			got := MoreImportantPod(v.p1, v.p2)
 			if got != v.expected {
 				t.Errorf("expected %t but got %t", v.expected, got)
 			}
 		})
 	}
 }

 func TestRemoveNominatedNodeName(t *testing.T) {
 	tests := []struct {
 		name                     string
 		currentNominatedNodeName string
 		newNominatedNodeName     string
 		expectedPatchRequests    int
 		expectedPatchData        string
 	}{
 		{
 			name:                     "Should make patch request to clear node name",
 			currentNominatedNodeName: "node1",
 			expectedPatchRequests:    1,
 			expectedPatchData:        `{"status":{"nominatedNodeName":null}}`,
 		},
 		{
 			name:                     "Should not make patch request if nominated node is already cleared",
 			currentNominatedNodeName: "",
 			expectedPatchRequests:    0,
 		},
 	}
 	for _, test := range tests {
 		t.Run(test.name, func(t *testing.T) {
 			actualPatchRequests := 0
 			var actualPatchData string
 			cs := &clientsetfake.Clientset{}
 			cs.AddReactor("patch", "pods", func(action clienttesting.Action) (bool, runtime.Object, error) {
 				actualPatchRequests++
 				patch := action.(clienttesting.PatchAction)
 				actualPatchData = string(patch.GetPatch())
 				// For this test, we don't care about the result of the patched pod, just that we got the expected
 				// patch request, so just returning &v1.Pod{} here is OK because scheduler doesn't use the response.
 				return true, &v1.Pod{}, nil
 			})

 			pod := &v1.Pod{
 				ObjectMeta: metav1.ObjectMeta{Name: "foo"},
 				Status:     v1.PodStatus{NominatedNodeName: test.currentNominatedNodeName},
 			}

 			ctx, cancel := context.WithCancel(context.Background())
 			defer cancel()
 			if err := ClearNominatedNodeName(ctx, cs, pod); err != nil {
 				t.Fatalf("Error calling removeNominatedNodeName: %v", err)
 			}

 			if actualPatchRequests != test.expectedPatchRequests {
 				t.Fatalf("Actual patch requests (%d) dos not equal expected patch requests (%d)", actualPatchRequests, test.expectedPatchRequests)
 			}

 			if test.expectedPatchRequests > 0 && actualPatchData != test.expectedPatchData {
 				t.Fatalf("Patch data mismatch: Actual was %v, but expected %v", actualPatchData, test.expectedPatchData)
 			}
 		})
 	}
 }

 func TestPatchPodStatus(t *testing.T) {
 	tests := []struct {
 		name   string
 		pod    v1.Pod
 		client *clientsetfake.Clientset
 		// validateErr checks if error returned from PatchPodStatus is expected one or not.
 		// (true means error is expected one.)
 		validateErr    func(goterr error) bool
 		statusToUpdate v1.PodStatus
 	}{
 		{
 			name:   "Should update pod conditions successfully",
 			client: clientsetfake.NewSimpleClientset(),
 			pod: v1.Pod{
 				ObjectMeta: metav1.ObjectMeta{
 					Namespace: "ns",
 					Name:      "pod1",
 				},
 				Spec: v1.PodSpec{
 					ImagePullSecrets: []v1.LocalObjectReference{{Name: "foo"}},
 				},
 			},
 			statusToUpdate: v1.PodStatus{
 				Conditions: []v1.PodCondition{
 					{
 						Type:   v1.PodScheduled,
 						Status: v1.ConditionFalse,
 					},
 				},
 			},
 		},
 		{
 			// ref: #101697, #94626 - ImagePullSecrets are allowed to have empty secret names
 			// which would fail the 2-way merge patch generation on Pod patches
 			// due to the mergeKey being the name field
 			name:   "Should update pod conditions successfully on a pod Spec with secrets with empty name",
 			client: clientsetfake.NewSimpleClientset(),
 			pod: v1.Pod{
 				ObjectMeta: metav1.ObjectMeta{
 					Namespace: "ns",
 					Name:      "pod1",
 				},
 				Spec: v1.PodSpec{
 					// this will serialize to imagePullSecrets:[{}]
 					ImagePullSecrets: make([]v1.LocalObjectReference, 1),
 				},
 			},
 			statusToUpdate: v1.PodStatus{
 				Conditions: []v1.PodCondition{
 					{
 						Type:   v1.PodScheduled,
 						Status: v1.ConditionFalse,
 					},
 				},
 			},
 		},
 		{
 			name: "retry patch request when an 'connection refused' error is returned",
 			client: func() *clientsetfake.Clientset {
 				client := clientsetfake.NewSimpleClientset()

 				reqcount := 0
 				client.PrependReactor("patch", "pods", func(action clienttesting.Action) (bool, runtime.Object, error) {
 					defer func() { reqcount++ }()
 					if reqcount == 0 {
 						// return an connection refused error for the first patch request.
 						return true, &v1.Pod{}, fmt.Errorf("connection refused: %w", syscall.ECONNREFUSED)
 					}
 					if reqcount == 1 {
 						// not return error for the second patch request.
 						return false, &v1.Pod{}, nil
 					}

 					// return error if requests comes in more than three times.
 					return true, nil, errors.New("requests comes in more than three times.")
 				})

 				return client
 			}(),
 			pod: v1.Pod{
 				ObjectMeta: metav1.ObjectMeta{
 					Namespace: "ns",
 					Name:      "pod1",
 				},
 				Spec: v1.PodSpec{
 					ImagePullSecrets: []v1.LocalObjectReference{{Name: "foo"}},
 				},
 			},
 			statusToUpdate: v1.PodStatus{
 				Conditions: []v1.PodCondition{
 					{
 						Type:   v1.PodScheduled,
 						Status: v1.ConditionFalse,
 					},
 				},
 			},
 		},
 		{
 			name: "only 4 retries at most",
 			client: func() *clientsetfake.Clientset {
 				client := clientsetfake.NewSimpleClientset()

 				reqcount := 0
 				client.PrependReactor("patch", "pods", func(action clienttesting.Action) (bool, runtime.Object, error) {
 					defer func() { reqcount++ }()
 					if reqcount >= 4 {
 						// return error if requests comes in more than four times.
 						return true, nil, errors.New("requests comes in more than four times.")
 					}

 					// return an connection refused error for the first patch request.
 					return true, &v1.Pod{}, fmt.Errorf("connection refused: %w", syscall.ECONNREFUSED)
 				})

 				return client
 			}(),
 			pod: v1.Pod{
 				ObjectMeta: metav1.ObjectMeta{
 					Namespace: "ns",
 					Name:      "pod1",
 				},
 				Spec: v1.PodSpec{
 					ImagePullSecrets: []v1.LocalObjectReference{{Name: "foo"}},
 				},
 			},
 			validateErr: net.IsConnectionRefused,
 			statusToUpdate: v1.PodStatus{
 				Conditions: []v1.PodCondition{
 					{
 						Type:   v1.PodScheduled,
 						Status: v1.ConditionFalse,
 					},
 				},
 			},
 		},
 	}

 	for _, tc := range tests {
 		t.Run(tc.name, func(t *testing.T) {
 			client := tc.client
 			_, err := client.CoreV1().Pods(tc.pod.Namespace).Create(context.TODO(), &tc.pod, metav1.CreateOptions{})
 			if err != nil {
 				t.Fatal(err)
 			}

 			ctx, cancel := context.WithCancel(context.Background())
 			defer cancel()
 			err = PatchPodStatus(ctx, client, &tc.pod, &tc.statusToUpdate)
 			if err != nil && tc.validateErr == nil {
 				// shouldn't be error
 				t.Fatal(err)
 			}
 			if tc.validateErr != nil {
 				if !tc.validateErr(err) {
 					t.Fatalf("Returned unexpected error: %v", err)
 				}
 				return
 			}

 			retrievedPod, err := client.CoreV1().Pods(tc.pod.Namespace).Get(ctx, tc.pod.Name, metav1.GetOptions{})
 			if err != nil {
 				t.Fatal(err)
 			}

 			if diff := cmp.Diff(tc.statusToUpdate, retrievedPod.Status); diff != "" {
 				t.Errorf("unexpected pod status (-want,+got):\n%s", diff)
 			}
 		})
 	}
 }

 // Test_As tests the As function with Pod.
 func Test_As_Pod(t *testing.T) {
 	tests := []struct {
 		name       string
 		oldObj     interface{}
 		newObj     interface{}
 		wantOldObj *v1.Pod
 		wantNewObj *v1.Pod
 		wantErr    bool
 	}{
 		{
 			name:       "nil old Pod",
 			oldObj:     nil,
 			newObj:     &v1.Pod{ObjectMeta: metav1.ObjectMeta{Name: "foo"}},
 			wantOldObj: nil,
 			wantNewObj: &v1.Pod{ObjectMeta: metav1.ObjectMeta{Name: "foo"}},
 		},
 		{
 			name:       "nil new Pod",
 			oldObj:     &v1.Pod{ObjectMeta: metav1.ObjectMeta{Name: "foo"}},
 			newObj:     nil,
 			wantOldObj: &v1.Pod{ObjectMeta: metav1.ObjectMeta{Name: "foo"}},
 			wantNewObj: nil,
 		},
 		{
 			name:    "two different kinds of objects",
 			oldObj:  &v1.Pod{ObjectMeta: metav1.ObjectMeta{Name: "foo"}},
 			newObj:  &v1.Node{ObjectMeta: metav1.ObjectMeta{Name: "foo"}},
 			wantErr: true,
 		},
 	}

 	for _, tc := range tests {
 		t.Run(tc.name, func(t *testing.T) {
 			gotOld, gotNew, err := As[*v1.Pod](tc.oldObj, tc.newObj)
 			if err != nil && !tc.wantErr {
 				t.Fatalf("unexpected error: %v", err)
 			}
 			if tc.wantErr {
 				if err == nil {
 					t.Fatalf("expected error, but got nil")
 				}
 				return
 			}

 			if diff := cmp.Diff(tc.wantOldObj, gotOld); diff != "" {
 				t.Errorf("unexpected old object (-want,+got):\n%s", diff)
 			}
 			if diff := cmp.Diff(tc.wantNewObj, gotNew); diff != "" {
 				t.Errorf("unexpected new object (-want,+got):\n%s", diff)
 			}
 		})
 	}
 }

 // Test_As_Node tests the As function with Node.
 func Test_As_Node(t *testing.T) {
 	tests := []struct {
 		name       string
 		oldObj     interface{}
 		newObj     interface{}
 		wantOldObj *v1.Node
 		wantNewObj *v1.Node
 		wantErr    bool
 	}{
 		{
 			name:       "nil old Node",
 			oldObj:     nil,
 			newObj:     &v1.Node{ObjectMeta: metav1.ObjectMeta{Name: "foo"}},
 			wantOldObj: nil,
 			wantNewObj: &v1.Node{ObjectMeta: metav1.ObjectMeta{Name: "foo"}},
 		},
 		{
 			name:       "nil new Node",
 			oldObj:     &v1.Node{ObjectMeta: metav1.ObjectMeta{Name: "foo"}},
 			newObj:     nil,
 			wantOldObj: &v1.Node{ObjectMeta: metav1.ObjectMeta{Name: "foo"}},
 			wantNewObj: nil,
 		},
 	}

 	for _, tc := range tests {
 		t.Run(tc.name, func(t *testing.T) {
 			gotOld, gotNew, err := As[*v1.Node](tc.oldObj, tc.newObj)
 			if err != nil && !tc.wantErr {
 				t.Fatalf("unexpected error: %v", err)
 			}
 			if tc.wantErr {
 				if err == nil {
 					t.Fatalf("expected error, but got nil")
 				}
 				return
 			}

 			if diff := cmp.Diff(tc.wantOldObj, gotOld); diff != "" {
 				t.Errorf("unexpected old object (-want,+got):\n%s", diff)
 			}
 			if diff := cmp.Diff(tc.wantNewObj, gotNew); diff != "" {
 				t.Errorf("unexpected new object (-want,+got):\n%s", diff)
 			}
 		})
 	}
 }

 // Test_As_KMetadata tests the As function with Pod.
 func Test_As_KMetadata(t *testing.T) {
 	tests := []struct {
 		name    string
 		oldObj  interface{}
 		newObj  interface{}
 		wantErr bool
 	}{
 		{
 			name:    "nil old Pod",
 			oldObj:  nil,
 			newObj:  &v1.Pod{ObjectMeta: metav1.ObjectMeta{Name: "foo"}},
 			wantErr: false,
 		},
 		{
 			name:    "nil new Pod",
 			oldObj:  &v1.Pod{ObjectMeta: metav1.ObjectMeta{Name: "foo"}},
 			newObj:  nil,
 			wantErr: false,
 		},
 		{
 			name:    "two different kinds of objects",
 			oldObj:  &v1.Pod{ObjectMeta: metav1.ObjectMeta{Name: "foo"}},
 			newObj:  &v1.Node{ObjectMeta: metav1.ObjectMeta{Name: "foo"}},
 			wantErr: false,
 		},
 		{
 			name:    "unknown old type",
 			oldObj:  "unknown type",
 			wantErr: true,
 		},
 		{
 			name:    "unknown new type",
 			newObj:  "unknown type",
 			wantErr: true,
 		},
 	}

 	for _, tc := range tests {
 		t.Run(tc.name, func(t *testing.T) {
 			_, _, err := As[klog.KMetadata](tc.oldObj, tc.newObj)
 			if err != nil && !tc.wantErr {
 				t.Fatalf("unexpected error: %v", err)
 			}
 			if tc.wantErr {
 				if err == nil {
 					t.Fatalf("expected error, but got nil")
 				}
 				return
 			}
 		})
 	}
 }
	/*
	Copyright 2017 The Kubernetes Authors.

	Licensed under the Apache License, Version 2.0 (the "License");
	you may not use this file except in compliance with the License.
	You may obtain a copy of the License at

	http://www.apache.org/licenses/LICENSE-2.0

	Unless required by applicable law or agreed to in writing, software
	distributed under the License is distributed on an "AS IS" BASIS,
	WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	See the License for the specific language governing permissions and
	limitations under the License.
	*/

	package util

	import (
	"context"
	"errors"
	"fmt"
	"syscall"
	"testing"
	"time"

	"github.com/google/go-cmp/cmp"
	v1 "k8s.io/api/core/v1"
	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
	"k8s.io/apimachinery/pkg/runtime"
	"k8s.io/apimachinery/pkg/util/net"
	clientsetfake "k8s.io/client-go/kubernetes/fake"
	clienttesting "k8s.io/client-go/testing"
	"k8s.io/klog/v2"
	extenderv1 "k8s.io/kube-scheduler/extender/v1"
	)

	func TestGetPodFullName(t *testing.T) {
	pod := &v1.Pod{
	ObjectMeta: metav1.ObjectMeta{
	Namespace: "test",
	Name: "pod",
	},
	}
	got := GetPodFullName(pod)
	expected := fmt.Sprintf("%s_%s", pod.Name, pod.Namespace)
	if got != expected {
	t.Errorf("Got wrong full name, got: %s, expected: %s", got, expected)
	}
	}

	func newPriorityPodWithStartTime(name string, priority int32, startTime time.Time) *v1.Pod {
	return &v1.Pod{
	ObjectMeta: metav1.ObjectMeta{
	Name: name,
	},
	Spec: v1.PodSpec{
	Priority: &priority,
	},
	Status: v1.PodStatus{
	StartTime: &metav1.Time{Time: startTime},
	},
	}
	}

	func TestGetEarliestPodStartTime(t *testing.T) {
	var priority int32 = 1
	currentTime := time.Now()
	tests := []struct {
	name string
	pods []*v1.Pod
	expectedStartTime *metav1.Time
	}{
	{
	name: "Pods length is 0",
	pods: []*v1.Pod{},
	expectedStartTime: nil,
	},
	{
	name: "generate new startTime",
	pods: []*v1.Pod{
	newPriorityPodWithStartTime("pod1", 1, currentTime.Add(-time.Second)),
	{
	ObjectMeta: metav1.ObjectMeta{
	Name: "pod2",
	},
	Spec: v1.PodSpec{
	Priority: &priority,
	},
	},
	},
	expectedStartTime: &metav1.Time{Time: currentTime.Add(-time.Second)},
	},
	{
	name: "Pod with earliest start time last in the list",
	pods: []*v1.Pod{
	newPriorityPodWithStartTime("pod1", 1, currentTime.Add(time.Second)),
	newPriorityPodWithStartTime("pod2", 2, currentTime.Add(time.Second)),
	newPriorityPodWithStartTime("pod3", 2, currentTime),
	},
	expectedStartTime: &metav1.Time{Time: currentTime},
	},
	{
	name: "Pod with earliest start time first in the list",
	pods: []*v1.Pod{
	newPriorityPodWithStartTime("pod1", 2, currentTime),
	newPriorityPodWithStartTime("pod2", 2, currentTime.Add(time.Second)),
	newPriorityPodWithStartTime("pod3", 2, currentTime.Add(2*time.Second)),
	},
	expectedStartTime: &metav1.Time{Time: currentTime},
	},
	}
	for _, test := range tests {
	t.Run(test.name, func(t *testing.T) {
	startTime := GetEarliestPodStartTime(&extenderv1.Victims{Pods: test.pods})
	if !startTime.Equal(test.expectedStartTime) {
	t.Errorf("startTime is not the expected result,got %v, expected %v", startTime, test.expectedStartTime)
	}
	})
	}
	}

	func TestMoreImportantPod(t *testing.T) {
	currentTime := time.Now()
	pod1 := newPriorityPodWithStartTime("pod1", 1, currentTime)
	pod2 := newPriorityPodWithStartTime("pod2", 2, currentTime.Add(time.Second))
	pod3 := newPriorityPodWithStartTime("pod3", 2, currentTime)

	tests := map[string]struct {
	p1 *v1.Pod
	p2 *v1.Pod
	expected bool
	}{
	"Pod with higher priority": {
	p1: pod1,
	p2: pod2,
	expected: false,
	},
	"Pod with older created time": {
	p1: pod2,
	p2: pod3,
	expected: false,
	},
	"Pods with same start time": {
	p1: pod3,
	p2: pod1,
	expected: true,
	},
	}

	for k, v := range tests {
	t.Run(k, func(t *testing.T) {
	got := MoreImportantPod(v.p1, v.p2)
	if got != v.expected {
	t.Errorf("expected %t but got %t", v.expected, got)
	}
	})
	}
	}

	func TestRemoveNominatedNodeName(t *testing.T) {
	tests := []struct {
	name string
	currentNominatedNodeName string
	newNominatedNodeName string
	expectedPatchRequests int
	expectedPatchData string
	}{
	{
	name: "Should make patch request to clear node name",
	currentNominatedNodeName: "node1",
	expectedPatchRequests: 1,
	expectedPatchData: `{"status":{"nominatedNodeName":null}}`,
	},
	{
	name: "Should not make patch request if nominated node is already cleared",
	currentNominatedNodeName: "",
	expectedPatchRequests: 0,
	},
	}
	for _, test := range tests {
	t.Run(test.name, func(t *testing.T) {
	actualPatchRequests := 0
	var actualPatchData string
	cs := &clientsetfake.Clientset{}
	cs.AddReactor("patch", "pods", func(action clienttesting.Action) (bool, runtime.Object, error) {
	actualPatchRequests++
	patch := action.(clienttesting.PatchAction)
	actualPatchData = string(patch.GetPatch())
	// For this test, we don't care about the result of the patched pod, just that we got the expected
	// patch request, so just returning &v1.Pod{} here is OK because scheduler doesn't use the response.
	return true, &v1.Pod{}, nil
	})

	pod := &v1.Pod{
	ObjectMeta: metav1.ObjectMeta{Name: "foo"},
	Status: v1.PodStatus{NominatedNodeName: test.currentNominatedNodeName},
	}

	ctx, cancel := context.WithCancel(context.Background())
	defer cancel()
	if err := ClearNominatedNodeName(ctx, cs, pod); err != nil {
	t.Fatalf("Error calling removeNominatedNodeName: %v", err)
	}

	if actualPatchRequests != test.expectedPatchRequests {
	t.Fatalf("Actual patch requests (%d) dos not equal expected patch requests (%d)", actualPatchRequests, test.expectedPatchRequests)
	}

	if test.expectedPatchRequests > 0 && actualPatchData != test.expectedPatchData {
	t.Fatalf("Patch data mismatch: Actual was %v, but expected %v", actualPatchData, test.expectedPatchData)
	}
	})
	}
	}

	func TestPatchPodStatus(t *testing.T) {
	tests := []struct {
	name string
	pod v1.Pod
	client *clientsetfake.Clientset
	// validateErr checks if error returned from PatchPodStatus is expected one or not.
	// (true means error is expected one.)
	validateErr func(goterr error) bool
	statusToUpdate v1.PodStatus
	}{
	{
	name: "Should update pod conditions successfully",
	client: clientsetfake.NewSimpleClientset(),
	pod: v1.Pod{
	ObjectMeta: metav1.ObjectMeta{
	Namespace: "ns",
	Name: "pod1",
	},
	Spec: v1.PodSpec{
	ImagePullSecrets: []v1.LocalObjectReference{{Name: "foo"}},
	},
	},
	statusToUpdate: v1.PodStatus{
	Conditions: []v1.PodCondition{
	{
	Type: v1.PodScheduled,
	Status: v1.ConditionFalse,
	},
	},
	},
	},
	{
	// ref: #101697, #94626 - ImagePullSecrets are allowed to have empty secret names
	// which would fail the 2-way merge patch generation on Pod patches
	// due to the mergeKey being the name field
	name: "Should update pod conditions successfully on a pod Spec with secrets with empty name",
	client: clientsetfake.NewSimpleClientset(),
	pod: v1.Pod{
	ObjectMeta: metav1.ObjectMeta{
	Namespace: "ns",
	Name: "pod1",
	},
	Spec: v1.PodSpec{
	// this will serialize to imagePullSecrets:[{}]
	ImagePullSecrets: make([]v1.LocalObjectReference, 1),
	},
	},
	statusToUpdate: v1.PodStatus{
	Conditions: []v1.PodCondition{
	{
	Type: v1.PodScheduled,
	Status: v1.ConditionFalse,
	},
	},
	},
	},
	{
	name: "retry patch request when an 'connection refused' error is returned",
	client: func() *clientsetfake.Clientset {
	client := clientsetfake.NewSimpleClientset()

	reqcount := 0
	client.PrependReactor("patch", "pods", func(action clienttesting.Action) (bool, runtime.Object, error) {
	defer func() { reqcount++ }()
	if reqcount == 0 {
	// return an connection refused error for the first patch request.
	return true, &v1.Pod{}, fmt.Errorf("connection refused: %w", syscall.ECONNREFUSED)
	}
	if reqcount == 1 {
	// not return error for the second patch request.
	return false, &v1.Pod{}, nil
	}

	// return error if requests comes in more than three times.
	return true, nil, errors.New("requests comes in more than three times.")
	})

	return client
	}(),
	pod: v1.Pod{
	ObjectMeta: metav1.ObjectMeta{
	Namespace: "ns",
	Name: "pod1",
	},
	Spec: v1.PodSpec{
	ImagePullSecrets: []v1.LocalObjectReference{{Name: "foo"}},
	},
	},
	statusToUpdate: v1.PodStatus{
	Conditions: []v1.PodCondition{
	{
	Type: v1.PodScheduled,
	Status: v1.ConditionFalse,
	},
	},
	},
	},
	{
	name: "only 4 retries at most",
	client: func() *clientsetfake.Clientset {
	client := clientsetfake.NewSimpleClientset()

	reqcount := 0
	client.PrependReactor("patch", "pods", func(action clienttesting.Action) (bool, runtime.Object, error) {
	defer func() { reqcount++ }()
	if reqcount >= 4 {
	// return error if requests comes in more than four times.
	return true, nil, errors.New("requests comes in more than four times.")
	}

	// return an connection refused error for the first patch request.
	return true, &v1.Pod{}, fmt.Errorf("connection refused: %w", syscall.ECONNREFUSED)
	})

	return client
	}(),
	pod: v1.Pod{
	ObjectMeta: metav1.ObjectMeta{
	Namespace: "ns",
	Name: "pod1",
	},
	Spec: v1.PodSpec{
	ImagePullSecrets: []v1.LocalObjectReference{{Name: "foo"}},
	},
	},
	validateErr: net.IsConnectionRefused,
	statusToUpdate: v1.PodStatus{
	Conditions: []v1.PodCondition{
	{
	Type: v1.PodScheduled,
	Status: v1.ConditionFalse,
	},
	},
	},
	},
	}

	for _, tc := range tests {
	t.Run(tc.name, func(t *testing.T) {
	client := tc.client
	_, err := client.CoreV1().Pods(tc.pod.Namespace).Create(context.TODO(), &tc.pod, metav1.CreateOptions{})
	if err != nil {
	t.Fatal(err)
	}

	ctx, cancel := context.WithCancel(context.Background())
	defer cancel()
	err = PatchPodStatus(ctx, client, &tc.pod, &tc.statusToUpdate)
	if err != nil && tc.validateErr == nil {
	// shouldn't be error
	t.Fatal(err)
	}
	if tc.validateErr != nil {
	if !tc.validateErr(err) {
	t.Fatalf("Returned unexpected error: %v", err)
	}
	return
	}

	retrievedPod, err := client.CoreV1().Pods(tc.pod.Namespace).Get(ctx, tc.pod.Name, metav1.GetOptions{})
	if err != nil {
	t.Fatal(err)
	}

	if diff := cmp.Diff(tc.statusToUpdate, retrievedPod.Status); diff != "" {
	t.Errorf("unexpected pod status (-want,+got):\n%s", diff)
	}
	})
	}
	}

	// Test_As tests the As function with Pod.
	func Test_As_Pod(t *testing.T) {
	tests := []struct {
	name string
	oldObj interface{}
	newObj interface{}
	wantOldObj *v1.Pod
	wantNewObj *v1.Pod
	wantErr bool
	}{
	{
	name: "nil old Pod",
	oldObj: nil,
	newObj: &v1.Pod{ObjectMeta: metav1.ObjectMeta{Name: "foo"}},
	wantOldObj: nil,
	wantNewObj: &v1.Pod{ObjectMeta: metav1.ObjectMeta{Name: "foo"}},
	},
	{
	name: "nil new Pod",
	oldObj: &v1.Pod{ObjectMeta: metav1.ObjectMeta{Name: "foo"}},
	newObj: nil,
	wantOldObj: &v1.Pod{ObjectMeta: metav1.ObjectMeta{Name: "foo"}},
	wantNewObj: nil,
	},
	{
	name: "two different kinds of objects",
	oldObj: &v1.Pod{ObjectMeta: metav1.ObjectMeta{Name: "foo"}},
	newObj: &v1.Node{ObjectMeta: metav1.ObjectMeta{Name: "foo"}},
	wantErr: true,
	},
	}

	for _, tc := range tests {
	t.Run(tc.name, func(t *testing.T) {
	gotOld, gotNew, err := As[*v1.Pod](tc.oldObj, tc.newObj)
	if err != nil && !tc.wantErr {
	t.Fatalf("unexpected error: %v", err)
	}
	if tc.wantErr {
	if err == nil {
	t.Fatalf("expected error, but got nil")
	}
	return
	}

	if diff := cmp.Diff(tc.wantOldObj, gotOld); diff != "" {
	t.Errorf("unexpected old object (-want,+got):\n%s", diff)
	}
	if diff := cmp.Diff(tc.wantNewObj, gotNew); diff != "" {
	t.Errorf("unexpected new object (-want,+got):\n%s", diff)
	}
	})
	}
	}

	// Test_As_Node tests the As function with Node.
	func Test_As_Node(t *testing.T) {
	tests := []struct {
	name string
	oldObj interface{}
	newObj interface{}
	wantOldObj *v1.Node
	wantNewObj *v1.Node
	wantErr bool
	}{
	{
	name: "nil old Node",
	oldObj: nil,
	newObj: &v1.Node{ObjectMeta: metav1.ObjectMeta{Name: "foo"}},
	wantOldObj: nil,
	wantNewObj: &v1.Node{ObjectMeta: metav1.ObjectMeta{Name: "foo"}},
	},
	{
	name: "nil new Node",
	oldObj: &v1.Node{ObjectMeta: metav1.ObjectMeta{Name: "foo"}},
	newObj: nil,
	wantOldObj: &v1.Node{ObjectMeta: metav1.ObjectMeta{Name: "foo"}},
	wantNewObj: nil,
	},
	}

	for _, tc := range tests {
	t.Run(tc.name, func(t *testing.T) {
	gotOld, gotNew, err := As[*v1.Node](tc.oldObj, tc.newObj)
	if err != nil && !tc.wantErr {
	t.Fatalf("unexpected error: %v", err)
	}
	if tc.wantErr {
	if err == nil {
	t.Fatalf("expected error, but got nil")
	}
	return
	}

	if diff := cmp.Diff(tc.wantOldObj, gotOld); diff != "" {
	t.Errorf("unexpected old object (-want,+got):\n%s", diff)
	}
	if diff := cmp.Diff(tc.wantNewObj, gotNew); diff != "" {
	t.Errorf("unexpected new object (-want,+got):\n%s", diff)
	}
	})
	}
	}

	// Test_As_KMetadata tests the As function with Pod.
	func Test_As_KMetadata(t *testing.T) {
	tests := []struct {
	name string
	oldObj interface{}
	newObj interface{}
	wantErr bool
	}{
	{
	name: "nil old Pod",
	oldObj: nil,
	newObj: &v1.Pod{ObjectMeta: metav1.ObjectMeta{Name: "foo"}},
	wantErr: false,
	},
	{
	name: "nil new Pod",
	oldObj: &v1.Pod{ObjectMeta: metav1.ObjectMeta{Name: "foo"}},
	newObj: nil,
	wantErr: false,
	},
	{
	name: "two different kinds of objects",
	oldObj: &v1.Pod{ObjectMeta: metav1.ObjectMeta{Name: "foo"}},
	newObj: &v1.Node{ObjectMeta: metav1.ObjectMeta{Name: "foo"}},
	wantErr: false,
	},
	{
	name: "unknown old type",
	oldObj: "unknown type",
	wantErr: true,
	},
	{
	name: "unknown new type",
	newObj: "unknown type",
	wantErr: true,
	},
	}

	for _, tc := range tests {
	t.Run(tc.name, func(t *testing.T) {
	_, _, err := As[klog.KMetadata](tc.oldObj, tc.newObj)
	if err != nil && !tc.wantErr {
	t.Fatalf("unexpected error: %v", err)
	}
	if tc.wantErr {
	if err == nil {
	t.Fatalf("expected error, but got nil")
	}
	return
	}
	})
	}
	}