Sok3t/descheduler
1
0
Fork 0
mirror of https://github.com/kubernetes-sigs/descheduler.git synced 2026-01-26 21:31:18 +01:00
Code Packages Releases Activity
Files
96657caf601392088b1d8045357a15b7d5e6ec56
descheduler/pkg/utils/predicates_test.go
Jordi Piqué Sellés 31704047c5 feat: Implement preferredDuringSchedulingIgnoredDuringExecution for RemovePodsViolatingNodeAffinity (#1210) 
* feat: Implement preferredDuringSchedulingIgnoredDuringExecution for RemovePodsViolatingNodeAffinity

Now, the descheduler can detect and evict pods that are not optimally
allocated according to the "preferred..." node affinity. It only evicts
a pod if it can be scheduled on a node that scores higher in terms of
preferred node affinity than the current one.

This can be activated by enabling the RemovePodsViolatingNodeAffinity
plugin and passing "preferredDuringSchedulingIgnoredDuringExecution" in
the args.

For example, imagine we have a pod that prefers nodes with label "key1:
value1" with a weight of 10. If this pod is scheduled on a node that
doesn't have "key1: value1" as label but there's another node that has
this label and where this pod can potentially run, then the descheduler
will evict the pod.

Another effect of this commit is that the
RemovePodsViolatingNodeAffinity plugin will not remove pods that don't
fit in the current node but for other reasons than violating the node
affinity. Before that, enabling this plugin could cause evictions on
pods that were running on tainted nodes without the necessary
tolerations.

This commit also fixes the wording of some tests from
node_affinity_test.go and some parameters and expectations of these
tests, which were wrong.

* Optimization on RemovePodsViolatingNodeAffinity

Before checking if a pod can be evicted or if it can be scheduled
somewhere else, we first check if it has the corresponding nodeAffinity
field defined. Otherwise, the pod is automatically discarded as a
candidate.

Apart from that, the method that calculates the weight that a pod
gives to a node based on its preferred node affinity has been
renamed to better reflect what it does.
2023-08-04 03:08:21 -07:00

1044 lines
23 KiB
Go
Raw Blame History

package utils
import (
"reflect"
"testing"
v1 "k8s.io/api/core/v1"
metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
)
func TestUniqueSortTolerations(t *testing.T) {
tests := []struct {
name string
tolerations []v1.Toleration
expectedTolerations []v1.Toleration
}{
{
name: "sort by key",
tolerations: []v1.Toleration{
{
Key: "key2",
Operator: v1.TolerationOpEqual,
Value: "value2",
Effect: v1.TaintEffectNoSchedule,
},
{
Key: "key3",
Operator: v1.TolerationOpEqual,
Value: "value3",
Effect: v1.TaintEffectNoSchedule,
},
{
Key: "key1",
Operator: v1.TolerationOpEqual,
Value: "value1",
Effect: v1.TaintEffectNoSchedule,
},
},
expectedTolerations: []v1.Toleration{
{
Key: "key1",
Operator: v1.TolerationOpEqual,
Value: "value1",
Effect: v1.TaintEffectNoSchedule,
},
{
Key: "key2",
Operator: v1.TolerationOpEqual,
Value: "value2",
Effect: v1.TaintEffectNoSchedule,
},
{
Key: "key3",
Operator: v1.TolerationOpEqual,
Value: "value3",
Effect: v1.TaintEffectNoSchedule,
},
},
},
{
name: "sort by value",
tolerations: []v1.Toleration{
{
Key: "key1",
Operator: v1.TolerationOpEqual,
Value: "value2",
Effect: v1.TaintEffectNoSchedule,
},
{
Key: "key1",
Operator: v1.TolerationOpEqual,
Value: "value3",
Effect: v1.TaintEffectNoSchedule,
},
{
Key: "key1",
Operator: v1.TolerationOpEqual,
Value: "value1",
Effect: v1.TaintEffectNoSchedule,
},
},
expectedTolerations: []v1.Toleration{
{
Key: "key1",
Operator: v1.TolerationOpEqual,
Value: "value1",
Effect: v1.TaintEffectNoSchedule,
},
{
Key: "key1",
Operator: v1.TolerationOpEqual,
Value: "value2",
Effect: v1.TaintEffectNoSchedule,
},
{
Key: "key1",
Operator: v1.TolerationOpEqual,
Value: "value3",
Effect: v1.TaintEffectNoSchedule,
},
},
},
{
name: "sort by effect",
tolerations: []v1.Toleration{
{
Key: "key1",
Operator: v1.TolerationOpEqual,
Value: "value1",
Effect: v1.TaintEffectNoSchedule,
},
{
Key: "key1",
Operator: v1.TolerationOpEqual,
Value: "value1",
Effect: v1.TaintEffectNoExecute,
},
{
Key: "key1",
Operator: v1.TolerationOpEqual,
Value: "value1",
Effect: v1.TaintEffectPreferNoSchedule,
},
},
expectedTolerations: []v1.Toleration{
{
Key: "key1",
Operator: v1.TolerationOpEqual,
Value: "value1",
Effect: v1.TaintEffectNoExecute,
},
{
Key: "key1",
Operator: v1.TolerationOpEqual,
Value: "value1",
Effect: v1.TaintEffectNoSchedule,
},
{
Key: "key1",
Operator: v1.TolerationOpEqual,
Value: "value1",
Effect: v1.TaintEffectPreferNoSchedule,
},
},
},
{
name: "sort unique",
tolerations: []v1.Toleration{
{
Key: "key1",
Operator: v1.TolerationOpEqual,
Value: "value1",
Effect: v1.TaintEffectNoSchedule,
},
{
Key: "key2",
Operator: v1.TolerationOpEqual,
Value: "value2",
Effect: v1.TaintEffectNoSchedule,
},
{
Key: "key2",
Operator: v1.TolerationOpEqual,
Value: "value2",
Effect: v1.TaintEffectNoSchedule,
},
},
expectedTolerations: []v1.Toleration{
{
Key: "key1",
Operator: v1.TolerationOpEqual,
Value: "value1",
Effect: v1.TaintEffectNoSchedule,
},
{
Key: "key2",
Operator: v1.TolerationOpEqual,
Value: "value2",
Effect: v1.TaintEffectNoSchedule,
},
},
},
}
for _, test := range tests {
t.Run(test.name, func(t *testing.T) {
resultTolerations := uniqueSortTolerations(test.tolerations)
if !reflect.DeepEqual(resultTolerations, test.expectedTolerations) {
t.Errorf("tolerations not sorted as expected, \n\tgot: %#v, \n\texpected: %#v", resultTolerations, test.expectedTolerations)
}
})
}
}
func TestTolerationsEqual(t *testing.T) {
tests := []struct {
name string
leftTolerations, rightTolerations []v1.Toleration
equal bool
}{
{
name: "identical lists",
leftTolerations: []v1.Toleration{
{
Key: "key1",
Operator: v1.TolerationOpEqual,
Value: "value1",
Effect: v1.TaintEffectNoSchedule,
},
{
Key: "key2",
Operator: v1.TolerationOpEqual,
Value: "value2",
Effect: v1.TaintEffectNoSchedule,
},
},
rightTolerations: []v1.Toleration{
{
Key: "key1",
Operator: v1.TolerationOpEqual,
Value: "value1",
Effect: v1.TaintEffectNoSchedule,
},
{
Key: "key2",
Operator: v1.TolerationOpEqual,
Value: "value2",
Effect: v1.TaintEffectNoSchedule,
},
},
equal: true,
},
{
name: "equal lists",
leftTolerations: []v1.Toleration{
{
Key: "key1",
Operator: v1.TolerationOpEqual,
Value: "value1",
Effect: v1.TaintEffectNoSchedule,
},
{
Key: "key2",
Operator: v1.TolerationOpEqual,
Value: "value2",
Effect: v1.TaintEffectNoSchedule,
},
{
Key: "key2",
Operator: v1.TolerationOpEqual,
Value: "value2",
Effect: v1.TaintEffectNoSchedule,
},
},
rightTolerations: []v1.Toleration{
{
Key: "key1",
Operator: v1.TolerationOpEqual,
Value: "value1",
Effect: v1.TaintEffectNoSchedule,
},
{
Key: "key2",
Operator: v1.TolerationOpEqual,
Value: "value2",
Effect: v1.TaintEffectNoSchedule,
},
},
equal: true,
},
{
name: "non-equal lists",
leftTolerations: []v1.Toleration{
{
Key: "key1",
Operator: v1.TolerationOpEqual,
Value: "value1",
Effect: v1.TaintEffectNoSchedule,
},
{
Key: "key2",
Operator: v1.TolerationOpEqual,
Value: "value2",
Effect: v1.TaintEffectNoSchedule,
},
},
rightTolerations: []v1.Toleration{
{
Key: "key1",
Operator: v1.TolerationOpEqual,
Value: "value1",
Effect: v1.TaintEffectNoSchedule,
},
{
Key: "key2",
Operator: v1.TolerationOpEqual,
Value: "value2",
Effect: v1.TaintEffectNoExecute,
},
},
equal: false,
},
{
name: "different sizes lists",
leftTolerations: []v1.Toleration{
{
Key: "key1",
Operator: v1.TolerationOpEqual,
Value: "value1",
Effect: v1.TaintEffectNoSchedule,
},
},
rightTolerations: []v1.Toleration{
{
Key: "key1",
Operator: v1.TolerationOpEqual,
Value: "value1",
Effect: v1.TaintEffectNoSchedule,
},
{
Key: "key2",
Operator: v1.TolerationOpEqual,
Value: "value2",
Effect: v1.TaintEffectNoExecute,
},
},
equal: false,
},
}
for _, test := range tests {
t.Run(test.name, func(t *testing.T) {
equal := TolerationsEqual(test.leftTolerations, test.rightTolerations)
if equal != test.equal {
t.Errorf("TolerationsEqual expected to be %v, got %v", test.equal, equal)
}
})
}
}
func TestUniqueSortNodeSelectorRequirements(t *testing.T) {
tests := []struct {
name string
requirements []v1.NodeSelectorRequirement
expectedRequirements []v1.NodeSelectorRequirement
}{
{
name: "Identical requirements",
requirements: []v1.NodeSelectorRequirement{
{
Key: "k1",
Operator: v1.NodeSelectorOpIn,
Values: []string{"v1"},
},
{
Key: "k1",
Operator: v1.NodeSelectorOpIn,
Values: []string{"v1"},
},
},
expectedRequirements: []v1.NodeSelectorRequirement{
{
Key: "k1",
Operator: v1.NodeSelectorOpIn,
Values: []string{"v1"},
},
},
},
{
name: "Sorted requirements",
requirements: []v1.NodeSelectorRequirement{
{
Key: "k1",
Operator: v1.NodeSelectorOpIn,
Values: []string{"v1"},
},
{
Key: "k2",
Operator: v1.NodeSelectorOpIn,
Values: []string{"v2"},
},
},
expectedRequirements: []v1.NodeSelectorRequirement{
{
Key: "k1",
Operator: v1.NodeSelectorOpIn,
Values: []string{"v1"},
},
{
Key: "k2",
Operator: v1.NodeSelectorOpIn,
Values: []string{"v2"},
},
},
},
{
name: "Sort values",
requirements: []v1.NodeSelectorRequirement{
{
Key: "k1",
Operator: v1.NodeSelectorOpIn,
Values: []string{"v2", "v1"},
},
},
expectedRequirements: []v1.NodeSelectorRequirement{
{
Key: "k1",
Operator: v1.NodeSelectorOpIn,
Values: []string{"v1", "v2"},
},
},
},
{
name: "Sort by key",
requirements: []v1.NodeSelectorRequirement{
{
Key: "k3",
Operator: v1.NodeSelectorOpIn,
Values: []string{"v1", "v2"},
},
{
Key: "k2",
Operator: v1.NodeSelectorOpIn,
Values: []string{"v1", "v2"},
},
{
Key: "k1",
Operator: v1.NodeSelectorOpIn,
Values: []string{"v1", "v2"},
},
},
expectedRequirements: []v1.NodeSelectorRequirement{
{
Key: "k1",
Operator: v1.NodeSelectorOpIn,
Values: []string{"v1", "v2"},
},
{
Key: "k2",
Operator: v1.NodeSelectorOpIn,
Values: []string{"v1", "v2"},
},
{
Key: "k3",
Operator: v1.NodeSelectorOpIn,
Values: []string{"v1", "v2"},
},
},
},
{
name: "Sort by operator",
requirements: []v1.NodeSelectorRequirement{
{
Key: "k1",
Operator: v1.NodeSelectorOpIn,
Values: []string{"v1", "v2"},
},
{
Key: "k1",
Operator: v1.NodeSelectorOpExists,
Values: []string{"v1", "v2"},
},
{
Key: "k1",
Operator: v1.NodeSelectorOpGt,
Values: []string{"v1", "v2"},
},
},
expectedRequirements: []v1.NodeSelectorRequirement{
{
Key: "k1",
Operator: v1.NodeSelectorOpExists,
Values: []string{"v1", "v2"},
},
{
Key: "k1",
Operator: v1.NodeSelectorOpGt,
Values: []string{"v1", "v2"},
},
{
Key: "k1",
Operator: v1.NodeSelectorOpIn,
Values: []string{"v1", "v2"},
},
},
},
{
name: "Sort by values",
requirements: []v1.NodeSelectorRequirement{
{
Key: "k1",
Operator: v1.NodeSelectorOpIn,
Values: []string{"v6", "v5"},
},
{
Key: "k1",
Operator: v1.NodeSelectorOpIn,
Values: []string{"v2", "v1"},
},
{
Key: "k1",
Operator: v1.NodeSelectorOpIn,
Values: []string{"v4", "v1"},
},
},
expectedRequirements: []v1.NodeSelectorRequirement{
{
Key: "k1",
Operator: v1.NodeSelectorOpIn,
Values: []string{"v1", "v2"},
},
{
Key: "k1",
Operator: v1.NodeSelectorOpIn,
Values: []string{"v1", "v4"},
},
{
Key: "k1",
Operator: v1.NodeSelectorOpIn,
Values: []string{"v5", "v6"},
},
},
},
}
for _, test := range tests {
t.Run(test.name, func(t *testing.T) {
resultRequirements := uniqueSortNodeSelectorRequirements(test.requirements)
if !reflect.DeepEqual(resultRequirements, test.expectedRequirements) {
t.Errorf("Requirements not sorted as expected, \n\tgot: %#v, \n\texpected: %#v", resultRequirements, test.expectedRequirements)
}
})
}
}
func TestUniqueSortNodeSelectorTerms(t *testing.T) {
tests := []struct {
name string
terms []v1.NodeSelectorTerm
expectedTerms []v1.NodeSelectorTerm
}{
{
name: "Identical terms",
terms: []v1.NodeSelectorTerm{
{
MatchExpressions: []v1.NodeSelectorRequirement{
{
Key: "k1",
Operator: v1.NodeSelectorOpIn,
Values: []string{"v1"},
},
{
Key: "k1",
Operator: v1.NodeSelectorOpIn,
Values: []string{"v1"},
},
},
MatchFields: []v1.NodeSelectorRequirement{
{
Key: "k1",
Operator: v1.NodeSelectorOpIn,
Values: []string{"v1"},
},
{
Key: "k1",
Operator: v1.NodeSelectorOpIn,
Values: []string{"v1"},
},
},
},
},
expectedTerms: []v1.NodeSelectorTerm{
{
MatchExpressions: []v1.NodeSelectorRequirement{
{
Key: "k1",
Operator: v1.NodeSelectorOpIn,
Values: []string{"v1"},
},
},
MatchFields: []v1.NodeSelectorRequirement{
{
Key: "k1",
Operator: v1.NodeSelectorOpIn,
Values: []string{"v1"},
},
},
},
},
},
{
name: "Sorted terms",
terms: []v1.NodeSelectorTerm{
{
MatchExpressions: []v1.NodeSelectorRequirement{
{
Key: "k1",
Operator: v1.NodeSelectorOpIn,
Values: []string{"v1"},
},
{
Key: "k2",
Operator: v1.NodeSelectorOpIn,
Values: []string{"v1"},
},
},
MatchFields: []v1.NodeSelectorRequirement{
{
Key: "k1",
Operator: v1.NodeSelectorOpIn,
Values: []string{"v1"},
},
{
Key: "k2",
Operator: v1.NodeSelectorOpIn,
Values: []string{"v1"},
},
},
},
},
expectedTerms: []v1.NodeSelectorTerm{
{
MatchExpressions: []v1.NodeSelectorRequirement{
{
Key: "k1",
Operator: v1.NodeSelectorOpIn,
Values: []string{"v1"},
},
{
Key: "k2",
Operator: v1.NodeSelectorOpIn,
Values: []string{"v1"},
},
},
MatchFields: []v1.NodeSelectorRequirement{
{
Key: "k1",
Operator: v1.NodeSelectorOpIn,
Values: []string{"v1"},
},
{
Key: "k2",
Operator: v1.NodeSelectorOpIn,
Values: []string{"v1"},
},
},
},
},
},
{
name: "Sort terms",
terms: []v1.NodeSelectorTerm{
{
MatchExpressions: []v1.NodeSelectorRequirement{
{
Key: "k2",
Operator: v1.NodeSelectorOpIn,
Values: []string{"v1"},
},
{
Key: "k1",
Operator: v1.NodeSelectorOpIn,
Values: []string{"v2", "v1"},
},
{
Key: "k1",
Operator: v1.NodeSelectorOpIn,
Values: []string{"v3", "v1"},
},
},
},
},
expectedTerms: []v1.NodeSelectorTerm{
{
MatchExpressions: []v1.NodeSelectorRequirement{
{
Key: "k1",
Operator: v1.NodeSelectorOpIn,
Values: []string{"v1", "v2"},
},
{
Key: "k1",
Operator: v1.NodeSelectorOpIn,
Values: []string{"v1", "v3"},
},
{
Key: "k2",
Operator: v1.NodeSelectorOpIn,
Values: []string{"v1"},
},
},
},
},
},
{
name: "Unique sort terms",
terms: []v1.NodeSelectorTerm{
{
MatchExpressions: []v1.NodeSelectorRequirement{
{
Key: "k1",
Operator: v1.NodeSelectorOpIn,
Values: []string{"v2", "v1"},
},
{
Key: "k2",
Operator: v1.NodeSelectorOpIn,
Values: []string{"v1"},
},
{
Key: "k1",
Operator: v1.NodeSelectorOpIn,
Values: []string{"v2", "v1"},
},
},
},
{
MatchExpressions: []v1.NodeSelectorRequirement{
{
Key: "k2",
Operator: v1.NodeSelectorOpIn,
Values: []string{"v1"},
},
{
Key: "k1",
Operator: v1.NodeSelectorOpIn,
Values: []string{"v2", "v1"},
},
},
},
},
expectedTerms: []v1.NodeSelectorTerm{
{
MatchExpressions: []v1.NodeSelectorRequirement{
{
Key: "k1",
Operator: v1.NodeSelectorOpIn,
Values: []string{"v1", "v2"},
},
{
Key: "k2",
Operator: v1.NodeSelectorOpIn,
Values: []string{"v1"},
},
},
},
},
},
}
for _, test := range tests {
t.Run(test.name, func(t *testing.T) {
resultTerms := uniqueSortNodeSelectorTerms(test.terms)
if !reflect.DeepEqual(resultTerms, test.expectedTerms) {
t.Errorf("Terms not sorted as expected, \n\tgot: %#v, \n\texpected: %#v", resultTerms, test.expectedTerms)
}
})
}
}
func TestNodeSelectorTermsEqual(t *testing.T) {
tests := []struct {
name string
leftSelector, rightSelector v1.NodeSelector
equal bool
}{
{
name: "identical selectors",
leftSelector: v1.NodeSelector{
NodeSelectorTerms: []v1.NodeSelectorTerm{
{
MatchExpressions: []v1.NodeSelectorRequirement{
{
Key: "k1",
Operator: v1.NodeSelectorOpIn,
Values: []string{"v1", "v2"},
},
{
Key: "k2",
Operator: v1.NodeSelectorOpIn,
Values: []string{"v1"},
},
},
},
},
},
rightSelector: v1.NodeSelector{
NodeSelectorTerms: []v1.NodeSelectorTerm{
{
MatchExpressions: []v1.NodeSelectorRequirement{
{
Key: "k1",
Operator: v1.NodeSelectorOpIn,
Values: []string{"v1", "v2"},
},
{
Key: "k2",
Operator: v1.NodeSelectorOpIn,
Values: []string{"v1"},
},
},
},
},
},
equal: true,
},
{
name: "equal selectors",
leftSelector: v1.NodeSelector{
NodeSelectorTerms: []v1.NodeSelectorTerm{
{
MatchExpressions: []v1.NodeSelectorRequirement{
{
Key: "k2",
Operator: v1.NodeSelectorOpIn,
Values: []string{"v1", "v1"},
},
{
Key: "k1",
Operator: v1.NodeSelectorOpIn,
Values: []string{"v1", "v2"},
},
},
},
},
},
rightSelector: v1.NodeSelector{
NodeSelectorTerms: []v1.NodeSelectorTerm{
{
MatchExpressions: []v1.NodeSelectorRequirement{
{
Key: "k1",
Operator: v1.NodeSelectorOpIn,
Values: []string{"v1", "v2"},
},
{
Key: "k2",
Operator: v1.NodeSelectorOpIn,
Values: []string{"v1"},
},
},
},
},
},
equal: true,
},
{
name: "non-equal selectors in values",
leftSelector: v1.NodeSelector{
NodeSelectorTerms: []v1.NodeSelectorTerm{
{
MatchExpressions: []v1.NodeSelectorRequirement{
{
Key: "k1",
Operator: v1.NodeSelectorOpIn,
Values: []string{"v1", "v2"},
},
{
Key: "k2",
Operator: v1.NodeSelectorOpIn,
Values: []string{"v1"},
},
},
},
},
},
rightSelector: v1.NodeSelector{
NodeSelectorTerms: []v1.NodeSelectorTerm{
{
MatchExpressions: []v1.NodeSelectorRequirement{
{
Key: "k1",
Operator: v1.NodeSelectorOpIn,
Values: []string{"v1", "v2"},
},
{
Key: "k2",
Operator: v1.NodeSelectorOpIn,
Values: []string{"v1", "v2"},
},
},
},
},
},
equal: false,
},
{
name: "non-equal selectors in keys",
leftSelector: v1.NodeSelector{
NodeSelectorTerms: []v1.NodeSelectorTerm{
{
MatchExpressions: []v1.NodeSelectorRequirement{
{
Key: "k3",
Operator: v1.NodeSelectorOpIn,
Values: []string{"v1"},
},
{
Key: "k1",
Operator: v1.NodeSelectorOpIn,
Values: []string{"v1", "v2"},
},
{
Key: "k2",
Operator: v1.NodeSelectorOpIn,
Values: []string{"v1"},
},
},
},
},
},
rightSelector: v1.NodeSelector{
NodeSelectorTerms: []v1.NodeSelectorTerm{
{
MatchExpressions: []v1.NodeSelectorRequirement{
{
Key: "k1",
Operator: v1.NodeSelectorOpIn,
Values: []string{"v1", "v2"},
},
{
Key: "k2",
Operator: v1.NodeSelectorOpIn,
Values: []string{"v1", "v2"},
},
},
},
},
},
equal: false,
},
}
for _, test := range tests {
t.Run(test.name, func(t *testing.T) {
equal := NodeSelectorsEqual(&test.leftSelector, &test.rightSelector)
if equal != test.equal {
t.Errorf("NodeSelectorsEqual expected to be %v, got %v", test.equal, equal)
}
})
}
}
func createNodeSelectorTerm(key, value string) v1.NodeSelectorTerm {
return v1.NodeSelectorTerm{
MatchExpressions: []v1.NodeSelectorRequirement{
{
Key: key,
Operator: "In",
Values: []string{value},
},
},
}
}
func TestPodNodeAffinityWeight(t *testing.T) {
defaultNode := v1.Node{
ObjectMeta: metav1.ObjectMeta{
Labels: map[string]string{
"key1": "value1",
"key2": "value2",
"key3": "value3",
},
},
}
tests := []struct {
name string
affinity *v1.Affinity
expectedWeight int32
}{
{
name: "No affinity",
affinity: nil,
expectedWeight: 0,
},
{
name: "No node affinity",
affinity: &v1.Affinity{},
expectedWeight: 0,
},
{
name: "Empty preferred node affinity, but matching required node affinity",
affinity: &v1.Affinity{
NodeAffinity: &v1.NodeAffinity{
RequiredDuringSchedulingIgnoredDuringExecution: &v1.NodeSelector{
NodeSelectorTerms: []v1.NodeSelectorTerm{
createNodeSelectorTerm("key1", "value1"),
},
},
},
},
expectedWeight: 0,
},
{
name: "Matching single key in preferred node affinity",
affinity: &v1.Affinity{
NodeAffinity: &v1.NodeAffinity{
PreferredDuringSchedulingIgnoredDuringExecution: []v1.PreferredSchedulingTerm{
{
Weight: 10,
Preference: createNodeSelectorTerm("key1", "value1"),
},
{
Weight: 5,
Preference: createNodeSelectorTerm("key1", "valueX"),
},
},
},
},
expectedWeight: 10,
},
{
name: "Matching two keys in preferred node affinity",
affinity: &v1.Affinity{
NodeAffinity: &v1.NodeAffinity{
PreferredDuringSchedulingIgnoredDuringExecution: []v1.PreferredSchedulingTerm{
{
Weight: 10,
Preference: createNodeSelectorTerm("key1", "value1"),
},
{
Weight: 5,
Preference: createNodeSelectorTerm("key2", "value2"),
},
},
},
},
expectedWeight: 15,
},
}
for _, test := range tests {
t.Run(test.name, func(t *testing.T) {
pod := v1.Pod{}
pod.Spec.Affinity = test.affinity
totalWeight, err := GetNodeWeightGivenPodPreferredAffinity(&pod, &defaultNode)
if err != nil {
t.Error("Found non nil error")
}
if totalWeight != test.expectedWeight {
t.Errorf("Expected total weight is %v but actual total weight is %v", test.expectedWeight, totalWeight)
}
})
}
}
View Git Blame Copy Permalink