github/kubernetes
1
0
Fork 0
mirror of https://github.com/k3s-io/kubernetes.git synced 2025-08-07 03:03:59 +00:00
Code Issues Projects Releases Wiki Activity

Merge pull request #120252 from kerthcet/cleanup/framework-import

Browse Source 
Move framework testing libraries to the right place
This commit is contained in:
Kubernetes Prow Robot 2023-09-12 17:44:11 -07:00 committed by GitHub
commit db49b13ccd
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
13 changed files with 477 additions and 473 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
pkg/controller/volume/attachdetach/util/util_test.go
View File

@ -31,7 +31,7 @@ import (
"k8s.io/client-go/informers" "k8s.io/client-go/informers"
csitrans "k8s.io/csi-translation-lib" csitrans "k8s.io/csi-translation-lib"
"k8s.io/klog/v2/ktesting" "k8s.io/klog/v2/ktesting"
fakeframework "k8s.io/kubernetes/pkg/scheduler/framework/fake" tf "k8s.io/kubernetes/pkg/scheduler/testing/framework"
"k8s.io/kubernetes/pkg/volume/csimigration" "k8s.io/kubernetes/pkg/volume/csimigration"
"k8s.io/kubernetes/pkg/volume/fc" "k8s.io/kubernetes/pkg/volume/fc"
@ -282,7 +282,7 @@ func Test_CreateVolumeSpec(t *testing.T) {
} }
} }
func setup(nodeName string, t *testing.T) (*volume.VolumePluginMgr, csimigration.PluginManager, csitrans.CSITranslator, fakeframework.PersistentVolumeLister, fakeframework.PersistentVolumeClaimLister) { func setup(nodeName string, t *testing.T) (*volume.VolumePluginMgr, csimigration.PluginManager, csitrans.CSITranslator, tf.PersistentVolumeLister, tf.PersistentVolumeClaimLister) {
tmpDir, err := utiltesting.MkTmpdir("csi-test") tmpDir, err := utiltesting.MkTmpdir("csi-test")
if err != nil { if err != nil {
t.Fatalf("can't make a temp dir: %v", err) t.Fatalf("can't make a temp dir: %v", err)
@ -313,7 +313,7 @@ func setup(nodeName string, t *testing.T) (*volume.VolumePluginMgr, csimigration
plugMgr.Host = fakeAttachDetachVolumeHost plugMgr.Host = fakeAttachDetachVolumeHost
pvLister := fakeframework.PersistentVolumeLister{ pvLister := tf.PersistentVolumeLister{
{ {
ObjectMeta: metav1.ObjectMeta{Name: migratedVolume}, ObjectMeta: metav1.ObjectMeta{Name: migratedVolume},
Spec: v1.PersistentVolumeSpec{ Spec: v1.PersistentVolumeSpec{
@ -339,7 +339,7 @@ func setup(nodeName string, t *testing.T) (*volume.VolumePluginMgr, csimigration
}, },
} }
pvcLister := fakeframework.PersistentVolumeClaimLister{ pvcLister := tf.PersistentVolumeClaimLister{
{ {
ObjectMeta: metav1.ObjectMeta{Name: "migrated-pvc", Namespace: "default"}, ObjectMeta: metav1.ObjectMeta{Name: "migrated-pvc", Namespace: "default"},
Spec: v1.PersistentVolumeClaimSpec{VolumeName: migratedVolume}, Spec: v1.PersistentVolumeClaimSpec{VolumeName: migratedVolume},

144
pkg/scheduler/extender_test.go
View File

@ -31,38 +31,38 @@ import (
extenderv1 "k8s.io/kube-scheduler/extender/v1" extenderv1 "k8s.io/kube-scheduler/extender/v1"
schedulerapi "k8s.io/kubernetes/pkg/scheduler/apis/config" schedulerapi "k8s.io/kubernetes/pkg/scheduler/apis/config"
"k8s.io/kubernetes/pkg/scheduler/framework" "k8s.io/kubernetes/pkg/scheduler/framework"
"k8s.io/kubernetes/pkg/scheduler/framework/fake"
"k8s.io/kubernetes/pkg/scheduler/framework/plugins/defaultbinder" "k8s.io/kubernetes/pkg/scheduler/framework/plugins/defaultbinder"
"k8s.io/kubernetes/pkg/scheduler/framework/plugins/queuesort" "k8s.io/kubernetes/pkg/scheduler/framework/plugins/queuesort"
"k8s.io/kubernetes/pkg/scheduler/framework/runtime" "k8s.io/kubernetes/pkg/scheduler/framework/runtime"
internalcache "k8s.io/kubernetes/pkg/scheduler/internal/cache" internalcache "k8s.io/kubernetes/pkg/scheduler/internal/cache"
internalqueue "k8s.io/kubernetes/pkg/scheduler/internal/queue" internalqueue "k8s.io/kubernetes/pkg/scheduler/internal/queue"
st "k8s.io/kubernetes/pkg/scheduler/testing" st "k8s.io/kubernetes/pkg/scheduler/testing"
tf "k8s.io/kubernetes/pkg/scheduler/testing/framework"
) )
func TestSchedulerWithExtenders(t *testing.T) { func TestSchedulerWithExtenders(t *testing.T) {
tests := []struct { tests := []struct {
name string name string
registerPlugins []st.RegisterPluginFunc registerPlugins []tf.RegisterPluginFunc
extenders []st.FakeExtender extenders []tf.FakeExtender
nodes []string nodes []string
expectedResult ScheduleResult expectedResult ScheduleResult
expectsErr bool expectsErr bool
}{ }{
{ {
registerPlugins: []st.RegisterPluginFunc{ registerPlugins: []tf.RegisterPluginFunc{
st.RegisterFilterPlugin("TrueFilter", st.NewTrueFilterPlugin), tf.RegisterFilterPlugin("TrueFilter", tf.NewTrueFilterPlugin),
st.RegisterQueueSortPlugin(queuesort.Name, queuesort.New), tf.RegisterQueueSortPlugin(queuesort.Name, queuesort.New),
st.RegisterBindPlugin(defaultbinder.Name, defaultbinder.New), tf.RegisterBindPlugin(defaultbinder.Name, defaultbinder.New),
}, },
extenders: []st.FakeExtender{ extenders: []tf.FakeExtender{
{ {
ExtenderName: "FakeExtender1", ExtenderName: "FakeExtender1",
Predicates: []st.FitPredicate{st.TruePredicateExtender}, Predicates: []tf.FitPredicate{tf.TruePredicateExtender},
}, },
{ {
ExtenderName: "FakeExtender2", ExtenderName: "FakeExtender2",
Predicates: []st.FitPredicate{st.ErrorPredicateExtender}, Predicates: []tf.FitPredicate{tf.ErrorPredicateExtender},
}, },
}, },
nodes: []string{"node1", "node2"}, nodes: []string{"node1", "node2"},
@ -70,19 +70,19 @@ func TestSchedulerWithExtenders(t *testing.T) {
name: "test 1", name: "test 1",
}, },
{ {
registerPlugins: []st.RegisterPluginFunc{ registerPlugins: []tf.RegisterPluginFunc{
st.RegisterFilterPlugin("TrueFilter", st.NewTrueFilterPlugin), tf.RegisterFilterPlugin("TrueFilter", tf.NewTrueFilterPlugin),
st.RegisterQueueSortPlugin(queuesort.Name, queuesort.New), tf.RegisterQueueSortPlugin(queuesort.Name, queuesort.New),
st.RegisterBindPlugin(defaultbinder.Name, defaultbinder.New), tf.RegisterBindPlugin(defaultbinder.Name, defaultbinder.New),
}, },
extenders: []st.FakeExtender{ extenders: []tf.FakeExtender{
{ {
ExtenderName: "FakeExtender1", ExtenderName: "FakeExtender1",
Predicates: []st.FitPredicate{st.TruePredicateExtender}, Predicates: []tf.FitPredicate{tf.TruePredicateExtender},
}, },
{ {
ExtenderName: "FakeExtender2", ExtenderName: "FakeExtender2",
Predicates: []st.FitPredicate{st.FalsePredicateExtender}, Predicates: []tf.FitPredicate{tf.FalsePredicateExtender},
}, },
}, },
nodes: []string{"node1", "node2"}, nodes: []string{"node1", "node2"},
@ -90,19 +90,19 @@ func TestSchedulerWithExtenders(t *testing.T) {
name: "test 2", name: "test 2",
}, },
{ {
registerPlugins: []st.RegisterPluginFunc{ registerPlugins: []tf.RegisterPluginFunc{
st.RegisterFilterPlugin("TrueFilter", st.NewTrueFilterPlugin), tf.RegisterFilterPlugin("TrueFilter", tf.NewTrueFilterPlugin),
st.RegisterQueueSortPlugin(queuesort.Name, queuesort.New), tf.RegisterQueueSortPlugin(queuesort.Name, queuesort.New),
st.RegisterBindPlugin(defaultbinder.Name, defaultbinder.New), tf.RegisterBindPlugin(defaultbinder.Name, defaultbinder.New),
}, },
extenders: []st.FakeExtender{ extenders: []tf.FakeExtender{
{ {
ExtenderName: "FakeExtender1", ExtenderName: "FakeExtender1",
Predicates: []st.FitPredicate{st.TruePredicateExtender}, Predicates: []tf.FitPredicate{tf.TruePredicateExtender},
}, },
{ {
ExtenderName: "FakeExtender2", ExtenderName: "FakeExtender2",
Predicates: []st.FitPredicate{st.Node1PredicateExtender}, Predicates: []tf.FitPredicate{tf.Node1PredicateExtender},
}, },
}, },
nodes: []string{"node1", "node2"}, nodes: []string{"node1", "node2"},
@ -114,19 +114,19 @@ func TestSchedulerWithExtenders(t *testing.T) {
name: "test 3", name: "test 3",
}, },
{ {
registerPlugins: []st.RegisterPluginFunc{ registerPlugins: []tf.RegisterPluginFunc{
st.RegisterFilterPlugin("TrueFilter", st.NewTrueFilterPlugin), tf.RegisterFilterPlugin("TrueFilter", tf.NewTrueFilterPlugin),
st.RegisterQueueSortPlugin(queuesort.Name, queuesort.New), tf.RegisterQueueSortPlugin(queuesort.Name, queuesort.New),
st.RegisterBindPlugin(defaultbinder.Name, defaultbinder.New), tf.RegisterBindPlugin(defaultbinder.Name, defaultbinder.New),
}, },
extenders: []st.FakeExtender{ extenders: []tf.FakeExtender{
{ {
ExtenderName: "FakeExtender1", ExtenderName: "FakeExtender1",
Predicates: []st.FitPredicate{st.Node2PredicateExtender}, Predicates: []tf.FitPredicate{tf.Node2PredicateExtender},
}, },
{ {
ExtenderName: "FakeExtender2", ExtenderName: "FakeExtender2",
Predicates: []st.FitPredicate{st.Node1PredicateExtender}, Predicates: []tf.FitPredicate{tf.Node1PredicateExtender},
}, },
}, },
nodes: []string{"node1", "node2"}, nodes: []string{"node1", "node2"},
@ -134,16 +134,16 @@ func TestSchedulerWithExtenders(t *testing.T) {
name: "test 4", name: "test 4",
}, },
{ {
registerPlugins: []st.RegisterPluginFunc{ registerPlugins: []tf.RegisterPluginFunc{
st.RegisterFilterPlugin("TrueFilter", st.NewTrueFilterPlugin), tf.RegisterFilterPlugin("TrueFilter", tf.NewTrueFilterPlugin),
st.RegisterQueueSortPlugin(queuesort.Name, queuesort.New), tf.RegisterQueueSortPlugin(queuesort.Name, queuesort.New),
st.RegisterBindPlugin(defaultbinder.Name, defaultbinder.New), tf.RegisterBindPlugin(defaultbinder.Name, defaultbinder.New),
}, },
extenders: []st.FakeExtender{ extenders: []tf.FakeExtender{
{ {
ExtenderName: "FakeExtender1", ExtenderName: "FakeExtender1",
Predicates: []st.FitPredicate{st.TruePredicateExtender}, Predicates: []tf.FitPredicate{tf.TruePredicateExtender},
Prioritizers: []st.PriorityConfig{{Function: st.ErrorPrioritizerExtender, Weight: 10}}, Prioritizers: []tf.PriorityConfig{{Function: tf.ErrorPrioritizerExtender, Weight: 10}},
Weight: 1, Weight: 1,
}, },
}, },
@ -156,22 +156,22 @@ func TestSchedulerWithExtenders(t *testing.T) {
name: "test 5", name: "test 5",
}, },
{ {
registerPlugins: []st.RegisterPluginFunc{ registerPlugins: []tf.RegisterPluginFunc{
st.RegisterFilterPlugin("TrueFilter", st.NewTrueFilterPlugin), tf.RegisterFilterPlugin("TrueFilter", tf.NewTrueFilterPlugin),
st.RegisterQueueSortPlugin(queuesort.Name, queuesort.New), tf.RegisterQueueSortPlugin(queuesort.Name, queuesort.New),
st.RegisterBindPlugin(defaultbinder.Name, defaultbinder.New), tf.RegisterBindPlugin(defaultbinder.Name, defaultbinder.New),
}, },
extenders: []st.FakeExtender{ extenders: []tf.FakeExtender{
{ {
ExtenderName: "FakeExtender1", ExtenderName: "FakeExtender1",
Predicates: []st.FitPredicate{st.TruePredicateExtender}, Predicates: []tf.FitPredicate{tf.TruePredicateExtender},
Prioritizers: []st.PriorityConfig{{Function: st.Node1PrioritizerExtender, Weight: 10}}, Prioritizers: []tf.PriorityConfig{{Function: tf.Node1PrioritizerExtender, Weight: 10}},
Weight: 1, Weight: 1,
}, },
{ {
ExtenderName: "FakeExtender2", ExtenderName: "FakeExtender2",
Predicates: []st.FitPredicate{st.TruePredicateExtender}, Predicates: []tf.FitPredicate{tf.TruePredicateExtender},
Prioritizers: []st.PriorityConfig{{Function: st.Node2PrioritizerExtender, Weight: 10}}, Prioritizers: []tf.PriorityConfig{{Function: tf.Node2PrioritizerExtender, Weight: 10}},
Weight: 5, Weight: 5,
}, },
}, },
@ -184,17 +184,17 @@ func TestSchedulerWithExtenders(t *testing.T) {
name: "test 6", name: "test 6",
}, },
{ {
registerPlugins: []st.RegisterPluginFunc{ registerPlugins: []tf.RegisterPluginFunc{
st.RegisterFilterPlugin("TrueFilter", st.NewTrueFilterPlugin), tf.RegisterFilterPlugin("TrueFilter", tf.NewTrueFilterPlugin),
st.RegisterScorePlugin("Node2Prioritizer", st.NewNode2PrioritizerPlugin(), 20), tf.RegisterScorePlugin("Node2Prioritizer", tf.NewNode2PrioritizerPlugin(), 20),
st.RegisterQueueSortPlugin(queuesort.Name, queuesort.New), tf.RegisterQueueSortPlugin(queuesort.Name, queuesort.New),
st.RegisterBindPlugin(defaultbinder.Name, defaultbinder.New), tf.RegisterBindPlugin(defaultbinder.Name, defaultbinder.New),
}, },
extenders: []st.FakeExtender{ extenders: []tf.FakeExtender{
{ {
ExtenderName: "FakeExtender1", ExtenderName: "FakeExtender1",
Predicates: []st.FitPredicate{st.TruePredicateExtender}, Predicates: []tf.FitPredicate{tf.TruePredicateExtender},
Prioritizers: []st.PriorityConfig{{Function: st.Node1PrioritizerExtender, Weight: 10}}, Prioritizers: []tf.PriorityConfig{{Function: tf.Node1PrioritizerExtender, Weight: 10}},
Weight: 1, Weight: 1,
}, },
}, },
@ -214,17 +214,17 @@ func TestSchedulerWithExtenders(t *testing.T) {
// If scheduler sends the pod by mistake, the test would fail // If scheduler sends the pod by mistake, the test would fail
// because of the errors from errorPredicateExtender and/or // because of the errors from errorPredicateExtender and/or
// errorPrioritizerExtender. // errorPrioritizerExtender.
registerPlugins: []st.RegisterPluginFunc{ registerPlugins: []tf.RegisterPluginFunc{
st.RegisterFilterPlugin("TrueFilter", st.NewTrueFilterPlugin), tf.RegisterFilterPlugin("TrueFilter", tf.NewTrueFilterPlugin),
st.RegisterScorePlugin("Node2Prioritizer", st.NewNode2PrioritizerPlugin(), 1), tf.RegisterScorePlugin("Node2Prioritizer", tf.NewNode2PrioritizerPlugin(), 1),
st.RegisterQueueSortPlugin(queuesort.Name, queuesort.New), tf.RegisterQueueSortPlugin(queuesort.Name, queuesort.New),
st.RegisterBindPlugin(defaultbinder.Name, defaultbinder.New), tf.RegisterBindPlugin(defaultbinder.Name, defaultbinder.New),
}, },
extenders: []st.FakeExtender{ extenders: []tf.FakeExtender{
{ {
ExtenderName: "FakeExtender1", ExtenderName: "FakeExtender1",
Predicates: []st.FitPredicate{st.ErrorPredicateExtender}, Predicates: []tf.FitPredicate{tf.ErrorPredicateExtender},
Prioritizers: []st.PriorityConfig{{Function: st.ErrorPrioritizerExtender, Weight: 10}}, Prioritizers: []tf.PriorityConfig{{Function: tf.ErrorPrioritizerExtender, Weight: 10}},
UnInterested: true, UnInterested: true,
}, },
}, },
@ -243,20 +243,20 @@ func TestSchedulerWithExtenders(t *testing.T) {
// //
// If scheduler did not ignore the extender, the test would fail // If scheduler did not ignore the extender, the test would fail
// because of the errors from errorPredicateExtender. // because of the errors from errorPredicateExtender.
registerPlugins: []st.RegisterPluginFunc{ registerPlugins: []tf.RegisterPluginFunc{
st.RegisterFilterPlugin("TrueFilter", st.NewTrueFilterPlugin), tf.RegisterFilterPlugin("TrueFilter", tf.NewTrueFilterPlugin),
st.RegisterQueueSortPlugin(queuesort.Name, queuesort.New), tf.RegisterQueueSortPlugin(queuesort.Name, queuesort.New),
st.RegisterBindPlugin(defaultbinder.Name, defaultbinder.New), tf.RegisterBindPlugin(defaultbinder.Name, defaultbinder.New),
}, },
extenders: []st.FakeExtender{ extenders: []tf.FakeExtender{
{ {
ExtenderName: "FakeExtender1", ExtenderName: "FakeExtender1",
Predicates: []st.FitPredicate{st.ErrorPredicateExtender}, Predicates: []tf.FitPredicate{tf.ErrorPredicateExtender},
Ignorable: true, Ignorable: true,
}, },
{ {
ExtenderName: "FakeExtender2", ExtenderName: "FakeExtender2",
Predicates: []st.FitPredicate{st.Node1PredicateExtender}, Predicates: []tf.FitPredicate{tf.Node1PredicateExtender},
}, },
}, },
nodes: []string{"node1", "node2"}, nodes: []string{"node1", "node2"},
@ -287,7 +287,7 @@ func TestSchedulerWithExtenders(t *testing.T) {
for _, name := range test.nodes { for _, name := range test.nodes {
cache.AddNode(logger, createNode(name)) cache.AddNode(logger, createNode(name))
} }
fwk, err := st.NewFramework( fwk, err := tf.NewFramework(
ctx, ctx,
test.registerPlugins, "", test.registerPlugins, "",
runtime.WithClientSet(client), runtime.WithClientSet(client),
@ -510,7 +510,7 @@ func TestConvertToVictims(t *testing.T) {
nodeInfo.AddPod(tt.podsInNodeList[i+2]) nodeInfo.AddPod(tt.podsInNodeList[i+2])
nodeInfoList = append(nodeInfoList, nodeInfo) nodeInfoList = append(nodeInfoList, nodeInfo)
} }
tt.nodeInfos = fake.NodeInfoLister(nodeInfoList) tt.nodeInfos = tf.NodeInfoLister(nodeInfoList)
got, err := tt.httpExtender.convertToVictims(tt.nodeNameToMetaVictims, tt.nodeInfos) got, err := tt.httpExtender.convertToVictims(tt.nodeNameToMetaVictims, tt.nodeInfos)
if (err != nil) != tt.wantErr { if (err != nil) != tt.wantErr {

195
pkg/scheduler/framework/plugins/defaultpreemption/default_preemption_test.go
View File

@ -56,6 +56,7 @@ import (
internalcache "k8s.io/kubernetes/pkg/scheduler/internal/cache" internalcache "k8s.io/kubernetes/pkg/scheduler/internal/cache"
internalqueue "k8s.io/kubernetes/pkg/scheduler/internal/queue" internalqueue "k8s.io/kubernetes/pkg/scheduler/internal/queue"
st "k8s.io/kubernetes/pkg/scheduler/testing" st "k8s.io/kubernetes/pkg/scheduler/testing"
tf "k8s.io/kubernetes/pkg/scheduler/testing/framework"
) )
var ( var (
@ -228,9 +229,9 @@ func TestPostFilter(t *testing.T) {
"node1": framework.NewStatus(framework.Unschedulable), "node1": framework.NewStatus(framework.Unschedulable),
"node2": framework.NewStatus(framework.Unschedulable), "node2": framework.NewStatus(framework.Unschedulable),
}, },
extender: &st.FakeExtender{ extender: &tf.FakeExtender{
ExtenderName: "FakeExtender1", ExtenderName: "FakeExtender1",
Predicates: []st.FitPredicate{st.Node1PredicateExtender}, Predicates: []tf.FitPredicate{tf.Node1PredicateExtender},
}, },
wantResult: framework.NewPostFilterResultWithNominatedNode("node1"), wantResult: framework.NewPostFilterResultWithNominatedNode("node1"),
wantStatus: framework.NewStatus(framework.Success), wantStatus: framework.NewStatus(framework.Success),
@ -342,11 +343,11 @@ func TestPostFilter(t *testing.T) {
podInformer.GetStore().Add(tt.pods[i]) podInformer.GetStore().Add(tt.pods[i])
} }
// Register NodeResourceFit as the Filter & PreFilter plugin. // Register NodeResourceFit as the Filter & PreFilter plugin.
registeredPlugins := []st.RegisterPluginFunc{ registeredPlugins := []tf.RegisterPluginFunc{
st.RegisterQueueSortPlugin(queuesort.Name, queuesort.New), tf.RegisterQueueSortPlugin(queuesort.Name, queuesort.New),
st.RegisterPluginAsExtensions(noderesources.Name, nodeResourcesFitFunc, "Filter", "PreFilter"), tf.RegisterPluginAsExtensions(noderesources.Name, nodeResourcesFitFunc, "Filter", "PreFilter"),
st.RegisterPluginAsExtensions("test-plugin", newTestPlugin, "PreFilter"), tf.RegisterPluginAsExtensions("test-plugin", newTestPlugin, "PreFilter"),
st.RegisterBindPlugin(defaultbinder.Name, defaultbinder.New), tf.RegisterBindPlugin(defaultbinder.Name, defaultbinder.New),
} }
var extenders []framework.Extender var extenders []framework.Extender
if tt.extender != nil { if tt.extender != nil {
@ -355,7 +356,7 @@ func TestPostFilter(t *testing.T) {
logger, ctx := ktesting.NewTestContext(t) logger, ctx := ktesting.NewTestContext(t)
ctx, cancel := context.WithCancel(ctx) ctx, cancel := context.WithCancel(ctx)
defer cancel() defer cancel()
f, err := st.NewFramework(ctx, registeredPlugins, "", f, err := tf.NewFramework(ctx, registeredPlugins, "",
frameworkruntime.WithClientSet(cs), frameworkruntime.WithClientSet(cs),
frameworkruntime.WithEventRecorder(&events.FakeRecorder{}), frameworkruntime.WithEventRecorder(&events.FakeRecorder{}),
frameworkruntime.WithInformerFactory(informerFactory), frameworkruntime.WithInformerFactory(informerFactory),
@ -410,7 +411,7 @@ func TestDryRunPreemption(t *testing.T) {
nodeNames []string nodeNames []string
testPods []*v1.Pod testPods []*v1.Pod
initPods []*v1.Pod initPods []*v1.Pod
registerPlugins []st.RegisterPluginFunc registerPlugins []tf.RegisterPluginFunc
pdbs []*policy.PodDisruptionBudget pdbs []*policy.PodDisruptionBudget
fakeFilterRC framework.Code // return code for fake filter plugin fakeFilterRC framework.Code // return code for fake filter plugin
disableParallelism bool disableParallelism bool
@ -419,8 +420,8 @@ func TestDryRunPreemption(t *testing.T) {
}{ }{
{ {
name: "a pod that does not fit on any node", name: "a pod that does not fit on any node",
registerPlugins: []st.RegisterPluginFunc{ registerPlugins: []tf.RegisterPluginFunc{
st.RegisterFilterPlugin("FalseFilter", st.NewFalseFilterPlugin), tf.RegisterFilterPlugin("FalseFilter", tf.NewFalseFilterPlugin),
}, },
nodeNames: []string{"node1", "node2"}, nodeNames: []string{"node1", "node2"},
testPods: []*v1.Pod{ testPods: []*v1.Pod{
@ -435,8 +436,8 @@ func TestDryRunPreemption(t *testing.T) {
}, },
{ {
name: "a pod that fits with no preemption", name: "a pod that fits with no preemption",
registerPlugins: []st.RegisterPluginFunc{ registerPlugins: []tf.RegisterPluginFunc{
st.RegisterFilterPlugin("TrueFilter", st.NewTrueFilterPlugin), tf.RegisterFilterPlugin("TrueFilter", tf.NewTrueFilterPlugin),
}, },
nodeNames: []string{"node1", "node2"}, nodeNames: []string{"node1", "node2"},
testPods: []*v1.Pod{ testPods: []*v1.Pod{
@ -452,8 +453,8 @@ func TestDryRunPreemption(t *testing.T) {
}, },
{ {
name: "a pod that fits on one node with no preemption", name: "a pod that fits on one node with no preemption",
registerPlugins: []st.RegisterPluginFunc{ registerPlugins: []tf.RegisterPluginFunc{
st.RegisterFilterPlugin("MatchFilter", st.NewMatchFilterPlugin), tf.RegisterFilterPlugin("MatchFilter", tf.NewMatchFilterPlugin),
}, },
nodeNames: []string{"node1", "node2"}, nodeNames: []string{"node1", "node2"},
testPods: []*v1.Pod{ testPods: []*v1.Pod{
@ -470,8 +471,8 @@ func TestDryRunPreemption(t *testing.T) {
}, },
{ {
name: "a pod that fits on both nodes when lower priority pods are preempted", name: "a pod that fits on both nodes when lower priority pods are preempted",
registerPlugins: []st.RegisterPluginFunc{ registerPlugins: []tf.RegisterPluginFunc{
st.RegisterPluginAsExtensions(noderesources.Name, nodeResourcesFitFunc, "Filter", "PreFilter"), tf.RegisterPluginAsExtensions(noderesources.Name, nodeResourcesFitFunc, "Filter", "PreFilter"),
}, },
nodeNames: []string{"node1", "node2"}, nodeNames: []string{"node1", "node2"},
testPods: []*v1.Pod{ testPods: []*v1.Pod{
@ -501,8 +502,8 @@ func TestDryRunPreemption(t *testing.T) {
}, },
{ {
name: "a pod that would fit on the nodes, but other pods running are higher priority, no preemption would happen", name: "a pod that would fit on the nodes, but other pods running are higher priority, no preemption would happen",
registerPlugins: []st.RegisterPluginFunc{ registerPlugins: []tf.RegisterPluginFunc{
st.RegisterPluginAsExtensions(noderesources.Name, nodeResourcesFitFunc, "Filter", "PreFilter"), tf.RegisterPluginAsExtensions(noderesources.Name, nodeResourcesFitFunc, "Filter", "PreFilter"),
}, },
nodeNames: []string{"node1", "node2"}, nodeNames: []string{"node1", "node2"},
testPods: []*v1.Pod{ testPods: []*v1.Pod{
@ -517,8 +518,8 @@ func TestDryRunPreemption(t *testing.T) {
}, },
{ {
name: "medium priority pod is preempted, but lower priority one stays as it is small", name: "medium priority pod is preempted, but lower priority one stays as it is small",
registerPlugins: []st.RegisterPluginFunc{ registerPlugins: []tf.RegisterPluginFunc{
st.RegisterPluginAsExtensions(noderesources.Name, nodeResourcesFitFunc, "Filter", "PreFilter"), tf.RegisterPluginAsExtensions(noderesources.Name, nodeResourcesFitFunc, "Filter", "PreFilter"),
}, },
nodeNames: []string{"node1", "node2"}, nodeNames: []string{"node1", "node2"},
testPods: []*v1.Pod{ testPods: []*v1.Pod{
@ -549,8 +550,8 @@ func TestDryRunPreemption(t *testing.T) {
}, },
{ {
name: "mixed priority pods are preempted", name: "mixed priority pods are preempted",
registerPlugins: []st.RegisterPluginFunc{ registerPlugins: []tf.RegisterPluginFunc{
st.RegisterPluginAsExtensions(noderesources.Name, nodeResourcesFitFunc, "Filter", "PreFilter"), tf.RegisterPluginAsExtensions(noderesources.Name, nodeResourcesFitFunc, "Filter", "PreFilter"),
}, },
nodeNames: []string{"node1", "node2"}, nodeNames: []string{"node1", "node2"},
testPods: []*v1.Pod{ testPods: []*v1.Pod{
@ -580,8 +581,8 @@ func TestDryRunPreemption(t *testing.T) {
}, },
{ {
name: "mixed priority pods are preempted, pick later StartTime one when priorities are equal", name: "mixed priority pods are preempted, pick later StartTime one when priorities are equal",
registerPlugins: []st.RegisterPluginFunc{ registerPlugins: []tf.RegisterPluginFunc{
st.RegisterPluginAsExtensions(noderesources.Name, nodeResourcesFitFunc, "Filter", "PreFilter"), tf.RegisterPluginAsExtensions(noderesources.Name, nodeResourcesFitFunc, "Filter", "PreFilter"),
}, },
nodeNames: []string{"node1", "node2"}, nodeNames: []string{"node1", "node2"},
testPods: []*v1.Pod{ testPods: []*v1.Pod{
@ -611,9 +612,9 @@ func TestDryRunPreemption(t *testing.T) {
}, },
{ {
name: "pod with anti-affinity is preempted", name: "pod with anti-affinity is preempted",
registerPlugins: []st.RegisterPluginFunc{ registerPlugins: []tf.RegisterPluginFunc{
st.RegisterPluginAsExtensions(noderesources.Name, nodeResourcesFitFunc, "Filter", "PreFilter"), tf.RegisterPluginAsExtensions(noderesources.Name, nodeResourcesFitFunc, "Filter", "PreFilter"),
st.RegisterPluginAsExtensions(interpodaffinity.Name, interpodaffinity.New, "Filter", "PreFilter"), tf.RegisterPluginAsExtensions(interpodaffinity.Name, interpodaffinity.New, "Filter", "PreFilter"),
}, },
nodeNames: []string{"node1", "node2"}, nodeNames: []string{"node1", "node2"},
testPods: []*v1.Pod{ testPods: []*v1.Pod{
@ -643,8 +644,8 @@ func TestDryRunPreemption(t *testing.T) {
}, },
{ {
name: "preemption to resolve pod topology spread filter failure", name: "preemption to resolve pod topology spread filter failure",
registerPlugins: []st.RegisterPluginFunc{ registerPlugins: []tf.RegisterPluginFunc{
st.RegisterPluginAsExtensions(podtopologyspread.Name, podTopologySpreadFunc, "PreFilter", "Filter"), tf.RegisterPluginAsExtensions(podtopologyspread.Name, podTopologySpreadFunc, "PreFilter", "Filter"),
}, },
nodeNames: []string{"node-a/zone1", "node-b/zone1", "node-x/zone2"}, nodeNames: []string{"node-a/zone1", "node-b/zone1", "node-x/zone2"},
testPods: []*v1.Pod{ testPods: []*v1.Pod{
@ -680,8 +681,8 @@ func TestDryRunPreemption(t *testing.T) {
}, },
{ {
name: "get Unschedulable in the preemption phase when the filter plugins filtering the nodes", name: "get Unschedulable in the preemption phase when the filter plugins filtering the nodes",
registerPlugins: []st.RegisterPluginFunc{ registerPlugins: []tf.RegisterPluginFunc{
st.RegisterPluginAsExtensions(noderesources.Name, nodeResourcesFitFunc, "Filter", "PreFilter"), tf.RegisterPluginAsExtensions(noderesources.Name, nodeResourcesFitFunc, "Filter", "PreFilter"),
}, },
nodeNames: []string{"node1", "node2"}, nodeNames: []string{"node1", "node2"},
testPods: []*v1.Pod{ testPods: []*v1.Pod{
@ -697,8 +698,8 @@ func TestDryRunPreemption(t *testing.T) {
}, },
{ {
name: "preemption with violation of same pdb", name: "preemption with violation of same pdb",
registerPlugins: []st.RegisterPluginFunc{ registerPlugins: []tf.RegisterPluginFunc{
st.RegisterPluginAsExtensions(noderesources.Name, nodeResourcesFitFunc, "Filter", "PreFilter"), tf.RegisterPluginAsExtensions(noderesources.Name, nodeResourcesFitFunc, "Filter", "PreFilter"),
}, },
nodeNames: []string{"node1"}, nodeNames: []string{"node1"},
testPods: []*v1.Pod{ testPods: []*v1.Pod{
@ -732,8 +733,8 @@ func TestDryRunPreemption(t *testing.T) {
}, },
{ {
name: "preemption with violation of the pdb with pod whose eviction was processed, the victim doesn't belong to DisruptedPods", name: "preemption with violation of the pdb with pod whose eviction was processed, the victim doesn't belong to DisruptedPods",
registerPlugins: []st.RegisterPluginFunc{ registerPlugins: []tf.RegisterPluginFunc{
st.RegisterPluginAsExtensions(noderesources.Name, nodeResourcesFitFunc, "Filter", "PreFilter"), tf.RegisterPluginAsExtensions(noderesources.Name, nodeResourcesFitFunc, "Filter", "PreFilter"),
}, },
nodeNames: []string{"node1"}, nodeNames: []string{"node1"},
testPods: []*v1.Pod{ testPods: []*v1.Pod{
@ -767,8 +768,8 @@ func TestDryRunPreemption(t *testing.T) {
}, },
{ {
name: "preemption with violation of the pdb with pod whose eviction was processed, the victim belongs to DisruptedPods", name: "preemption with violation of the pdb with pod whose eviction was processed, the victim belongs to DisruptedPods",
registerPlugins: []st.RegisterPluginFunc{ registerPlugins: []tf.RegisterPluginFunc{
st.RegisterPluginAsExtensions(noderesources.Name, nodeResourcesFitFunc, "Filter", "PreFilter"), tf.RegisterPluginAsExtensions(noderesources.Name, nodeResourcesFitFunc, "Filter", "PreFilter"),
}, },
nodeNames: []string{"node1"}, nodeNames: []string{"node1"},
testPods: []*v1.Pod{ testPods: []*v1.Pod{
@ -802,8 +803,8 @@ func TestDryRunPreemption(t *testing.T) {
}, },
{ {
name: "preemption with violation of the pdb with pod whose eviction was processed, the victim which belongs to DisruptedPods is treated as 'nonViolating'", name: "preemption with violation of the pdb with pod whose eviction was processed, the victim which belongs to DisruptedPods is treated as 'nonViolating'",
registerPlugins: []st.RegisterPluginFunc{ registerPlugins: []tf.RegisterPluginFunc{
st.RegisterPluginAsExtensions(noderesources.Name, nodeResourcesFitFunc, "Filter", "PreFilter"), tf.RegisterPluginAsExtensions(noderesources.Name, nodeResourcesFitFunc, "Filter", "PreFilter"),
}, },
nodeNames: []string{"node1"}, nodeNames: []string{"node1"},
testPods: []*v1.Pod{ testPods: []*v1.Pod{
@ -840,8 +841,8 @@ func TestDryRunPreemption(t *testing.T) {
{ {
name: "all nodes are possible candidates, but DefaultPreemptionArgs limits to 2", name: "all nodes are possible candidates, but DefaultPreemptionArgs limits to 2",
args: &config.DefaultPreemptionArgs{MinCandidateNodesPercentage: 40, MinCandidateNodesAbsolute: 1}, args: &config.DefaultPreemptionArgs{MinCandidateNodesPercentage: 40, MinCandidateNodesAbsolute: 1},
registerPlugins: []st.RegisterPluginFunc{ registerPlugins: []tf.RegisterPluginFunc{
st.RegisterPluginAsExtensions(noderesources.Name, nodeResourcesFitFunc, "Filter", "PreFilter"), tf.RegisterPluginAsExtensions(noderesources.Name, nodeResourcesFitFunc, "Filter", "PreFilter"),
}, },
nodeNames: []string{"node1", "node2", "node3", "node4", "node5"}, nodeNames: []string{"node1", "node2", "node3", "node4", "node5"},
testPods: []*v1.Pod{ testPods: []*v1.Pod{
@ -877,8 +878,8 @@ func TestDryRunPreemption(t *testing.T) {
{ {
name: "some nodes are not possible candidates, DefaultPreemptionArgs limits to 2", name: "some nodes are not possible candidates, DefaultPreemptionArgs limits to 2",
args: &config.DefaultPreemptionArgs{MinCandidateNodesPercentage: 40, MinCandidateNodesAbsolute: 1}, args: &config.DefaultPreemptionArgs{MinCandidateNodesPercentage: 40, MinCandidateNodesAbsolute: 1},
registerPlugins: []st.RegisterPluginFunc{ registerPlugins: []tf.RegisterPluginFunc{
st.RegisterPluginAsExtensions(noderesources.Name, nodeResourcesFitFunc, "Filter", "PreFilter"), tf.RegisterPluginAsExtensions(noderesources.Name, nodeResourcesFitFunc, "Filter", "PreFilter"),
}, },
nodeNames: []string{"node1", "node2", "node3", "node4", "node5"}, nodeNames: []string{"node1", "node2", "node3", "node4", "node5"},
testPods: []*v1.Pod{ testPods: []*v1.Pod{
@ -914,8 +915,8 @@ func TestDryRunPreemption(t *testing.T) {
{ {
name: "preemption offset across multiple scheduling cycles and wrap around", name: "preemption offset across multiple scheduling cycles and wrap around",
args: &config.DefaultPreemptionArgs{MinCandidateNodesPercentage: 40, MinCandidateNodesAbsolute: 1}, args: &config.DefaultPreemptionArgs{MinCandidateNodesPercentage: 40, MinCandidateNodesAbsolute: 1},
registerPlugins: []st.RegisterPluginFunc{ registerPlugins: []tf.RegisterPluginFunc{
st.RegisterPluginAsExtensions(noderesources.Name, nodeResourcesFitFunc, "Filter", "PreFilter"), tf.RegisterPluginAsExtensions(noderesources.Name, nodeResourcesFitFunc, "Filter", "PreFilter"),
}, },
nodeNames: []string{"node1", "node2", "node3", "node4", "node5"}, nodeNames: []string{"node1", "node2", "node3", "node4", "node5"},
testPods: []*v1.Pod{ testPods: []*v1.Pod{
@ -983,8 +984,8 @@ func TestDryRunPreemption(t *testing.T) {
{ {
name: "preemption looks past numCandidates until a non-PDB violating node is found", name: "preemption looks past numCandidates until a non-PDB violating node is found",
args: &config.DefaultPreemptionArgs{MinCandidateNodesPercentage: 40, MinCandidateNodesAbsolute: 2}, args: &config.DefaultPreemptionArgs{MinCandidateNodesPercentage: 40, MinCandidateNodesAbsolute: 2},
registerPlugins: []st.RegisterPluginFunc{ registerPlugins: []tf.RegisterPluginFunc{
st.RegisterPluginAsExtensions(noderesources.Name, nodeResourcesFitFunc, "Filter", "PreFilter"), tf.RegisterPluginAsExtensions(noderesources.Name, nodeResourcesFitFunc, "Filter", "PreFilter"),
}, },
nodeNames: []string{"node1", "node2", "node3", "node4", "node5"}, nodeNames: []string{"node1", "node2", "node3", "node4", "node5"},
testPods: []*v1.Pod{ testPods: []*v1.Pod{
@ -1059,18 +1060,18 @@ func TestDryRunPreemption(t *testing.T) {
snapshot := internalcache.NewSnapshot(tt.initPods, nodes) snapshot := internalcache.NewSnapshot(tt.initPods, nodes)
// For each test, register a FakeFilterPlugin along with essential plugins and tt.registerPlugins. // For each test, register a FakeFilterPlugin along with essential plugins and tt.registerPlugins.
fakePlugin := st.FakeFilterPlugin{ fakePlugin := tf.FakeFilterPlugin{
FailedNodeReturnCodeMap: fakeFilterRCMap, FailedNodeReturnCodeMap: fakeFilterRCMap,
} }
registeredPlugins := append([]st.RegisterPluginFunc{ registeredPlugins := append([]tf.RegisterPluginFunc{
st.RegisterFilterPlugin( tf.RegisterFilterPlugin(
"FakeFilter", "FakeFilter",
func(_ runtime.Object, fh framework.Handle) (framework.Plugin, error) { func(_ runtime.Object, fh framework.Handle) (framework.Plugin, error) {
return &fakePlugin, nil return &fakePlugin, nil
}, },
)}, )},
st.RegisterQueueSortPlugin(queuesort.Name, queuesort.New), tf.RegisterQueueSortPlugin(queuesort.Name, queuesort.New),
st.RegisterBindPlugin(defaultbinder.Name, defaultbinder.New), tf.RegisterBindPlugin(defaultbinder.Name, defaultbinder.New),
) )
registeredPlugins = append(registeredPlugins, tt.registerPlugins...) registeredPlugins = append(registeredPlugins, tt.registerPlugins...)
var objs []runtime.Object var objs []runtime.Object
@ -1092,7 +1093,7 @@ func TestDryRunPreemption(t *testing.T) {
logger, ctx := ktesting.NewTestContext(t) logger, ctx := ktesting.NewTestContext(t)
ctx, cancel := context.WithCancel(ctx) ctx, cancel := context.WithCancel(ctx)
defer cancel() defer cancel()
fwk, err := st.NewFramework( fwk, err := tf.NewFramework(
ctx, ctx,
registeredPlugins, "", registeredPlugins, "",
frameworkruntime.WithPodNominator(internalqueue.NewPodNominator(informerFactory.Core().V1().Pods().Lister())), frameworkruntime.WithPodNominator(internalqueue.NewPodNominator(informerFactory.Core().V1().Pods().Lister())),
@ -1176,7 +1177,7 @@ func TestDryRunPreemption(t *testing.T) {
func TestSelectBestCandidate(t *testing.T) { func TestSelectBestCandidate(t *testing.T) {
tests := []struct { tests := []struct {
name string name string
registerPlugin st.RegisterPluginFunc registerPlugin tf.RegisterPluginFunc
nodeNames []string nodeNames []string
pod *v1.Pod pod *v1.Pod
pods []*v1.Pod pods []*v1.Pod
@ -1184,7 +1185,7 @@ func TestSelectBestCandidate(t *testing.T) {
}{ }{
{ {
name: "a pod that fits on both nodes when lower priority pods are preempted", name: "a pod that fits on both nodes when lower priority pods are preempted",
registerPlugin: st.RegisterPluginAsExtensions(noderesources.Name, nodeResourcesFitFunc, "Filter", "PreFilter"), registerPlugin: tf.RegisterPluginAsExtensions(noderesources.Name, nodeResourcesFitFunc, "Filter", "PreFilter"),
nodeNames: []string{"node1", "node2"}, nodeNames: []string{"node1", "node2"},
pod: st.MakePod().Name("p").UID("p").Priority(highPriority).Req(largeRes).Obj(), pod: st.MakePod().Name("p").UID("p").Priority(highPriority).Req(largeRes).Obj(),
pods: []*v1.Pod{ pods: []*v1.Pod{
@ -1195,7 +1196,7 @@ func TestSelectBestCandidate(t *testing.T) {
}, },
{ {
name: "node with min highest priority pod is picked", name: "node with min highest priority pod is picked",
registerPlugin: st.RegisterPluginAsExtensions(noderesources.Name, nodeResourcesFitFunc, "Filter", "PreFilter"), registerPlugin: tf.RegisterPluginAsExtensions(noderesources.Name, nodeResourcesFitFunc, "Filter", "PreFilter"),
nodeNames: []string{"node1", "node2", "node3"}, nodeNames: []string{"node1", "node2", "node3"},
pod: st.MakePod().Name("p").UID("p").Priority(highPriority).Req(veryLargeRes).Obj(), pod: st.MakePod().Name("p").UID("p").Priority(highPriority).Req(veryLargeRes).Obj(),
pods: []*v1.Pod{ pods: []*v1.Pod{
@ -1210,7 +1211,7 @@ func TestSelectBestCandidate(t *testing.T) {
}, },
{ {
name: "when highest priorities are the same, minimum sum of priorities is picked", name: "when highest priorities are the same, minimum sum of priorities is picked",
registerPlugin: st.RegisterPluginAsExtensions(noderesources.Name, nodeResourcesFitFunc, "Filter", "PreFilter"), registerPlugin: tf.RegisterPluginAsExtensions(noderesources.Name, nodeResourcesFitFunc, "Filter", "PreFilter"),
nodeNames: []string{"node1", "node2", "node3"}, nodeNames: []string{"node1", "node2", "node3"},
pod: st.MakePod().Name("p").UID("p").Priority(highPriority).Req(veryLargeRes).Obj(), pod: st.MakePod().Name("p").UID("p").Priority(highPriority).Req(veryLargeRes).Obj(),
pods: []*v1.Pod{ pods: []*v1.Pod{
@ -1225,7 +1226,7 @@ func TestSelectBestCandidate(t *testing.T) {
}, },
{ {
name: "when highest priority and sum are the same, minimum number of pods is picked", name: "when highest priority and sum are the same, minimum number of pods is picked",
registerPlugin: st.RegisterPluginAsExtensions(noderesources.Name, nodeResourcesFitFunc, "Filter", "PreFilter"), registerPlugin: tf.RegisterPluginAsExtensions(noderesources.Name, nodeResourcesFitFunc, "Filter", "PreFilter"),
nodeNames: []string{"node1", "node2", "node3"}, nodeNames: []string{"node1", "node2", "node3"},
pod: st.MakePod().Name("p").UID("p").Priority(highPriority).Req(veryLargeRes).Obj(), pod: st.MakePod().Name("p").UID("p").Priority(highPriority).Req(veryLargeRes).Obj(),
pods: []*v1.Pod{ pods: []*v1.Pod{
@ -1245,7 +1246,7 @@ func TestSelectBestCandidate(t *testing.T) {
// pickOneNodeForPreemption adjusts pod priorities when finding the sum of the victims. This // pickOneNodeForPreemption adjusts pod priorities when finding the sum of the victims. This
// test ensures that the logic works correctly. // test ensures that the logic works correctly.
name: "sum of adjusted priorities is considered", name: "sum of adjusted priorities is considered",
registerPlugin: st.RegisterPluginAsExtensions(noderesources.Name, nodeResourcesFitFunc, "Filter", "PreFilter"), registerPlugin: tf.RegisterPluginAsExtensions(noderesources.Name, nodeResourcesFitFunc, "Filter", "PreFilter"),
nodeNames: []string{"node1", "node2", "node3"}, nodeNames: []string{"node1", "node2", "node3"},
pod: st.MakePod().Name("p").UID("p").Priority(highPriority).Req(veryLargeRes).Obj(), pod: st.MakePod().Name("p").UID("p").Priority(highPriority).Req(veryLargeRes).Obj(),
pods: []*v1.Pod{ pods: []*v1.Pod{
@ -1262,7 +1263,7 @@ func TestSelectBestCandidate(t *testing.T) {
}, },
{ {
name: "non-overlapping lowest high priority, sum priorities, and number of pods", name: "non-overlapping lowest high priority, sum priorities, and number of pods",
registerPlugin: st.RegisterPluginAsExtensions(noderesources.Name, nodeResourcesFitFunc, "Filter", "PreFilter"), registerPlugin: tf.RegisterPluginAsExtensions(noderesources.Name, nodeResourcesFitFunc, "Filter", "PreFilter"),
nodeNames: []string{"node1", "node2", "node3", "node4"}, nodeNames: []string{"node1", "node2", "node3", "node4"},
pod: st.MakePod().Name("p").UID("p").Priority(veryHighPriority).Req(veryLargeRes).Obj(), pod: st.MakePod().Name("p").UID("p").Priority(veryHighPriority).Req(veryLargeRes).Obj(),
pods: []*v1.Pod{ pods: []*v1.Pod{
@ -1283,7 +1284,7 @@ func TestSelectBestCandidate(t *testing.T) {
}, },
{ {
name: "same priority, same number of victims, different start time for each node's pod", name: "same priority, same number of victims, different start time for each node's pod",
registerPlugin: st.RegisterPluginAsExtensions(noderesources.Name, nodeResourcesFitFunc, "Filter", "PreFilter"), registerPlugin: tf.RegisterPluginAsExtensions(noderesources.Name, nodeResourcesFitFunc, "Filter", "PreFilter"),
nodeNames: []string{"node1", "node2", "node3"}, nodeNames: []string{"node1", "node2", "node3"},
pod: st.MakePod().Name("p").UID("p").Priority(highPriority).Req(veryLargeRes).Obj(), pod: st.MakePod().Name("p").UID("p").Priority(highPriority).Req(veryLargeRes).Obj(),
pods: []*v1.Pod{ pods: []*v1.Pod{
@ -1298,7 +1299,7 @@ func TestSelectBestCandidate(t *testing.T) {
}, },
{ {
name: "same priority, same number of victims, different start time for all pods", name: "same priority, same number of victims, different start time for all pods",
registerPlugin: st.RegisterPluginAsExtensions(noderesources.Name, nodeResourcesFitFunc, "Filter", "PreFilter"), registerPlugin: tf.RegisterPluginAsExtensions(noderesources.Name, nodeResourcesFitFunc, "Filter", "PreFilter"),
nodeNames: []string{"node1", "node2", "node3"}, nodeNames: []string{"node1", "node2", "node3"},
pod: st.MakePod().Name("p").UID("p").Priority(highPriority).Req(veryLargeRes).Obj(), pod: st.MakePod().Name("p").UID("p").Priority(highPriority).Req(veryLargeRes).Obj(),
pods: []*v1.Pod{ pods: []*v1.Pod{
@ -1313,7 +1314,7 @@ func TestSelectBestCandidate(t *testing.T) {
}, },
{ {
name: "different priority, same number of victims, different start time for all pods", name: "different priority, same number of victims, different start time for all pods",
registerPlugin: st.RegisterPluginAsExtensions(noderesources.Name, nodeResourcesFitFunc, "Filter", "PreFilter"), registerPlugin: tf.RegisterPluginAsExtensions(noderesources.Name, nodeResourcesFitFunc, "Filter", "PreFilter"),
nodeNames: []string{"node1", "node2", "node3"}, nodeNames: []string{"node1", "node2", "node3"},
pod: st.MakePod().Name("p").UID("p").Priority(highPriority).Req(veryLargeRes).Obj(), pod: st.MakePod().Name("p").UID("p").Priority(highPriority).Req(veryLargeRes).Obj(),
pods: []*v1.Pod{ pods: []*v1.Pod{
@ -1346,12 +1347,12 @@ func TestSelectBestCandidate(t *testing.T) {
logger, ctx := ktesting.NewTestContext(t) logger, ctx := ktesting.NewTestContext(t)
ctx, cancel := context.WithCancel(ctx) ctx, cancel := context.WithCancel(ctx)
defer cancel() defer cancel()
fwk, err := st.NewFramework( fwk, err := tf.NewFramework(
ctx, ctx,
[]st.RegisterPluginFunc{ []tf.RegisterPluginFunc{
tt.registerPlugin, tt.registerPlugin,
st.RegisterQueueSortPlugin(queuesort.Name, queuesort.New), tf.RegisterQueueSortPlugin(queuesort.Name, queuesort.New),
st.RegisterBindPlugin(defaultbinder.Name, defaultbinder.New), tf.RegisterBindPlugin(defaultbinder.Name, defaultbinder.New),
}, },
"", "",
frameworkruntime.WithPodNominator(internalqueue.NewPodNominator(informerFactory.Core().V1().Pods().Lister())), frameworkruntime.WithPodNominator(internalqueue.NewPodNominator(informerFactory.Core().V1().Pods().Lister())),
@ -1493,11 +1494,11 @@ func TestPodEligibleToPreemptOthers(t *testing.T) {
for _, n := range test.nodes { for _, n := range test.nodes {
nodes = append(nodes, st.MakeNode().Name(n).Obj()) nodes = append(nodes, st.MakeNode().Name(n).Obj())
} }
registeredPlugins := []st.RegisterPluginFunc{ registeredPlugins := []tf.RegisterPluginFunc{
st.RegisterQueueSortPlugin(queuesort.Name, queuesort.New), tf.RegisterQueueSortPlugin(queuesort.Name, queuesort.New),
st.RegisterBindPlugin(defaultbinder.Name, defaultbinder.New), tf.RegisterBindPlugin(defaultbinder.Name, defaultbinder.New),
} }
f, err := st.NewFramework(ctx, registeredPlugins, "", f, err := tf.NewFramework(ctx, registeredPlugins, "",
frameworkruntime.WithSnapshotSharedLister(internalcache.NewSnapshot(test.pods, nodes)), frameworkruntime.WithSnapshotSharedLister(internalcache.NewSnapshot(test.pods, nodes)),
frameworkruntime.WithLogger(logger), frameworkruntime.WithLogger(logger),
) )
@ -1516,9 +1517,9 @@ func TestPreempt(t *testing.T) {
name string name string
pod *v1.Pod pod *v1.Pod
pods []*v1.Pod pods []*v1.Pod
extenders []*st.FakeExtender extenders []*tf.FakeExtender
nodeNames []string nodeNames []string
registerPlugin st.RegisterPluginFunc registerPlugin tf.RegisterPluginFunc
want *framework.PostFilterResult want *framework.PostFilterResult
expectedPods []string // list of preempted pods expectedPods []string // list of preempted pods
}{ }{
@ -1532,7 +1533,7 @@ func TestPreempt(t *testing.T) {
st.MakePod().Name("p3.1").UID("p3.1").Node("node3").Priority(midPriority).Req(mediumRes).Obj(), st.MakePod().Name("p3.1").UID("p3.1").Node("node3").Priority(midPriority).Req(mediumRes).Obj(),
}, },
nodeNames: []string{"node1", "node2", "node3"}, nodeNames: []string{"node1", "node2", "node3"},
registerPlugin: st.RegisterPluginAsExtensions(noderesources.Name, nodeResourcesFitFunc, "Filter", "PreFilter"), registerPlugin: tf.RegisterPluginAsExtensions(noderesources.Name, nodeResourcesFitFunc, "Filter", "PreFilter"),
want: framework.NewPostFilterResultWithNominatedNode("node1"), want: framework.NewPostFilterResultWithNominatedNode("node1"),
expectedPods: []string{"p1.1", "p1.2"}, expectedPods: []string{"p1.1", "p1.2"},
}, },
@ -1550,7 +1551,7 @@ func TestPreempt(t *testing.T) {
st.MakePod().Name("p-x2").UID("p-x2").Namespace(v1.NamespaceDefault).Node("node-x").Label("foo", "").Priority(highPriority).Obj(), st.MakePod().Name("p-x2").UID("p-x2").Namespace(v1.NamespaceDefault).Node("node-x").Label("foo", "").Priority(highPriority).Obj(),
}, },
nodeNames: []string{"node-a/zone1", "node-b/zone1", "node-x/zone2"}, nodeNames: []string{"node-a/zone1", "node-b/zone1", "node-x/zone2"},
registerPlugin: st.RegisterPluginAsExtensions(podtopologyspread.Name, podTopologySpreadFunc, "PreFilter", "Filter"), registerPlugin: tf.RegisterPluginAsExtensions(podtopologyspread.Name, podTopologySpreadFunc, "PreFilter", "Filter"),
want: framework.NewPostFilterResultWithNominatedNode("node-b"), want: framework.NewPostFilterResultWithNominatedNode("node-b"),
expectedPods: []string{"p-b1"}, expectedPods: []string{"p-b1"},
}, },
@ -1563,17 +1564,17 @@ func TestPreempt(t *testing.T) {
st.MakePod().Name("p2.1").UID("p2.1").Namespace(v1.NamespaceDefault).Node("node3").Priority(midPriority).Req(largeRes).Obj(), st.MakePod().Name("p2.1").UID("p2.1").Namespace(v1.NamespaceDefault).Node("node3").Priority(midPriority).Req(largeRes).Obj(),
}, },
nodeNames: []string{"node1", "node2", "node3"}, nodeNames: []string{"node1", "node2", "node3"},
extenders: []*st.FakeExtender{ extenders: []*tf.FakeExtender{
{ {
ExtenderName: "FakeExtender1", ExtenderName: "FakeExtender1",
Predicates: []st.FitPredicate{st.TruePredicateExtender}, Predicates: []tf.FitPredicate{tf.TruePredicateExtender},
}, },
{ {
ExtenderName: "FakeExtender2", ExtenderName: "FakeExtender2",
Predicates: []st.FitPredicate{st.Node1PredicateExtender}, Predicates: []tf.FitPredicate{tf.Node1PredicateExtender},
}, },
}, },
registerPlugin: st.RegisterPluginAsExtensions(noderesources.Name, nodeResourcesFitFunc, "Filter", "PreFilter"), registerPlugin: tf.RegisterPluginAsExtensions(noderesources.Name, nodeResourcesFitFunc, "Filter", "PreFilter"),
want: framework.NewPostFilterResultWithNominatedNode("node1"), want: framework.NewPostFilterResultWithNominatedNode("node1"),
expectedPods: []string{"p1.1", "p1.2"}, expectedPods: []string{"p1.1", "p1.2"},
}, },
@ -1586,13 +1587,13 @@ func TestPreempt(t *testing.T) {
st.MakePod().Name("p2.1").UID("p2.1").Namespace(v1.NamespaceDefault).Node("node2").Priority(midPriority).Req(largeRes).Obj(), st.MakePod().Name("p2.1").UID("p2.1").Namespace(v1.NamespaceDefault).Node("node2").Priority(midPriority).Req(largeRes).Obj(),
}, },
nodeNames: []string{"node1", "node2", "node3"}, nodeNames: []string{"node1", "node2", "node3"},
extenders: []*st.FakeExtender{ extenders: []*tf.FakeExtender{
{ {
ExtenderName: "FakeExtender1", ExtenderName: "FakeExtender1",
Predicates: []st.FitPredicate{st.FalsePredicateExtender}, Predicates: []tf.FitPredicate{tf.FalsePredicateExtender},
}, },
}, },
registerPlugin: st.RegisterPluginAsExtensions(noderesources.Name, nodeResourcesFitFunc, "Filter", "PreFilter"), registerPlugin: tf.RegisterPluginAsExtensions(noderesources.Name, nodeResourcesFitFunc, "Filter", "PreFilter"),
want: nil, want: nil,
expectedPods: []string{}, expectedPods: []string{},
}, },
@ -1605,18 +1606,18 @@ func TestPreempt(t *testing.T) {
st.MakePod().Name("p2.1").UID("p2.1").Namespace(v1.NamespaceDefault).Node("node2").Priority(midPriority).Req(largeRes).Obj(), st.MakePod().Name("p2.1").UID("p2.1").Namespace(v1.NamespaceDefault).Node("node2").Priority(midPriority).Req(largeRes).Obj(),
}, },
nodeNames: []string{"node1", "node2", "node3"}, nodeNames: []string{"node1", "node2", "node3"},
extenders: []*st.FakeExtender{ extenders: []*tf.FakeExtender{
{ {
Predicates: []st.FitPredicate{st.ErrorPredicateExtender}, Predicates: []tf.FitPredicate{tf.ErrorPredicateExtender},
Ignorable: true, Ignorable: true,
ExtenderName: "FakeExtender1", ExtenderName: "FakeExtender1",
}, },
{ {
Predicates: []st.FitPredicate{st.Node1PredicateExtender}, Predicates: []tf.FitPredicate{tf.Node1PredicateExtender},
ExtenderName: "FakeExtender2", ExtenderName: "FakeExtender2",
}, },
}, },
registerPlugin: st.RegisterPluginAsExtensions(noderesources.Name, nodeResourcesFitFunc, "Filter", "PreFilter"), registerPlugin: tf.RegisterPluginAsExtensions(noderesources.Name, nodeResourcesFitFunc, "Filter", "PreFilter"),
want: framework.NewPostFilterResultWithNominatedNode("node1"), want: framework.NewPostFilterResultWithNominatedNode("node1"),
expectedPods: []string{"p1.1", "p1.2"}, expectedPods: []string{"p1.1", "p1.2"},
}, },
@ -1629,18 +1630,18 @@ func TestPreempt(t *testing.T) {
st.MakePod().Name("p2.1").UID("p2.1").Namespace(v1.NamespaceDefault).Node("node2").Priority(midPriority).Req(largeRes).Obj(), st.MakePod().Name("p2.1").UID("p2.1").Namespace(v1.NamespaceDefault).Node("node2").Priority(midPriority).Req(largeRes).Obj(),
}, },
nodeNames: []string{"node1", "node2"}, nodeNames: []string{"node1", "node2"},
extenders: []*st.FakeExtender{ extenders: []*tf.FakeExtender{
{ {
ExtenderName: "FakeExtender1", ExtenderName: "FakeExtender1",
Predicates: []st.FitPredicate{st.Node1PredicateExtender}, Predicates: []tf.FitPredicate{tf.Node1PredicateExtender},
UnInterested: true, UnInterested: true,
}, },
{ {
ExtenderName: "FakeExtender2", ExtenderName: "FakeExtender2",
Predicates: []st.FitPredicate{st.TruePredicateExtender}, Predicates: []tf.FitPredicate{tf.TruePredicateExtender},
}, },
}, },
registerPlugin: st.RegisterPluginAsExtensions(noderesources.Name, nodeResourcesFitFunc, "Filter", "PreFilter"), registerPlugin: tf.RegisterPluginAsExtensions(noderesources.Name, nodeResourcesFitFunc, "Filter", "PreFilter"),
// sum of priorities of all victims on node1 is larger than node2, node2 is chosen. // sum of priorities of all victims on node1 is larger than node2, node2 is chosen.
want: framework.NewPostFilterResultWithNominatedNode("node2"), want: framework.NewPostFilterResultWithNominatedNode("node2"),
expectedPods: []string{"p2.1"}, expectedPods: []string{"p2.1"},
@ -1655,7 +1656,7 @@ func TestPreempt(t *testing.T) {
st.MakePod().Name("p3.1").UID("p3.1").Namespace(v1.NamespaceDefault).Node("node3").Priority(midPriority).Req(mediumRes).Obj(), st.MakePod().Name("p3.1").UID("p3.1").Namespace(v1.NamespaceDefault).Node("node3").Priority(midPriority).Req(mediumRes).Obj(),
}, },
nodeNames: []string{"node1", "node2", "node3"}, nodeNames: []string{"node1", "node2", "node3"},
registerPlugin: st.RegisterPluginAsExtensions(noderesources.Name, nodeResourcesFitFunc, "Filter", "PreFilter"), registerPlugin: tf.RegisterPluginAsExtensions(noderesources.Name, nodeResourcesFitFunc, "Filter", "PreFilter"),
want: nil, want: nil,
expectedPods: nil, expectedPods: nil,
}, },
@ -1669,7 +1670,7 @@ func TestPreempt(t *testing.T) {
st.MakePod().Name("p3.1").UID("p3.1").Namespace(v1.NamespaceDefault).Node("node3").Priority(midPriority).Req(mediumRes).Obj(), st.MakePod().Name("p3.1").UID("p3.1").Namespace(v1.NamespaceDefault).Node("node3").Priority(midPriority).Req(mediumRes).Obj(),
}, },
nodeNames: []string{"node1", "node2", "node3"}, nodeNames: []string{"node1", "node2", "node3"},
registerPlugin: st.RegisterPluginAsExtensions(noderesources.Name, nodeResourcesFitFunc, "Filter", "PreFilter"), registerPlugin: tf.RegisterPluginAsExtensions(noderesources.Name, nodeResourcesFitFunc, "Filter", "PreFilter"),
want: framework.NewPostFilterResultWithNominatedNode("node1"), want: framework.NewPostFilterResultWithNominatedNode("node1"),
expectedPods: []string{"p1.1", "p1.2"}, expectedPods: []string{"p1.1", "p1.2"},
}, },
@ -1730,12 +1731,12 @@ func TestPreempt(t *testing.T) {
extender.CachedNodeNameToInfo = cachedNodeInfoMap extender.CachedNodeNameToInfo = cachedNodeInfoMap
extenders = append(extenders, extender) extenders = append(extenders, extender)
} }
fwk, err := st.NewFramework( fwk, err := tf.NewFramework(
ctx, ctx,
[]st.RegisterPluginFunc{ []tf.RegisterPluginFunc{
test.registerPlugin, test.registerPlugin,
st.RegisterQueueSortPlugin(queuesort.Name, queuesort.New), tf.RegisterQueueSortPlugin(queuesort.Name, queuesort.New),
st.RegisterBindPlugin(defaultbinder.Name, defaultbinder.New), tf.RegisterBindPlugin(defaultbinder.Name, defaultbinder.New),
}, },
"", "",
frameworkruntime.WithClientSet(client), frameworkruntime.WithClientSet(client),

18
pkg/scheduler/framework/plugins/nodevolumelimits/csi_test.go
View File

@ -33,8 +33,8 @@ import (
csitrans "k8s.io/csi-translation-lib" csitrans "k8s.io/csi-translation-lib"
csilibplugins "k8s.io/csi-translation-lib/plugins" csilibplugins "k8s.io/csi-translation-lib/plugins"
"k8s.io/kubernetes/pkg/scheduler/framework" "k8s.io/kubernetes/pkg/scheduler/framework"
fakeframework "k8s.io/kubernetes/pkg/scheduler/framework/fake"
st "k8s.io/kubernetes/pkg/scheduler/testing" st "k8s.io/kubernetes/pkg/scheduler/testing"
tf "k8s.io/kubernetes/pkg/scheduler/testing/framework"
volumeutil "k8s.io/kubernetes/pkg/volume/util" volumeutil "k8s.io/kubernetes/pkg/volume/util"
"k8s.io/kubernetes/test/utils/ktesting" "k8s.io/kubernetes/test/utils/ktesting"
"k8s.io/utils/pointer" "k8s.io/utils/pointer"
@ -641,8 +641,8 @@ func TestCSILimits(t *testing.T) {
} }
} }
func getFakeCSIPVLister(volumeName string, driverNames ...string) fakeframework.PersistentVolumeLister { func getFakeCSIPVLister(volumeName string, driverNames ...string) tf.PersistentVolumeLister {
pvLister := fakeframework.PersistentVolumeLister{} pvLister := tf.PersistentVolumeLister{}
for _, driver := range driverNames { for _, driver := range driverNames {
for j := 0; j < 4; j++ { for j := 0; j < 4; j++ {
volumeHandle := fmt.Sprintf("%s-%s-%d", volumeName, driver, j) volumeHandle := fmt.Sprintf("%s-%s-%d", volumeName, driver, j)
@ -686,8 +686,8 @@ func getFakeCSIPVLister(volumeName string, driverNames ...string) fakeframework.
return pvLister return pvLister
} }
func getFakeCSIPVCLister(volumeName, scName string, driverNames ...string) fakeframework.PersistentVolumeClaimLister { func getFakeCSIPVCLister(volumeName, scName string, driverNames ...string) tf.PersistentVolumeClaimLister {
pvcLister := fakeframework.PersistentVolumeClaimLister{} pvcLister := tf.PersistentVolumeClaimLister{}
for _, driver := range driverNames { for _, driver := range driverNames {
for j := 0; j < 4; j++ { for j := 0; j < 4; j++ {
v := fmt.Sprintf("%s-%s-%d", volumeName, driver, j) v := fmt.Sprintf("%s-%s-%d", volumeName, driver, j)
@ -729,8 +729,8 @@ func enableMigrationOnNode(csiNode *storagev1.CSINode, pluginName string) {
csiNode.Annotations = nodeInfoAnnotations csiNode.Annotations = nodeInfoAnnotations
} }
func getFakeCSIStorageClassLister(scName, provisionerName string) fakeframework.StorageClassLister { func getFakeCSIStorageClassLister(scName, provisionerName string) tf.StorageClassLister {
return fakeframework.StorageClassLister{ return tf.StorageClassLister{
{ {
ObjectMeta: metav1.ObjectMeta{Name: scName}, ObjectMeta: metav1.ObjectMeta{Name: scName},
Provisioner: provisionerName, Provisioner: provisionerName,
@ -738,8 +738,8 @@ func getFakeCSIStorageClassLister(scName, provisionerName string) fakeframework.
} }
} }
func getFakeCSINodeLister(csiNode *storagev1.CSINode) fakeframework.CSINodeLister { func getFakeCSINodeLister(csiNode *storagev1.CSINode) tf.CSINodeLister {
csiNodeLister := fakeframework.CSINodeLister{} csiNodeLister := tf.CSINodeLister{}
if csiNode != nil { if csiNode != nil {
csiNodeLister = append(csiNodeLister, *csiNode.DeepCopy()) csiNodeLister = append(csiNodeLister, *csiNode.DeepCopy())
} }

10
pkg/scheduler/framework/plugins/nodevolumelimits/non_csi_test.go
View File

@ -29,9 +29,9 @@ import (
metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
csilibplugins "k8s.io/csi-translation-lib/plugins" csilibplugins "k8s.io/csi-translation-lib/plugins"
"k8s.io/kubernetes/pkg/scheduler/framework" "k8s.io/kubernetes/pkg/scheduler/framework"
fakeframework "k8s.io/kubernetes/pkg/scheduler/framework/fake"
"k8s.io/kubernetes/pkg/scheduler/framework/plugins/feature" "k8s.io/kubernetes/pkg/scheduler/framework/plugins/feature"
st "k8s.io/kubernetes/pkg/scheduler/testing" st "k8s.io/kubernetes/pkg/scheduler/testing"
tf "k8s.io/kubernetes/pkg/scheduler/testing/framework"
"k8s.io/utils/pointer" "k8s.io/utils/pointer"
) )
@ -974,8 +974,8 @@ func TestGetMaxVols(t *testing.T) {
} }
} }
func getFakePVCLister(filterName string) fakeframework.PersistentVolumeClaimLister { func getFakePVCLister(filterName string) tf.PersistentVolumeClaimLister {
return fakeframework.PersistentVolumeClaimLister{ return tf.PersistentVolumeClaimLister{
{ {
ObjectMeta: metav1.ObjectMeta{Name: "some" + filterName + "Vol"}, ObjectMeta: metav1.ObjectMeta{Name: "some" + filterName + "Vol"},
Spec: v1.PersistentVolumeClaimSpec{ Spec: v1.PersistentVolumeClaimSpec{
@ -1035,8 +1035,8 @@ func getFakePVCLister(filterName string) fakeframework.PersistentVolumeClaimList
} }
} }
func getFakePVLister(filterName string) fakeframework.PersistentVolumeLister { func getFakePVLister(filterName string) tf.PersistentVolumeLister {
return fakeframework.PersistentVolumeLister{ return tf.PersistentVolumeLister{
{ {
ObjectMeta: metav1.ObjectMeta{Name: "some" + filterName + "Vol"}, ObjectMeta: metav1.ObjectMeta{Name: "some" + filterName + "Vol"},
Spec: v1.PersistentVolumeSpec{ Spec: v1.PersistentVolumeSpec{

16
pkg/scheduler/framework/plugins/volumezone/volume_zone_test.go
View File

@ -29,10 +29,10 @@ import (
"k8s.io/klog/v2/ktesting" "k8s.io/klog/v2/ktesting"
"k8s.io/kubernetes/pkg/scheduler/apis/config" "k8s.io/kubernetes/pkg/scheduler/apis/config"
"k8s.io/kubernetes/pkg/scheduler/framework" "k8s.io/kubernetes/pkg/scheduler/framework"
fakeframework "k8s.io/kubernetes/pkg/scheduler/framework/fake"
plugintesting "k8s.io/kubernetes/pkg/scheduler/framework/plugins/testing" plugintesting "k8s.io/kubernetes/pkg/scheduler/framework/plugins/testing"
"k8s.io/kubernetes/pkg/scheduler/internal/cache" "k8s.io/kubernetes/pkg/scheduler/internal/cache"
st "k8s.io/kubernetes/pkg/scheduler/testing" st "k8s.io/kubernetes/pkg/scheduler/testing"
tf "k8s.io/kubernetes/pkg/scheduler/testing/framework"
) )
func createPodWithVolume(pod, pv, pvc string) *v1.Pod { func createPodWithVolume(pod, pv, pvc string) *v1.Pod {
@ -40,7 +40,7 @@ func createPodWithVolume(pod, pv, pvc string) *v1.Pod {
} }
func TestSingleZone(t *testing.T) { func TestSingleZone(t *testing.T) {
pvLister := fakeframework.PersistentVolumeLister{ pvLister := tf.PersistentVolumeLister{
{ {
ObjectMeta: metav1.ObjectMeta{Name: "Vol_1", Labels: map[string]string{v1.LabelFailureDomainBetaZone: "us-west1-a"}}, ObjectMeta: metav1.ObjectMeta{Name: "Vol_1", Labels: map[string]string{v1.LabelFailureDomainBetaZone: "us-west1-a"}},
}, },
@ -61,7 +61,7 @@ func TestSingleZone(t *testing.T) {
}, },
} }
pvcLister := fakeframework.PersistentVolumeClaimLister{ pvcLister := tf.PersistentVolumeClaimLister{
{ {
ObjectMeta: metav1.ObjectMeta{Name: "PVC_1", Namespace: "default"}, ObjectMeta: metav1.ObjectMeta{Name: "PVC_1", Namespace: "default"},
Spec: v1.PersistentVolumeClaimSpec{VolumeName: "Vol_1"}, Spec: v1.PersistentVolumeClaimSpec{VolumeName: "Vol_1"},
@ -283,7 +283,7 @@ func TestSingleZone(t *testing.T) {
} }
func TestMultiZone(t *testing.T) { func TestMultiZone(t *testing.T) {
pvLister := fakeframework.PersistentVolumeLister{ pvLister := tf.PersistentVolumeLister{
{ {
ObjectMeta: metav1.ObjectMeta{Name: "Vol_1", Labels: map[string]string{v1.LabelFailureDomainBetaZone: "us-west1-a"}}, ObjectMeta: metav1.ObjectMeta{Name: "Vol_1", Labels: map[string]string{v1.LabelFailureDomainBetaZone: "us-west1-a"}},
}, },
@ -301,7 +301,7 @@ func TestMultiZone(t *testing.T) {
}, },
} }
pvcLister := fakeframework.PersistentVolumeClaimLister{ pvcLister := tf.PersistentVolumeClaimLister{
{ {
ObjectMeta: metav1.ObjectMeta{Name: "PVC_1", Namespace: "default"}, ObjectMeta: metav1.ObjectMeta{Name: "PVC_1", Namespace: "default"},
Spec: v1.PersistentVolumeClaimSpec{VolumeName: "Vol_1"}, Spec: v1.PersistentVolumeClaimSpec{VolumeName: "Vol_1"},
@ -423,7 +423,7 @@ func TestWithBinding(t *testing.T) {
classImmediate = "Class_Immediate" classImmediate = "Class_Immediate"
) )
scLister := fakeframework.StorageClassLister{ scLister := tf.StorageClassLister{
{ {
ObjectMeta: metav1.ObjectMeta{Name: classImmediate}, ObjectMeta: metav1.ObjectMeta{Name: classImmediate},
}, },
@ -433,13 +433,13 @@ func TestWithBinding(t *testing.T) {
}, },
} }
pvLister := fakeframework.PersistentVolumeLister{ pvLister := tf.PersistentVolumeLister{
{ {
ObjectMeta: metav1.ObjectMeta{Name: "Vol_1", Labels: map[string]string{v1.LabelFailureDomainBetaZone: "us-west1-a"}}, ObjectMeta: metav1.ObjectMeta{Name: "Vol_1", Labels: map[string]string{v1.LabelFailureDomainBetaZone: "us-west1-a"}},
}, },
} }
pvcLister := fakeframework.PersistentVolumeClaimLister{ pvcLister := tf.PersistentVolumeClaimLister{
{ {
ObjectMeta: metav1.ObjectMeta{Name: "PVC_1", Namespace: "default"}, ObjectMeta: metav1.ObjectMeta{Name: "PVC_1", Namespace: "default"},
Spec: v1.PersistentVolumeClaimSpec{VolumeName: "Vol_1"}, Spec: v1.PersistentVolumeClaimSpec{VolumeName: "Vol_1"},

9
pkg/scheduler/framework/preemption/preemption_test.go
View File

@ -48,6 +48,7 @@ import (
internalcache "k8s.io/kubernetes/pkg/scheduler/internal/cache" internalcache "k8s.io/kubernetes/pkg/scheduler/internal/cache"
internalqueue "k8s.io/kubernetes/pkg/scheduler/internal/queue" internalqueue "k8s.io/kubernetes/pkg/scheduler/internal/queue"
st "k8s.io/kubernetes/pkg/scheduler/testing" st "k8s.io/kubernetes/pkg/scheduler/testing"
tf "k8s.io/kubernetes/pkg/scheduler/testing/framework"
) )
var ( var (
@ -268,9 +269,9 @@ func TestDryRunPreemption(t *testing.T) {
for _, tt := range tests { for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) { t.Run(tt.name, func(t *testing.T) {
logger, _ := ktesting.NewTestContext(t) logger, _ := ktesting.NewTestContext(t)
registeredPlugins := append([]st.RegisterPluginFunc{ registeredPlugins := append([]tf.RegisterPluginFunc{
st.RegisterQueueSortPlugin(queuesort.Name, queuesort.New)}, tf.RegisterQueueSortPlugin(queuesort.Name, queuesort.New)},
st.RegisterBindPlugin(defaultbinder.Name, defaultbinder.New), tf.RegisterBindPlugin(defaultbinder.Name, defaultbinder.New),
) )
var objs []runtime.Object var objs []runtime.Object
for _, p := range append(tt.testPods, tt.initPods...) { for _, p := range append(tt.testPods, tt.initPods...) {
@ -284,7 +285,7 @@ func TestDryRunPreemption(t *testing.T) {
_, ctx := ktesting.NewTestContext(t) _, ctx := ktesting.NewTestContext(t)
ctx, cancel := context.WithCancel(ctx) ctx, cancel := context.WithCancel(ctx)
defer cancel() defer cancel()
fwk, err := st.NewFramework( fwk, err := tf.NewFramework(
ctx, ctx,
registeredPlugins, "", registeredPlugins, "",
frameworkruntime.WithPodNominator(internalqueue.NewPodNominator(informerFactory.Core().V1().Pods().Lister())), frameworkruntime.WithPodNominator(internalqueue.NewPodNominator(informerFactory.Core().V1().Pods().Lister())),

523
pkg/scheduler/schedule_one_test.go
View File

File diff suppressed because it is too large Load Diff

19
pkg/scheduler/scheduler_test.go
View File

@ -52,6 +52,7 @@ import (
internalqueue "k8s.io/kubernetes/pkg/scheduler/internal/queue" internalqueue "k8s.io/kubernetes/pkg/scheduler/internal/queue"
"k8s.io/kubernetes/pkg/scheduler/profile" "k8s.io/kubernetes/pkg/scheduler/profile"
st "k8s.io/kubernetes/pkg/scheduler/testing" st "k8s.io/kubernetes/pkg/scheduler/testing"
tf "k8s.io/kubernetes/pkg/scheduler/testing/framework"
testingclock "k8s.io/utils/clock/testing" testingclock "k8s.io/utils/clock/testing"
"k8s.io/utils/pointer" "k8s.io/utils/pointer"
) )
@ -498,12 +499,12 @@ func getPodFromPriorityQueue(queue *internalqueue.PriorityQueue, pod *v1.Pod) *v
func initScheduler(ctx context.Context, cache internalcache.Cache, queue internalqueue.SchedulingQueue, func initScheduler(ctx context.Context, cache internalcache.Cache, queue internalqueue.SchedulingQueue,
client kubernetes.Interface, informerFactory informers.SharedInformerFactory) (*Scheduler, framework.Framework, error) { client kubernetes.Interface, informerFactory informers.SharedInformerFactory) (*Scheduler, framework.Framework, error) {
logger := klog.FromContext(ctx) logger := klog.FromContext(ctx)
registerPluginFuncs := []st.RegisterPluginFunc{ registerPluginFuncs := []tf.RegisterPluginFunc{
st.RegisterQueueSortPlugin(queuesort.Name, queuesort.New), tf.RegisterQueueSortPlugin(queuesort.Name, queuesort.New),
st.RegisterBindPlugin(defaultbinder.Name, defaultbinder.New), tf.RegisterBindPlugin(defaultbinder.Name, defaultbinder.New),
} }
eventBroadcaster := events.NewBroadcaster(&events.EventSinkImpl{Interface: client.EventsV1()}) eventBroadcaster := events.NewBroadcaster(&events.EventSinkImpl{Interface: client.EventsV1()})
fwk, err := st.NewFramework(ctx, fwk, err := tf.NewFramework(ctx,
registerPluginFuncs, registerPluginFuncs,
testSchedulerName, testSchedulerName,
frameworkruntime.WithClientSet(client), frameworkruntime.WithClientSet(client),
@ -593,22 +594,22 @@ func TestInitPluginsWithIndexers(t *testing.T) {
t.Run(tt.name, func(t *testing.T) { t.Run(tt.name, func(t *testing.T) {
fakeInformerFactory := NewInformerFactory(&fake.Clientset{}, 0*time.Second) fakeInformerFactory := NewInformerFactory(&fake.Clientset{}, 0*time.Second)
var registerPluginFuncs []st.RegisterPluginFunc var registerPluginFuncs []tf.RegisterPluginFunc
for name, entrypoint := range tt.entrypoints { for name, entrypoint := range tt.entrypoints {
registerPluginFuncs = append(registerPluginFuncs, registerPluginFuncs = append(registerPluginFuncs,
// anything supported by TestPlugin is fine // anything supported by TestPlugin is fine
st.RegisterFilterPlugin(name, entrypoint), tf.RegisterFilterPlugin(name, entrypoint),
) )
} }
// we always need this // we always need this
registerPluginFuncs = append(registerPluginFuncs, registerPluginFuncs = append(registerPluginFuncs,
st.RegisterQueueSortPlugin(queuesort.Name, queuesort.New), tf.RegisterQueueSortPlugin(queuesort.Name, queuesort.New),
st.RegisterBindPlugin(defaultbinder.Name, defaultbinder.New), tf.RegisterBindPlugin(defaultbinder.Name, defaultbinder.New),
) )
_, ctx := ktesting.NewTestContext(t) _, ctx := ktesting.NewTestContext(t)
ctx, cancel := context.WithCancel(ctx) ctx, cancel := context.WithCancel(ctx)
defer cancel() defer cancel()
_, err := st.NewFramework(ctx, registerPluginFuncs, "test", frameworkruntime.WithInformerFactory(fakeInformerFactory)) _, err := tf.NewFramework(ctx, registerPluginFuncs, "test", frameworkruntime.WithInformerFactory(fakeInformerFactory))
if len(tt.wantErr) > 0 { if len(tt.wantErr) > 0 {
if err == nil || !strings.Contains(err.Error(), tt.wantErr) { if err == nil || !strings.Contains(err.Error(), tt.wantErr) {

2
pkg/scheduler/testing/fake_extender.go → pkg/scheduler/testing/framework/fake_extender.go
View File

@ -14,7 +14,7 @@ See the License for the specific language governing permissions and
limitations under the License. limitations under the License.
*/ */
package testing package framework
import ( import (
"context" "context"

2
pkg/scheduler/framework/fake/listers.go → pkg/scheduler/testing/framework/fake_listers.go
View File

@ -14,7 +14,7 @@ See the License for the specific language governing permissions and
limitations under the License. limitations under the License.
*/ */
package fake package framework
import ( import (
"fmt" "fmt"

2
pkg/scheduler/testing/fake_plugins.go → pkg/scheduler/testing/framework/fake_plugins.go
View File

@ -14,7 +14,7 @@ See the License for the specific language governing permissions and
limitations under the License. limitations under the License.
*/ */
package testing package framework
import ( import (
"context" "context"

2
pkg/scheduler/testing/framework_helpers.go → pkg/scheduler/testing/framework/framework_helpers.go
View File

@ -14,7 +14,7 @@ See the License for the specific language governing permissions and
limitations under the License. limitations under the License.
*/ */
package testing package framework
import ( import (
"context" "context"