759 lines
17 KiB
Go
759 lines
17 KiB
Go
/*
|
|
Copyright 2019 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 topologymanager
|
|
|
|
import (
|
|
"fmt"
|
|
"reflect"
|
|
"strings"
|
|
"testing"
|
|
|
|
"k8s.io/api/core/v1"
|
|
"k8s.io/apimachinery/pkg/types"
|
|
"k8s.io/kubernetes/pkg/kubelet/cm/topologymanager/bitmask"
|
|
"k8s.io/kubernetes/pkg/kubelet/lifecycle"
|
|
)
|
|
|
|
func NewTestBitMask(sockets ...int) bitmask.BitMask {
|
|
s, _ := bitmask.NewBitMask(sockets...)
|
|
return s
|
|
}
|
|
|
|
func TestNewManager(t *testing.T) {
|
|
tcases := []struct {
|
|
description string
|
|
policyName string
|
|
expectedPolicy string
|
|
expectedError error
|
|
}{
|
|
{
|
|
description: "Policy is set to best-effort",
|
|
policyName: "best-effort",
|
|
expectedPolicy: "best-effort",
|
|
},
|
|
{
|
|
description: "Policy is set to restricted",
|
|
policyName: "restricted",
|
|
expectedPolicy: "restricted",
|
|
},
|
|
{
|
|
description: "Policy is set to unknown",
|
|
policyName: "unknown",
|
|
expectedError: fmt.Errorf("unknown policy: \"unknown\""),
|
|
},
|
|
}
|
|
|
|
for _, tc := range tcases {
|
|
mngr, err := NewManager(nil, tc.policyName)
|
|
|
|
if tc.expectedError != nil {
|
|
if !strings.Contains(err.Error(), tc.expectedError.Error()) {
|
|
t.Errorf("Unexpected error message. Have: %s wants %s", err.Error(), tc.expectedError.Error())
|
|
}
|
|
} else {
|
|
rawMgr := mngr.(*manager)
|
|
if rawMgr.policy.Name() != tc.expectedPolicy {
|
|
t.Errorf("Unexpected policy name. Have: %q wants %q", rawMgr.policy.Name(), tc.expectedPolicy)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
type mockHintProvider struct {
|
|
th map[string][]TopologyHint
|
|
//TODO: Add this field and add some tests to make sure things error out
|
|
//appropriately on allocation errors.
|
|
//allocateError error
|
|
}
|
|
|
|
func (m *mockHintProvider) GetTopologyHints(pod *v1.Pod, container *v1.Container) map[string][]TopologyHint {
|
|
return m.th
|
|
}
|
|
|
|
func (m *mockHintProvider) GetPodTopologyHints(pod *v1.Pod) map[string][]TopologyHint {
|
|
return m.th
|
|
}
|
|
|
|
func (m *mockHintProvider) Allocate(pod *v1.Pod, container *v1.Container) error {
|
|
//return allocateError
|
|
return nil
|
|
}
|
|
|
|
func TestGetAffinity(t *testing.T) {
|
|
tcases := []struct {
|
|
name string
|
|
containerName string
|
|
podUID string
|
|
expected TopologyHint
|
|
}{
|
|
{
|
|
name: "case1",
|
|
containerName: "nginx",
|
|
podUID: "0aafa4c4-38e8-11e9-bcb1-a4bf01040474",
|
|
expected: TopologyHint{},
|
|
},
|
|
}
|
|
for _, tc := range tcases {
|
|
mngr := manager{}
|
|
actual := mngr.GetAffinity(tc.podUID, tc.containerName)
|
|
if !reflect.DeepEqual(actual, tc.expected) {
|
|
t.Errorf("Expected Affinity in result to be %v, got %v", tc.expected, actual)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestAccumulateProvidersHints(t *testing.T) {
|
|
tcases := []struct {
|
|
name string
|
|
hp []HintProvider
|
|
expected []map[string][]TopologyHint
|
|
}{
|
|
{
|
|
name: "TopologyHint not set",
|
|
hp: []HintProvider{},
|
|
expected: nil,
|
|
},
|
|
{
|
|
name: "HintProvider returns empty non-nil map[string][]TopologyHint",
|
|
hp: []HintProvider{
|
|
&mockHintProvider{
|
|
map[string][]TopologyHint{},
|
|
},
|
|
},
|
|
expected: []map[string][]TopologyHint{
|
|
{},
|
|
},
|
|
},
|
|
{
|
|
name: "HintProvider returns - nil map[string][]TopologyHint from provider",
|
|
hp: []HintProvider{
|
|
&mockHintProvider{
|
|
map[string][]TopologyHint{
|
|
"resource": nil,
|
|
},
|
|
},
|
|
},
|
|
expected: []map[string][]TopologyHint{
|
|
{
|
|
"resource": nil,
|
|
},
|
|
},
|
|
},
|
|
{
|
|
name: "2 HintProviders with 1 resource returns hints",
|
|
hp: []HintProvider{
|
|
&mockHintProvider{
|
|
map[string][]TopologyHint{
|
|
"resource1": {TopologyHint{}},
|
|
},
|
|
},
|
|
&mockHintProvider{
|
|
map[string][]TopologyHint{
|
|
"resource2": {TopologyHint{}},
|
|
},
|
|
},
|
|
},
|
|
expected: []map[string][]TopologyHint{
|
|
{
|
|
"resource1": {TopologyHint{}},
|
|
},
|
|
{
|
|
"resource2": {TopologyHint{}},
|
|
},
|
|
},
|
|
},
|
|
{
|
|
name: "2 HintProviders 1 with 1 resource 1 with nil hints",
|
|
hp: []HintProvider{
|
|
&mockHintProvider{
|
|
map[string][]TopologyHint{
|
|
"resource1": {TopologyHint{}},
|
|
},
|
|
},
|
|
&mockHintProvider{nil},
|
|
},
|
|
expected: []map[string][]TopologyHint{
|
|
{
|
|
"resource1": {TopologyHint{}},
|
|
},
|
|
nil,
|
|
},
|
|
},
|
|
{
|
|
name: "2 HintProviders 1 with 1 resource 1 empty hints",
|
|
hp: []HintProvider{
|
|
&mockHintProvider{
|
|
map[string][]TopologyHint{
|
|
"resource1": {TopologyHint{}},
|
|
},
|
|
},
|
|
&mockHintProvider{
|
|
map[string][]TopologyHint{},
|
|
},
|
|
},
|
|
expected: []map[string][]TopologyHint{
|
|
{
|
|
"resource1": {TopologyHint{}},
|
|
},
|
|
{},
|
|
},
|
|
},
|
|
{
|
|
name: "HintProvider with 2 resources returns hints",
|
|
hp: []HintProvider{
|
|
&mockHintProvider{
|
|
map[string][]TopologyHint{
|
|
"resource1": {TopologyHint{}},
|
|
"resource2": {TopologyHint{}},
|
|
},
|
|
},
|
|
},
|
|
expected: []map[string][]TopologyHint{
|
|
{
|
|
"resource1": {TopologyHint{}},
|
|
"resource2": {TopologyHint{}},
|
|
},
|
|
},
|
|
},
|
|
}
|
|
|
|
for _, tc := range tcases {
|
|
mngr := manager{
|
|
hintProviders: tc.hp,
|
|
}
|
|
actual := mngr.accumulateProvidersHints(&v1.Pod{}, &v1.Container{})
|
|
if !reflect.DeepEqual(actual, tc.expected) {
|
|
t.Errorf("Test Case %s: Expected NUMANodeAffinity in result to be %v, got %v", tc.name, tc.expected, actual)
|
|
}
|
|
}
|
|
}
|
|
|
|
type mockPolicy struct {
|
|
nonePolicy
|
|
ph []map[string][]TopologyHint
|
|
}
|
|
|
|
func (p *mockPolicy) Merge(providersHints []map[string][]TopologyHint) (TopologyHint, bool) {
|
|
p.ph = providersHints
|
|
return TopologyHint{}, true
|
|
}
|
|
|
|
func TestCalculateAffinity(t *testing.T) {
|
|
tcases := []struct {
|
|
name string
|
|
hp []HintProvider
|
|
expected []map[string][]TopologyHint
|
|
}{
|
|
{
|
|
name: "No hint providers",
|
|
hp: []HintProvider{},
|
|
expected: ([]map[string][]TopologyHint)(nil),
|
|
},
|
|
{
|
|
name: "HintProvider returns empty non-nil map[string][]TopologyHint",
|
|
hp: []HintProvider{
|
|
&mockHintProvider{
|
|
map[string][]TopologyHint{},
|
|
},
|
|
},
|
|
expected: []map[string][]TopologyHint{
|
|
{},
|
|
},
|
|
},
|
|
{
|
|
name: "HintProvider returns -nil map[string][]TopologyHint from provider",
|
|
hp: []HintProvider{
|
|
&mockHintProvider{
|
|
map[string][]TopologyHint{
|
|
"resource": nil,
|
|
},
|
|
},
|
|
},
|
|
expected: []map[string][]TopologyHint{
|
|
{
|
|
"resource": nil,
|
|
},
|
|
},
|
|
},
|
|
{
|
|
name: "Assorted HintProviders",
|
|
hp: []HintProvider{
|
|
&mockHintProvider{
|
|
map[string][]TopologyHint{
|
|
"resource-1/A": {
|
|
{NUMANodeAffinity: NewTestBitMask(0), Preferred: true},
|
|
{NUMANodeAffinity: NewTestBitMask(0, 1), Preferred: false},
|
|
},
|
|
"resource-1/B": {
|
|
{NUMANodeAffinity: NewTestBitMask(1), Preferred: true},
|
|
{NUMANodeAffinity: NewTestBitMask(1, 2), Preferred: false},
|
|
},
|
|
},
|
|
},
|
|
&mockHintProvider{
|
|
map[string][]TopologyHint{
|
|
"resource-2/A": {
|
|
{NUMANodeAffinity: NewTestBitMask(2), Preferred: true},
|
|
{NUMANodeAffinity: NewTestBitMask(3, 4), Preferred: false},
|
|
},
|
|
"resource-2/B": {
|
|
{NUMANodeAffinity: NewTestBitMask(2), Preferred: true},
|
|
{NUMANodeAffinity: NewTestBitMask(3, 4), Preferred: false},
|
|
},
|
|
},
|
|
},
|
|
&mockHintProvider{
|
|
map[string][]TopologyHint{
|
|
"resource-3": nil,
|
|
},
|
|
},
|
|
},
|
|
expected: []map[string][]TopologyHint{
|
|
{
|
|
"resource-1/A": {
|
|
{NUMANodeAffinity: NewTestBitMask(0), Preferred: true},
|
|
{NUMANodeAffinity: NewTestBitMask(0, 1), Preferred: false},
|
|
},
|
|
"resource-1/B": {
|
|
{NUMANodeAffinity: NewTestBitMask(1), Preferred: true},
|
|
{NUMANodeAffinity: NewTestBitMask(1, 2), Preferred: false},
|
|
},
|
|
},
|
|
{
|
|
"resource-2/A": {
|
|
{NUMANodeAffinity: NewTestBitMask(2), Preferred: true},
|
|
{NUMANodeAffinity: NewTestBitMask(3, 4), Preferred: false},
|
|
},
|
|
"resource-2/B": {
|
|
{NUMANodeAffinity: NewTestBitMask(2), Preferred: true},
|
|
{NUMANodeAffinity: NewTestBitMask(3, 4), Preferred: false},
|
|
},
|
|
},
|
|
{
|
|
"resource-3": nil,
|
|
},
|
|
},
|
|
},
|
|
}
|
|
|
|
for _, tc := range tcases {
|
|
mngr := manager{}
|
|
mngr.policy = &mockPolicy{}
|
|
mngr.hintProviders = tc.hp
|
|
mngr.calculateAffinity(&v1.Pod{}, &v1.Container{})
|
|
actual := mngr.policy.(*mockPolicy).ph
|
|
if !reflect.DeepEqual(tc.expected, actual) {
|
|
t.Errorf("Test Case: %s", tc.name)
|
|
t.Errorf("Expected result to be %v, got %v", tc.expected, actual)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestAddContainer(t *testing.T) {
|
|
testCases := []struct {
|
|
name string
|
|
containerID string
|
|
podUID types.UID
|
|
}{
|
|
{
|
|
name: "Case1",
|
|
containerID: "nginx",
|
|
podUID: "0aafa4c4-38e8-11e9-bcb1-a4bf01040474",
|
|
},
|
|
{
|
|
name: "Case2",
|
|
containerID: "Busy_Box",
|
|
podUID: "b3ee37fc-39a5-11e9-bcb1-a4bf01040474",
|
|
},
|
|
}
|
|
mngr := manager{}
|
|
mngr.podMap = make(map[string]string)
|
|
for _, tc := range testCases {
|
|
pod := v1.Pod{}
|
|
pod.UID = tc.podUID
|
|
err := mngr.AddContainer(&pod, tc.containerID)
|
|
if err != nil {
|
|
t.Errorf("Expected error to be nil but got: %v", err)
|
|
}
|
|
if val, ok := mngr.podMap[tc.containerID]; ok {
|
|
if reflect.DeepEqual(val, pod.UID) {
|
|
t.Errorf("Error occurred")
|
|
}
|
|
} else {
|
|
t.Errorf("Error occurred, Pod not added to podMap")
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestRemoveContainer(t *testing.T) {
|
|
testCases := []struct {
|
|
name string
|
|
containerID string
|
|
podUID types.UID
|
|
}{
|
|
{
|
|
name: "Case1",
|
|
containerID: "nginx",
|
|
podUID: "0aafa4c4-38e8-11e9-bcb1-a4bf01040474",
|
|
},
|
|
{
|
|
name: "Case2",
|
|
containerID: "Busy_Box",
|
|
podUID: "b3ee37fc-39a5-11e9-bcb1-a4bf01040474",
|
|
},
|
|
}
|
|
var len1, len2 int
|
|
mngr := manager{}
|
|
mngr.podMap = make(map[string]string)
|
|
for _, tc := range testCases {
|
|
mngr.podMap[tc.containerID] = string(tc.podUID)
|
|
len1 = len(mngr.podMap)
|
|
err := mngr.RemoveContainer(tc.containerID)
|
|
len2 = len(mngr.podMap)
|
|
if err != nil {
|
|
t.Errorf("Expected error to be nil but got: %v", err)
|
|
}
|
|
if len1-len2 != 1 {
|
|
t.Errorf("Remove Pod resulted in error")
|
|
}
|
|
}
|
|
|
|
}
|
|
func TestAddHintProvider(t *testing.T) {
|
|
var len1 int
|
|
tcases := []struct {
|
|
name string
|
|
hp []HintProvider
|
|
}{
|
|
{
|
|
name: "Add HintProvider",
|
|
hp: []HintProvider{
|
|
&mockHintProvider{},
|
|
},
|
|
},
|
|
}
|
|
mngr := manager{}
|
|
for _, tc := range tcases {
|
|
mngr.hintProviders = []HintProvider{}
|
|
len1 = len(mngr.hintProviders)
|
|
mngr.AddHintProvider(tc.hp[0])
|
|
}
|
|
len2 := len(mngr.hintProviders)
|
|
if len2-len1 != 1 {
|
|
t.Errorf("error")
|
|
}
|
|
}
|
|
|
|
func TestAdmit(t *testing.T) {
|
|
numaNodes := []int{0, 1}
|
|
|
|
tcases := []struct {
|
|
name string
|
|
result lifecycle.PodAdmitResult
|
|
qosClass v1.PodQOSClass
|
|
policy Policy
|
|
hp []HintProvider
|
|
expected bool
|
|
}{
|
|
{
|
|
name: "QOSClass set as BestEffort. None Policy. No Hints.",
|
|
qosClass: v1.PodQOSBestEffort,
|
|
policy: NewNonePolicy(),
|
|
hp: []HintProvider{},
|
|
expected: true,
|
|
},
|
|
{
|
|
name: "QOSClass set as Guaranteed. None Policy. No Hints.",
|
|
qosClass: v1.PodQOSGuaranteed,
|
|
policy: NewNonePolicy(),
|
|
hp: []HintProvider{},
|
|
expected: true,
|
|
},
|
|
{
|
|
name: "QOSClass set as BestEffort. single-numa-node Policy. No Hints.",
|
|
qosClass: v1.PodQOSBestEffort,
|
|
policy: NewRestrictedPolicy(numaNodes),
|
|
hp: []HintProvider{
|
|
&mockHintProvider{},
|
|
},
|
|
expected: true,
|
|
},
|
|
{
|
|
name: "QOSClass set as BestEffort. Restricted Policy. No Hints.",
|
|
qosClass: v1.PodQOSBestEffort,
|
|
policy: NewRestrictedPolicy(numaNodes),
|
|
hp: []HintProvider{
|
|
&mockHintProvider{},
|
|
},
|
|
expected: true,
|
|
},
|
|
{
|
|
name: "QOSClass set as Guaranteed. BestEffort Policy. Preferred Affinity.",
|
|
qosClass: v1.PodQOSGuaranteed,
|
|
policy: NewBestEffortPolicy(numaNodes),
|
|
hp: []HintProvider{
|
|
&mockHintProvider{
|
|
map[string][]TopologyHint{
|
|
"resource": {
|
|
{
|
|
NUMANodeAffinity: NewTestBitMask(0),
|
|
Preferred: true,
|
|
},
|
|
{
|
|
NUMANodeAffinity: NewTestBitMask(0, 1),
|
|
Preferred: false,
|
|
},
|
|
},
|
|
},
|
|
},
|
|
},
|
|
expected: true,
|
|
},
|
|
{
|
|
name: "QOSClass set as Guaranteed. BestEffort Policy. More than one Preferred Affinity.",
|
|
qosClass: v1.PodQOSGuaranteed,
|
|
policy: NewBestEffortPolicy(numaNodes),
|
|
hp: []HintProvider{
|
|
&mockHintProvider{
|
|
map[string][]TopologyHint{
|
|
"resource": {
|
|
{
|
|
NUMANodeAffinity: NewTestBitMask(0),
|
|
Preferred: true,
|
|
},
|
|
{
|
|
NUMANodeAffinity: NewTestBitMask(1),
|
|
Preferred: true,
|
|
},
|
|
{
|
|
NUMANodeAffinity: NewTestBitMask(0, 1),
|
|
Preferred: false,
|
|
},
|
|
},
|
|
},
|
|
},
|
|
},
|
|
expected: true,
|
|
},
|
|
{
|
|
name: "QOSClass set as Burstable. BestEffort Policy. More than one Preferred Affinity.",
|
|
qosClass: v1.PodQOSBurstable,
|
|
policy: NewBestEffortPolicy(numaNodes),
|
|
hp: []HintProvider{
|
|
&mockHintProvider{
|
|
map[string][]TopologyHint{
|
|
"resource": {
|
|
{
|
|
NUMANodeAffinity: NewTestBitMask(0),
|
|
Preferred: true,
|
|
},
|
|
{
|
|
NUMANodeAffinity: NewTestBitMask(1),
|
|
Preferred: true,
|
|
},
|
|
{
|
|
NUMANodeAffinity: NewTestBitMask(0, 1),
|
|
Preferred: false,
|
|
},
|
|
},
|
|
},
|
|
},
|
|
},
|
|
expected: true,
|
|
},
|
|
{
|
|
name: "QOSClass set as Guaranteed. BestEffort Policy. No Preferred Affinity.",
|
|
qosClass: v1.PodQOSGuaranteed,
|
|
policy: NewBestEffortPolicy(numaNodes),
|
|
hp: []HintProvider{
|
|
&mockHintProvider{
|
|
map[string][]TopologyHint{
|
|
"resource": {
|
|
{
|
|
NUMANodeAffinity: NewTestBitMask(0, 1),
|
|
Preferred: false,
|
|
},
|
|
},
|
|
},
|
|
},
|
|
},
|
|
expected: true,
|
|
},
|
|
{
|
|
name: "QOSClass set as Guaranteed. Restricted Policy. Preferred Affinity.",
|
|
qosClass: v1.PodQOSGuaranteed,
|
|
policy: NewRestrictedPolicy(numaNodes),
|
|
hp: []HintProvider{
|
|
&mockHintProvider{
|
|
map[string][]TopologyHint{
|
|
"resource": {
|
|
{
|
|
NUMANodeAffinity: NewTestBitMask(0),
|
|
Preferred: true,
|
|
},
|
|
{
|
|
NUMANodeAffinity: NewTestBitMask(0, 1),
|
|
Preferred: false,
|
|
},
|
|
},
|
|
},
|
|
},
|
|
},
|
|
expected: true,
|
|
},
|
|
{
|
|
name: "QOSClass set as Burstable. Restricted Policy. Preferred Affinity.",
|
|
qosClass: v1.PodQOSBurstable,
|
|
policy: NewRestrictedPolicy(numaNodes),
|
|
hp: []HintProvider{
|
|
&mockHintProvider{
|
|
map[string][]TopologyHint{
|
|
"resource": {
|
|
{
|
|
NUMANodeAffinity: NewTestBitMask(0),
|
|
Preferred: true,
|
|
},
|
|
{
|
|
NUMANodeAffinity: NewTestBitMask(0, 1),
|
|
Preferred: false,
|
|
},
|
|
},
|
|
},
|
|
},
|
|
},
|
|
expected: true,
|
|
},
|
|
{
|
|
name: "QOSClass set as Guaranteed. Restricted Policy. More than one Preferred affinity.",
|
|
qosClass: v1.PodQOSGuaranteed,
|
|
policy: NewRestrictedPolicy(numaNodes),
|
|
hp: []HintProvider{
|
|
&mockHintProvider{
|
|
map[string][]TopologyHint{
|
|
"resource": {
|
|
{
|
|
NUMANodeAffinity: NewTestBitMask(0),
|
|
Preferred: true,
|
|
},
|
|
{
|
|
NUMANodeAffinity: NewTestBitMask(1),
|
|
Preferred: true,
|
|
},
|
|
{
|
|
NUMANodeAffinity: NewTestBitMask(0, 1),
|
|
Preferred: false,
|
|
},
|
|
},
|
|
},
|
|
},
|
|
},
|
|
expected: true,
|
|
},
|
|
{
|
|
name: "QOSClass set as Burstable. Restricted Policy. More than one Preferred affinity.",
|
|
qosClass: v1.PodQOSBurstable,
|
|
policy: NewRestrictedPolicy(numaNodes),
|
|
hp: []HintProvider{
|
|
&mockHintProvider{
|
|
map[string][]TopologyHint{
|
|
"resource": {
|
|
{
|
|
NUMANodeAffinity: NewTestBitMask(0),
|
|
Preferred: true,
|
|
},
|
|
{
|
|
NUMANodeAffinity: NewTestBitMask(1),
|
|
Preferred: true,
|
|
},
|
|
{
|
|
NUMANodeAffinity: NewTestBitMask(0, 1),
|
|
Preferred: false,
|
|
},
|
|
},
|
|
},
|
|
},
|
|
},
|
|
expected: true,
|
|
},
|
|
{
|
|
name: "QOSClass set as Guaranteed. Restricted Policy. No Preferred affinity.",
|
|
qosClass: v1.PodQOSGuaranteed,
|
|
policy: NewRestrictedPolicy(numaNodes),
|
|
hp: []HintProvider{
|
|
&mockHintProvider{
|
|
map[string][]TopologyHint{
|
|
"resource": {
|
|
{
|
|
NUMANodeAffinity: NewTestBitMask(0, 1),
|
|
Preferred: false,
|
|
},
|
|
},
|
|
},
|
|
},
|
|
},
|
|
expected: false,
|
|
},
|
|
{
|
|
name: "QOSClass set as Burstable. Restricted Policy. No Preferred affinity.",
|
|
qosClass: v1.PodQOSBurstable,
|
|
policy: NewRestrictedPolicy(numaNodes),
|
|
hp: []HintProvider{
|
|
&mockHintProvider{
|
|
map[string][]TopologyHint{
|
|
"resource": {
|
|
{
|
|
NUMANodeAffinity: NewTestBitMask(0, 1),
|
|
Preferred: false,
|
|
},
|
|
},
|
|
},
|
|
},
|
|
},
|
|
expected: false,
|
|
},
|
|
}
|
|
for _, tc := range tcases {
|
|
man := manager{
|
|
policy: tc.policy,
|
|
podTopologyHints: make(map[string]map[string]TopologyHint),
|
|
hintProviders: tc.hp,
|
|
}
|
|
|
|
pod := &v1.Pod{
|
|
Spec: v1.PodSpec{
|
|
Containers: []v1.Container{
|
|
{
|
|
Resources: v1.ResourceRequirements{},
|
|
},
|
|
},
|
|
},
|
|
Status: v1.PodStatus{
|
|
QOSClass: tc.qosClass,
|
|
},
|
|
}
|
|
|
|
podAttr := lifecycle.PodAdmitAttributes{
|
|
Pod: pod,
|
|
}
|
|
|
|
actual := man.Admit(&podAttr)
|
|
if actual.Admit != tc.expected {
|
|
t.Errorf("Error occurred, expected Admit in result to be %v got %v", tc.expected, actual.Admit)
|
|
}
|
|
}
|
|
}
|