github/kubernetes
1
0
Fork 0
mirror of https://github.com/k3s-io/kubernetes.git synced 2025-08-05 10:19:50 +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"
csitrans "k8s.io/csi-translation-lib"
"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/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")
if err != nil {
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
pvLister := fakeframework.PersistentVolumeLister{
pvLister := tf.PersistentVolumeLister{
{
ObjectMeta: metav1.ObjectMeta{Name: migratedVolume},
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"},
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"
schedulerapi "k8s.io/kubernetes/pkg/scheduler/apis/config"
"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/queuesort"
"k8s.io/kubernetes/pkg/scheduler/framework/runtime"
internalcache "k8s.io/kubernetes/pkg/scheduler/internal/cache"
internalqueue "k8s.io/kubernetes/pkg/scheduler/internal/queue"
st "k8s.io/kubernetes/pkg/scheduler/testing"
tf "k8s.io/kubernetes/pkg/scheduler/testing/framework"
)
func TestSchedulerWithExtenders(t *testing.T) {
tests := []struct {
name string
registerPlugins []st.RegisterPluginFunc
extenders []st.FakeExtender
registerPlugins []tf.RegisterPluginFunc
extenders []tf.FakeExtender
nodes []string
expectedResult ScheduleResult
expectsErr bool
}{
{
registerPlugins: []st.RegisterPluginFunc{
st.RegisterFilterPlugin("TrueFilter", st.NewTrueFilterPlugin),
st.RegisterQueueSortPlugin(queuesort.Name, queuesort.New),
st.RegisterBindPlugin(defaultbinder.Name, defaultbinder.New),
registerPlugins: []tf.RegisterPluginFunc{
tf.RegisterFilterPlugin("TrueFilter", tf.NewTrueFilterPlugin),
tf.RegisterQueueSortPlugin(queuesort.Name, queuesort.New),
tf.RegisterBindPlugin(defaultbinder.Name, defaultbinder.New),
},
extenders: []st.FakeExtender{
extenders: []tf.FakeExtender{
{
ExtenderName: "FakeExtender1",
Predicates: []st.FitPredicate{st.TruePredicateExtender},
Predicates: []tf.FitPredicate{tf.TruePredicateExtender},
},
{
ExtenderName: "FakeExtender2",
Predicates: []st.FitPredicate{st.ErrorPredicateExtender},
Predicates: []tf.FitPredicate{tf.ErrorPredicateExtender},
},
},
nodes: []string{"node1", "node2"},
@ -70,19 +70,19 @@ func TestSchedulerWithExtenders(t *testing.T) {
name: "test 1",
},
{
registerPlugins: []st.RegisterPluginFunc{
st.RegisterFilterPlugin("TrueFilter", st.NewTrueFilterPlugin),
st.RegisterQueueSortPlugin(queuesort.Name, queuesort.New),
st.RegisterBindPlugin(defaultbinder.Name, defaultbinder.New),
registerPlugins: []tf.RegisterPluginFunc{
tf.RegisterFilterPlugin("TrueFilter", tf.NewTrueFilterPlugin),
tf.RegisterQueueSortPlugin(queuesort.Name, queuesort.New),
tf.RegisterBindPlugin(defaultbinder.Name, defaultbinder.New),
},
extenders: []st.FakeExtender{
extenders: []tf.FakeExtender{
{
ExtenderName: "FakeExtender1",
Predicates: []st.FitPredicate{st.TruePredicateExtender},
Predicates: []tf.FitPredicate{tf.TruePredicateExtender},
},
{
ExtenderName: "FakeExtender2",
Predicates: []st.FitPredicate{st.FalsePredicateExtender},
Predicates: []tf.FitPredicate{tf.FalsePredicateExtender},
},
},
nodes: []string{"node1", "node2"},
@ -90,19 +90,19 @@ func TestSchedulerWithExtenders(t *testing.T) {
name: "test 2",
},
{
registerPlugins: []st.RegisterPluginFunc{
st.RegisterFilterPlugin("TrueFilter", st.NewTrueFilterPlugin),
st.RegisterQueueSortPlugin(queuesort.Name, queuesort.New),
st.RegisterBindPlugin(defaultbinder.Name, defaultbinder.New),
registerPlugins: []tf.RegisterPluginFunc{
tf.RegisterFilterPlugin("TrueFilter", tf.NewTrueFilterPlugin),
tf.RegisterQueueSortPlugin(queuesort.Name, queuesort.New),
tf.RegisterBindPlugin(defaultbinder.Name, defaultbinder.New),
},
extenders: []st.FakeExtender{
extenders: []tf.FakeExtender{
{
ExtenderName: "FakeExtender1",
Predicates: []st.FitPredicate{st.TruePredicateExtender},
Predicates: []tf.FitPredicate{tf.TruePredicateExtender},
},
{
ExtenderName: "FakeExtender2",
Predicates: []st.FitPredicate{st.Node1PredicateExtender},
Predicates: []tf.FitPredicate{tf.Node1PredicateExtender},
},
},
nodes: []string{"node1", "node2"},
@ -114,19 +114,19 @@ func TestSchedulerWithExtenders(t *testing.T) {
name: "test 3",
},
{
registerPlugins: []st.RegisterPluginFunc{
st.RegisterFilterPlugin("TrueFilter", st.NewTrueFilterPlugin),
st.RegisterQueueSortPlugin(queuesort.Name, queuesort.New),
st.RegisterBindPlugin(defaultbinder.Name, defaultbinder.New),
registerPlugins: []tf.RegisterPluginFunc{
tf.RegisterFilterPlugin("TrueFilter", tf.NewTrueFilterPlugin),
tf.RegisterQueueSortPlugin(queuesort.Name, queuesort.New),
tf.RegisterBindPlugin(defaultbinder.Name, defaultbinder.New),
},
extenders: []st.FakeExtender{
extenders: []tf.FakeExtender{
{
ExtenderName: "FakeExtender1",
Predicates: []st.FitPredicate{st.Node2PredicateExtender},
Predicates: []tf.FitPredicate{tf.Node2PredicateExtender},
},
{
ExtenderName: "FakeExtender2",
Predicates: []st.FitPredicate{st.Node1PredicateExtender},
Predicates: []tf.FitPredicate{tf.Node1PredicateExtender},
},
},
nodes: []string{"node1", "node2"},
@ -134,16 +134,16 @@ func TestSchedulerWithExtenders(t *testing.T) {
name: "test 4",
},
{
registerPlugins: []st.RegisterPluginFunc{
st.RegisterFilterPlugin("TrueFilter", st.NewTrueFilterPlugin),
st.RegisterQueueSortPlugin(queuesort.Name, queuesort.New),
st.RegisterBindPlugin(defaultbinder.Name, defaultbinder.New),
registerPlugins: []tf.RegisterPluginFunc{
tf.RegisterFilterPlugin("TrueFilter", tf.NewTrueFilterPlugin),
tf.RegisterQueueSortPlugin(queuesort.Name, queuesort.New),
tf.RegisterBindPlugin(defaultbinder.Name, defaultbinder.New),
},
extenders: []st.FakeExtender{
extenders: []tf.FakeExtender{
{
ExtenderName: "FakeExtender1",
Predicates: []st.FitPredicate{st.TruePredicateExtender},
Prioritizers: []st.PriorityConfig{{Function: st.ErrorPrioritizerExtender, Weight: 10}},
Predicates: []tf.FitPredicate{tf.TruePredicateExtender},
Prioritizers: []tf.PriorityConfig{{Function: tf.ErrorPrioritizerExtender, Weight: 10}},
Weight: 1,
},
},
@ -156,22 +156,22 @@ func TestSchedulerWithExtenders(t *testing.T) {
name: "test 5",
},
{
registerPlugins: []st.RegisterPluginFunc{
st.RegisterFilterPlugin("TrueFilter", st.NewTrueFilterPlugin),
st.RegisterQueueSortPlugin(queuesort.Name, queuesort.New),
st.RegisterBindPlugin(defaultbinder.Name, defaultbinder.New),
registerPlugins: []tf.RegisterPluginFunc{
tf.RegisterFilterPlugin("TrueFilter", tf.NewTrueFilterPlugin),
tf.RegisterQueueSortPlugin(queuesort.Name, queuesort.New),
tf.RegisterBindPlugin(defaultbinder.Name, defaultbinder.New),
},
extenders: []st.FakeExtender{
extenders: []tf.FakeExtender{
{
ExtenderName: "FakeExtender1",
Predicates: []st.FitPredicate{st.TruePredicateExtender},
Prioritizers: []st.PriorityConfig{{Function: st.Node1PrioritizerExtender, Weight: 10}},
Predicates: []tf.FitPredicate{tf.TruePredicateExtender},
Prioritizers: []tf.PriorityConfig{{Function: tf.Node1PrioritizerExtender, Weight: 10}},
Weight: 1,
},
{
ExtenderName: "FakeExtender2",
Predicates: []st.FitPredicate{st.TruePredicateExtender},
Prioritizers: []st.PriorityConfig{{Function: st.Node2PrioritizerExtender, Weight: 10}},
Predicates: []tf.FitPredicate{tf.TruePredicateExtender},
Prioritizers: []tf.PriorityConfig{{Function: tf.Node2PrioritizerExtender, Weight: 10}},
Weight: 5,
},
},
@ -184,17 +184,17 @@ func TestSchedulerWithExtenders(t *testing.T) {
name: "test 6",
},
{
registerPlugins: []st.RegisterPluginFunc{
st.RegisterFilterPlugin("TrueFilter", st.NewTrueFilterPlugin),
st.RegisterScorePlugin("Node2Prioritizer", st.NewNode2PrioritizerPlugin(), 20),
st.RegisterQueueSortPlugin(queuesort.Name, queuesort.New),
st.RegisterBindPlugin(defaultbinder.Name, defaultbinder.New),
registerPlugins: []tf.RegisterPluginFunc{
tf.RegisterFilterPlugin("TrueFilter", tf.NewTrueFilterPlugin),
tf.RegisterScorePlugin("Node2Prioritizer", tf.NewNode2PrioritizerPlugin(), 20),
tf.RegisterQueueSortPlugin(queuesort.Name, queuesort.New),
tf.RegisterBindPlugin(defaultbinder.Name, defaultbinder.New),
},
extenders: []st.FakeExtender{
extenders: []tf.FakeExtender{
{
ExtenderName: "FakeExtender1",
Predicates: []st.FitPredicate{st.TruePredicateExtender},
Prioritizers: []st.PriorityConfig{{Function: st.Node1PrioritizerExtender, Weight: 10}},
Predicates: []tf.FitPredicate{tf.TruePredicateExtender},
Prioritizers: []tf.PriorityConfig{{Function: tf.Node1PrioritizerExtender, Weight: 10}},
Weight: 1,
},
},
@ -214,17 +214,17 @@ func TestSchedulerWithExtenders(t *testing.T) {
// If scheduler sends the pod by mistake, the test would fail
// because of the errors from errorPredicateExtender and/or
// errorPrioritizerExtender.
registerPlugins: []st.RegisterPluginFunc{
st.RegisterFilterPlugin("TrueFilter", st.NewTrueFilterPlugin),
st.RegisterScorePlugin("Node2Prioritizer", st.NewNode2PrioritizerPlugin(), 1),
st.RegisterQueueSortPlugin(queuesort.Name, queuesort.New),
st.RegisterBindPlugin(defaultbinder.Name, defaultbinder.New),
registerPlugins: []tf.RegisterPluginFunc{
tf.RegisterFilterPlugin("TrueFilter", tf.NewTrueFilterPlugin),
tf.RegisterScorePlugin("Node2Prioritizer", tf.NewNode2PrioritizerPlugin(), 1),
tf.RegisterQueueSortPlugin(queuesort.Name, queuesort.New),
tf.RegisterBindPlugin(defaultbinder.Name, defaultbinder.New),
},
extenders: []st.FakeExtender{
extenders: []tf.FakeExtender{
{
ExtenderName: "FakeExtender1",
Predicates: []st.FitPredicate{st.ErrorPredicateExtender},
Prioritizers: []st.PriorityConfig{{Function: st.ErrorPrioritizerExtender, Weight: 10}},
Predicates: []tf.FitPredicate{tf.ErrorPredicateExtender},
Prioritizers: []tf.PriorityConfig{{Function: tf.ErrorPrioritizerExtender, Weight: 10}},
UnInterested: true,
},
},
@ -243,20 +243,20 @@ func TestSchedulerWithExtenders(t *testing.T) {
//
// If scheduler did not ignore the extender, the test would fail
// because of the errors from errorPredicateExtender.
registerPlugins: []st.RegisterPluginFunc{
st.RegisterFilterPlugin("TrueFilter", st.NewTrueFilterPlugin),
st.RegisterQueueSortPlugin(queuesort.Name, queuesort.New),
st.RegisterBindPlugin(defaultbinder.Name, defaultbinder.New),
registerPlugins: []tf.RegisterPluginFunc{
tf.RegisterFilterPlugin("TrueFilter", tf.NewTrueFilterPlugin),
tf.RegisterQueueSortPlugin(queuesort.Name, queuesort.New),
tf.RegisterBindPlugin(defaultbinder.Name, defaultbinder.New),
},
extenders: []st.FakeExtender{
extenders: []tf.FakeExtender{
{
ExtenderName: "FakeExtender1",
Predicates: []st.FitPredicate{st.ErrorPredicateExtender},
Predicates: []tf.FitPredicate{tf.ErrorPredicateExtender},
Ignorable: true,
},
{
ExtenderName: "FakeExtender2",
Predicates: []st.FitPredicate{st.Node1PredicateExtender},
Predicates: []tf.FitPredicate{tf.Node1PredicateExtender},
},
},
nodes: []string{"node1", "node2"},
@ -287,7 +287,7 @@ func TestSchedulerWithExtenders(t *testing.T) {
for _, name := range test.nodes {
cache.AddNode(logger, createNode(name))
}
fwk, err := st.NewFramework(
fwk, err := tf.NewFramework(
ctx,
test.registerPlugins, "",
runtime.WithClientSet(client),
@ -510,7 +510,7 @@ func TestConvertToVictims(t *testing.T) {
nodeInfo.AddPod(tt.podsInNodeList[i+2])
nodeInfoList = append(nodeInfoList, nodeInfo)
}
tt.nodeInfos = fake.NodeInfoLister(nodeInfoList)
tt.nodeInfos = tf.NodeInfoLister(nodeInfoList)
got, err := tt.httpExtender.convertToVictims(tt.nodeNameToMetaVictims, tt.nodeInfos)
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"
internalqueue "k8s.io/kubernetes/pkg/scheduler/internal/queue"
st "k8s.io/kubernetes/pkg/scheduler/testing"
tf "k8s.io/kubernetes/pkg/scheduler/testing/framework"
)
var (
@ -228,9 +229,9 @@ func TestPostFilter(t *testing.T) {
"node1": framework.NewStatus(framework.Unschedulable),
"node2": framework.NewStatus(framework.Unschedulable),
},
extender: &st.FakeExtender{
extender: &tf.FakeExtender{
ExtenderName: "FakeExtender1",
Predicates: []st.FitPredicate{st.Node1PredicateExtender},
Predicates: []tf.FitPredicate{tf.Node1PredicateExtender},
},
wantResult: framework.NewPostFilterResultWithNominatedNode("node1"),
wantStatus: framework.NewStatus(framework.Success),
@ -342,11 +343,11 @@ func TestPostFilter(t *testing.T) {
podInformer.GetStore().Add(tt.pods[i])
}
// Register NodeResourceFit as the Filter & PreFilter plugin.
registeredPlugins := []st.RegisterPluginFunc{
st.RegisterQueueSortPlugin(queuesort.Name, queuesort.New),
st.RegisterPluginAsExtensions(noderesources.Name, nodeResourcesFitFunc, "Filter", "PreFilter"),
st.RegisterPluginAsExtensions("test-plugin", newTestPlugin, "PreFilter"),
st.RegisterBindPlugin(defaultbinder.Name, defaultbinder.New),
registeredPlugins := []tf.RegisterPluginFunc{
tf.RegisterQueueSortPlugin(queuesort.Name, queuesort.New),
tf.RegisterPluginAsExtensions(noderesources.Name, nodeResourcesFitFunc, "Filter", "PreFilter"),
tf.RegisterPluginAsExtensions("test-plugin", newTestPlugin, "PreFilter"),
tf.RegisterBindPlugin(defaultbinder.Name, defaultbinder.New),
}
var extenders []framework.Extender
if tt.extender != nil {
@ -355,7 +356,7 @@ func TestPostFilter(t *testing.T) {
logger, ctx := ktesting.NewTestContext(t)
ctx, cancel := context.WithCancel(ctx)
defer cancel()
f, err := st.NewFramework(ctx, registeredPlugins, "",
f, err := tf.NewFramework(ctx, registeredPlugins, "",
frameworkruntime.WithClientSet(cs),
frameworkruntime.WithEventRecorder(&events.FakeRecorder{}),
frameworkruntime.WithInformerFactory(informerFactory),
@ -410,7 +411,7 @@ func TestDryRunPreemption(t *testing.T) {
nodeNames []string
testPods []*v1.Pod
initPods []*v1.Pod
registerPlugins []st.RegisterPluginFunc
registerPlugins []tf.RegisterPluginFunc
pdbs []*policy.PodDisruptionBudget
fakeFilterRC framework.Code // return code for fake filter plugin
disableParallelism bool
@ -419,8 +420,8 @@ func TestDryRunPreemption(t *testing.T) {
}{
{
name: "a pod that does not fit on any node",
registerPlugins: []st.RegisterPluginFunc{
st.RegisterFilterPlugin("FalseFilter", st.NewFalseFilterPlugin),
registerPlugins: []tf.RegisterPluginFunc{
tf.RegisterFilterPlugin("FalseFilter", tf.NewFalseFilterPlugin),
},
nodeNames: []string{"node1", "node2"},
testPods: []*v1.Pod{
@ -435,8 +436,8 @@ func TestDryRunPreemption(t *testing.T) {
},
{
name: "a pod that fits with no preemption",
registerPlugins: []st.RegisterPluginFunc{
st.RegisterFilterPlugin("TrueFilter", st.NewTrueFilterPlugin),
registerPlugins: []tf.RegisterPluginFunc{
tf.RegisterFilterPlugin("TrueFilter", tf.NewTrueFilterPlugin),
},
nodeNames: []string{"node1", "node2"},
testPods: []*v1.Pod{
@ -452,8 +453,8 @@ func TestDryRunPreemption(t *testing.T) {
},
{
name: "a pod that fits on one node with no preemption",
registerPlugins: []st.RegisterPluginFunc{
st.RegisterFilterPlugin("MatchFilter", st.NewMatchFilterPlugin),
registerPlugins: []tf.RegisterPluginFunc{
tf.RegisterFilterPlugin("MatchFilter", tf.NewMatchFilterPlugin),
},
nodeNames: []string{"node1", "node2"},
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",
registerPlugins: []st.RegisterPluginFunc{
st.RegisterPluginAsExtensions(noderesources.Name, nodeResourcesFitFunc, "Filter", "PreFilter"),
registerPlugins: []tf.RegisterPluginFunc{
tf.RegisterPluginAsExtensions(noderesources.Name, nodeResourcesFitFunc, "Filter", "PreFilter"),
},
nodeNames: []string{"node1", "node2"},
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",
registerPlugins: []st.RegisterPluginFunc{
st.RegisterPluginAsExtensions(noderesources.Name, nodeResourcesFitFunc, "Filter", "PreFilter"),
registerPlugins: []tf.RegisterPluginFunc{
tf.RegisterPluginAsExtensions(noderesources.Name, nodeResourcesFitFunc, "Filter", "PreFilter"),
},
nodeNames: []string{"node1", "node2"},
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",
registerPlugins: []st.RegisterPluginFunc{
st.RegisterPluginAsExtensions(noderesources.Name, nodeResourcesFitFunc, "Filter", "PreFilter"),
registerPlugins: []tf.RegisterPluginFunc{
tf.RegisterPluginAsExtensions(noderesources.Name, nodeResourcesFitFunc, "Filter", "PreFilter"),
},
nodeNames: []string{"node1", "node2"},
testPods: []*v1.Pod{
@ -549,8 +550,8 @@ func TestDryRunPreemption(t *testing.T) {
},
{
name: "mixed priority pods are preempted",
registerPlugins: []st.RegisterPluginFunc{
st.RegisterPluginAsExtensions(noderesources.Name, nodeResourcesFitFunc, "Filter", "PreFilter"),
registerPlugins: []tf.RegisterPluginFunc{
tf.RegisterPluginAsExtensions(noderesources.Name, nodeResourcesFitFunc, "Filter", "PreFilter"),
},
nodeNames: []string{"node1", "node2"},
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",
registerPlugins: []st.RegisterPluginFunc{
st.RegisterPluginAsExtensions(noderesources.Name, nodeResourcesFitFunc, "Filter", "PreFilter"),
registerPlugins: []tf.RegisterPluginFunc{
tf.RegisterPluginAsExtensions(noderesources.Name, nodeResourcesFitFunc, "Filter", "PreFilter"),
},
nodeNames: []string{"node1", "node2"},
testPods: []*v1.Pod{
@ -611,9 +612,9 @@ func TestDryRunPreemption(t *testing.T) {
},
{
name: "pod with anti-affinity is preempted",
registerPlugins: []st.RegisterPluginFunc{
st.RegisterPluginAsExtensions(noderesources.Name, nodeResourcesFitFunc, "Filter", "PreFilter"),
st.RegisterPluginAsExtensions(interpodaffinity.Name, interpodaffinity.New, "Filter", "PreFilter"),
registerPlugins: []tf.RegisterPluginFunc{
tf.RegisterPluginAsExtensions(noderesources.Name, nodeResourcesFitFunc, "Filter", "PreFilter"),
tf.RegisterPluginAsExtensions(interpodaffinity.Name, interpodaffinity.New, "Filter", "PreFilter"),
},
nodeNames: []string{"node1", "node2"},
testPods: []*v1.Pod{
@ -643,8 +644,8 @@ func TestDryRunPreemption(t *testing.T) {
},
{
name: "preemption to resolve pod topology spread filter failure",
registerPlugins: []st.RegisterPluginFunc{
st.RegisterPluginAsExtensions(podtopologyspread.Name, podTopologySpreadFunc, "PreFilter", "Filter"),
registerPlugins: []tf.RegisterPluginFunc{
tf.RegisterPluginAsExtensions(podtopologyspread.Name, podTopologySpreadFunc, "PreFilter", "Filter"),
},
nodeNames: []string{"node-a/zone1", "node-b/zone1", "node-x/zone2"},
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",
registerPlugins: []st.RegisterPluginFunc{
st.RegisterPluginAsExtensions(noderesources.Name, nodeResourcesFitFunc, "Filter", "PreFilter"),
registerPlugins: []tf.RegisterPluginFunc{
tf.RegisterPluginAsExtensions(noderesources.Name, nodeResourcesFitFunc, "Filter", "PreFilter"),
},
nodeNames: []string{"node1", "node2"},
testPods: []*v1.Pod{
@ -697,8 +698,8 @@ func TestDryRunPreemption(t *testing.T) {
},
{
name: "preemption with violation of same pdb",
registerPlugins: []st.RegisterPluginFunc{
st.RegisterPluginAsExtensions(noderesources.Name, nodeResourcesFitFunc, "Filter", "PreFilter"),
registerPlugins: []tf.RegisterPluginFunc{
tf.RegisterPluginAsExtensions(noderesources.Name, nodeResourcesFitFunc, "Filter", "PreFilter"),
},
nodeNames: []string{"node1"},
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",
registerPlugins: []st.RegisterPluginFunc{
st.RegisterPluginAsExtensions(noderesources.Name, nodeResourcesFitFunc, "Filter", "PreFilter"),
registerPlugins: []tf.RegisterPluginFunc{
tf.RegisterPluginAsExtensions(noderesources.Name, nodeResourcesFitFunc, "Filter", "PreFilter"),
},
nodeNames: []string{"node1"},
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",
registerPlugins: []st.RegisterPluginFunc{
st.RegisterPluginAsExtensions(noderesources.Name, nodeResourcesFitFunc, "Filter", "PreFilter"),
registerPlugins: []tf.RegisterPluginFunc{
tf.RegisterPluginAsExtensions(noderesources.Name, nodeResourcesFitFunc, "Filter", "PreFilter"),
},
nodeNames: []string{"node1"},
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'",
registerPlugins: []st.RegisterPluginFunc{
st.RegisterPluginAsExtensions(noderesources.Name, nodeResourcesFitFunc, "Filter", "PreFilter"),
registerPlugins: []tf.RegisterPluginFunc{
tf.RegisterPluginAsExtensions(noderesources.Name, nodeResourcesFitFunc, "Filter", "PreFilter"),
},
nodeNames: []string{"node1"},
testPods: []*v1.Pod{
@ -840,8 +841,8 @@ func TestDryRunPreemption(t *testing.T) {
{
name: "all nodes are possible candidates, but DefaultPreemptionArgs limits to 2",
args: &config.DefaultPreemptionArgs{MinCandidateNodesPercentage: 40, MinCandidateNodesAbsolute: 1},
registerPlugins: []st.RegisterPluginFunc{
st.RegisterPluginAsExtensions(noderesources.Name, nodeResourcesFitFunc, "Filter", "PreFilter"),
registerPlugins: []tf.RegisterPluginFunc{
tf.RegisterPluginAsExtensions(noderesources.Name, nodeResourcesFitFunc, "Filter", "PreFilter"),
},
nodeNames: []string{"node1", "node2", "node3", "node4", "node5"},
testPods: []*v1.Pod{
@ -877,8 +878,8 @@ func TestDryRunPreemption(t *testing.T) {
{
name: "some nodes are not possible candidates, DefaultPreemptionArgs limits to 2",
args: &config.DefaultPreemptionArgs{MinCandidateNodesPercentage: 40, MinCandidateNodesAbsolute: 1},
registerPlugins: []st.RegisterPluginFunc{
st.RegisterPluginAsExtensions(noderesources.Name, nodeResourcesFitFunc, "Filter", "PreFilter"),
registerPlugins: []tf.RegisterPluginFunc{
tf.RegisterPluginAsExtensions(noderesources.Name, nodeResourcesFitFunc, "Filter", "PreFilter"),
},
nodeNames: []string{"node1", "node2", "node3", "node4", "node5"},
testPods: []*v1.Pod{
@ -914,8 +915,8 @@ func TestDryRunPreemption(t *testing.T) {
{
name: "preemption offset across multiple scheduling cycles and wrap around",
args: &config.DefaultPreemptionArgs{MinCandidateNodesPercentage: 40, MinCandidateNodesAbsolute: 1},
registerPlugins: []st.RegisterPluginFunc{
st.RegisterPluginAsExtensions(noderesources.Name, nodeResourcesFitFunc, "Filter", "PreFilter"),
registerPlugins: []tf.RegisterPluginFunc{
tf.RegisterPluginAsExtensions(noderesources.Name, nodeResourcesFitFunc, "Filter", "PreFilter"),
},
nodeNames: []string{"node1", "node2", "node3", "node4", "node5"},
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",
args: &config.DefaultPreemptionArgs{MinCandidateNodesPercentage: 40, MinCandidateNodesAbsolute: 2},
registerPlugins: []st.RegisterPluginFunc{
st.RegisterPluginAsExtensions(noderesources.Name, nodeResourcesFitFunc, "Filter", "PreFilter"),
registerPlugins: []tf.RegisterPluginFunc{
tf.RegisterPluginAsExtensions(noderesources.Name, nodeResourcesFitFunc, "Filter", "PreFilter"),
},
nodeNames: []string{"node1", "node2", "node3", "node4", "node5"},
testPods: []*v1.Pod{
@ -1059,18 +1060,18 @@ func TestDryRunPreemption(t *testing.T) {
snapshot := internalcache.NewSnapshot(tt.initPods, nodes)
// For each test, register a FakeFilterPlugin along with essential plugins and tt.registerPlugins.
fakePlugin := st.FakeFilterPlugin{
fakePlugin := tf.FakeFilterPlugin{
FailedNodeReturnCodeMap: fakeFilterRCMap,
}
registeredPlugins := append([]st.RegisterPluginFunc{
st.RegisterFilterPlugin(
registeredPlugins := append([]tf.RegisterPluginFunc{
tf.RegisterFilterPlugin(
"FakeFilter",
func(_ runtime.Object, fh framework.Handle) (framework.Plugin, error) {
return &fakePlugin, nil
},
)},
st.RegisterQueueSortPlugin(queuesort.Name, queuesort.New),
st.RegisterBindPlugin(defaultbinder.Name, defaultbinder.New),
tf.RegisterQueueSortPlugin(queuesort.Name, queuesort.New),
tf.RegisterBindPlugin(defaultbinder.Name, defaultbinder.New),
)
registeredPlugins = append(registeredPlugins, tt.registerPlugins...)
var objs []runtime.Object
@ -1092,7 +1093,7 @@ func TestDryRunPreemption(t *testing.T) {
logger, ctx := ktesting.NewTestContext(t)
ctx, cancel := context.WithCancel(ctx)
defer cancel()
fwk, err := st.NewFramework(
fwk, err := tf.NewFramework(
ctx,
registeredPlugins, "",
frameworkruntime.WithPodNominator(internalqueue.NewPodNominator(informerFactory.Core().V1().Pods().Lister())),
@ -1176,7 +1177,7 @@ func TestDryRunPreemption(t *testing.T) {
func TestSelectBestCandidate(t *testing.T) {
tests := []struct {
name string
registerPlugin st.RegisterPluginFunc
registerPlugin tf.RegisterPluginFunc
nodeNames []string
pod *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",
registerPlugin: st.RegisterPluginAsExtensions(noderesources.Name, nodeResourcesFitFunc, "Filter", "PreFilter"),
registerPlugin: tf.RegisterPluginAsExtensions(noderesources.Name, nodeResourcesFitFunc, "Filter", "PreFilter"),
nodeNames: []string{"node1", "node2"},
pod: st.MakePod().Name("p").UID("p").Priority(highPriority).Req(largeRes).Obj(),
pods: []*v1.Pod{
@ -1195,7 +1196,7 @@ func TestSelectBestCandidate(t *testing.T) {
},
{
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"},
pod: st.MakePod().Name("p").UID("p").Priority(highPriority).Req(veryLargeRes).Obj(),
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",
registerPlugin: st.RegisterPluginAsExtensions(noderesources.Name, nodeResourcesFitFunc, "Filter", "PreFilter"),
registerPlugin: tf.RegisterPluginAsExtensions(noderesources.Name, nodeResourcesFitFunc, "Filter", "PreFilter"),
nodeNames: []string{"node1", "node2", "node3"},
pod: st.MakePod().Name("p").UID("p").Priority(highPriority).Req(veryLargeRes).Obj(),
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",
registerPlugin: st.RegisterPluginAsExtensions(noderesources.Name, nodeResourcesFitFunc, "Filter", "PreFilter"),
registerPlugin: tf.RegisterPluginAsExtensions(noderesources.Name, nodeResourcesFitFunc, "Filter", "PreFilter"),
nodeNames: []string{"node1", "node2", "node3"},
pod: st.MakePod().Name("p").UID("p").Priority(highPriority).Req(veryLargeRes).Obj(),
pods: []*v1.Pod{
@ -1245,7 +1246,7 @@ func TestSelectBestCandidate(t *testing.T) {
// pickOneNodeForPreemption adjusts pod priorities when finding the sum of the victims. This
// test ensures that the logic works correctly.
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"},
pod: st.MakePod().Name("p").UID("p").Priority(highPriority).Req(veryLargeRes).Obj(),
pods: []*v1.Pod{
@ -1262,7 +1263,7 @@ func TestSelectBestCandidate(t *testing.T) {
},
{
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"},
pod: st.MakePod().Name("p").UID("p").Priority(veryHighPriority).Req(veryLargeRes).Obj(),
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",
registerPlugin: st.RegisterPluginAsExtensions(noderesources.Name, nodeResourcesFitFunc, "Filter", "PreFilter"),
registerPlugin: tf.RegisterPluginAsExtensions(noderesources.Name, nodeResourcesFitFunc, "Filter", "PreFilter"),
nodeNames: []string{"node1", "node2", "node3"},
pod: st.MakePod().Name("p").UID("p").Priority(highPriority).Req(veryLargeRes).Obj(),
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",
registerPlugin: st.RegisterPluginAsExtensions(noderesources.Name, nodeResourcesFitFunc, "Filter", "PreFilter"),
registerPlugin: tf.RegisterPluginAsExtensions(noderesources.Name, nodeResourcesFitFunc, "Filter", "PreFilter"),
nodeNames: []string{"node1", "node2", "node3"},
pod: st.MakePod().Name("p").UID("p").Priority(highPriority).Req(veryLargeRes).Obj(),
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",
registerPlugin: st.RegisterPluginAsExtensions(noderesources.Name, nodeResourcesFitFunc, "Filter", "PreFilter"),
registerPlugin: tf.RegisterPluginAsExtensions(noderesources.Name, nodeResourcesFitFunc, "Filter", "PreFilter"),
nodeNames: []string{"node1", "node2", "node3"},
pod: st.MakePod().Name("p").UID("p").Priority(highPriority).Req(veryLargeRes).Obj(),
pods: []*v1.Pod{
@ -1346,12 +1347,12 @@ func TestSelectBestCandidate(t *testing.T) {
logger, ctx := ktesting.NewTestContext(t)
ctx, cancel := context.WithCancel(ctx)
defer cancel()
fwk, err := st.NewFramework(
fwk, err := tf.NewFramework(
ctx,
[]st.RegisterPluginFunc{
[]tf.RegisterPluginFunc{
tt.registerPlugin,
st.RegisterQueueSortPlugin(queuesort.Name, queuesort.New),
st.RegisterBindPlugin(defaultbinder.Name, defaultbinder.New),
tf.RegisterQueueSortPlugin(queuesort.Name, queuesort.New),
tf.RegisterBindPlugin(defaultbinder.Name, defaultbinder.New),
},
"",
frameworkruntime.WithPodNominator(internalqueue.NewPodNominator(informerFactory.Core().V1().Pods().Lister())),
@ -1493,11 +1494,11 @@ func TestPodEligibleToPreemptOthers(t *testing.T) {
for _, n := range test.nodes {
nodes = append(nodes, st.MakeNode().Name(n).Obj())
}
registeredPlugins := []st.RegisterPluginFunc{
st.RegisterQueueSortPlugin(queuesort.Name, queuesort.New),
st.RegisterBindPlugin(defaultbinder.Name, defaultbinder.New),
registeredPlugins := []tf.RegisterPluginFunc{
tf.RegisterQueueSortPlugin(queuesort.Name, queuesort.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.WithLogger(logger),
)
@ -1516,9 +1517,9 @@ func TestPreempt(t *testing.T) {
name string
pod *v1.Pod
pods []*v1.Pod
extenders []*st.FakeExtender
extenders []*tf.FakeExtender
nodeNames []string
registerPlugin st.RegisterPluginFunc
registerPlugin tf.RegisterPluginFunc
want *framework.PostFilterResult
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(),
},
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"),
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(),
},
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"),
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(),
},
nodeNames: []string{"node1", "node2", "node3"},
extenders: []*st.FakeExtender{
extenders: []*tf.FakeExtender{
{
ExtenderName: "FakeExtender1",
Predicates: []st.FitPredicate{st.TruePredicateExtender},
Predicates: []tf.FitPredicate{tf.TruePredicateExtender},
},
{
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"),
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(),
},
nodeNames: []string{"node1", "node2", "node3"},
extenders: []*st.FakeExtender{
extenders: []*tf.FakeExtender{
{
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,
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(),
},
nodeNames: []string{"node1", "node2", "node3"},
extenders: []*st.FakeExtender{
extenders: []*tf.FakeExtender{
{
Predicates: []st.FitPredicate{st.ErrorPredicateExtender},
Predicates: []tf.FitPredicate{tf.ErrorPredicateExtender},
Ignorable: true,
ExtenderName: "FakeExtender1",
},
{
Predicates: []st.FitPredicate{st.Node1PredicateExtender},
Predicates: []tf.FitPredicate{tf.Node1PredicateExtender},
ExtenderName: "FakeExtender2",
},
},
registerPlugin: st.RegisterPluginAsExtensions(noderesources.Name, nodeResourcesFitFunc, "Filter", "PreFilter"),
registerPlugin: tf.RegisterPluginAsExtensions(noderesources.Name, nodeResourcesFitFunc, "Filter", "PreFilter"),
want: framework.NewPostFilterResultWithNominatedNode("node1"),
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(),
},
nodeNames: []string{"node1", "node2"},
extenders: []*st.FakeExtender{
extenders: []*tf.FakeExtender{
{
ExtenderName: "FakeExtender1",
Predicates: []st.FitPredicate{st.Node1PredicateExtender},
Predicates: []tf.FitPredicate{tf.Node1PredicateExtender},
UnInterested: true,
},
{
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.
want: framework.NewPostFilterResultWithNominatedNode("node2"),
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(),
},
nodeNames: []string{"node1", "node2", "node3"},
registerPlugin: st.RegisterPluginAsExtensions(noderesources.Name, nodeResourcesFitFunc, "Filter", "PreFilter"),
registerPlugin: tf.RegisterPluginAsExtensions(noderesources.Name, nodeResourcesFitFunc, "Filter", "PreFilter"),
want: 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(),
},
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"),
expectedPods: []string{"p1.1", "p1.2"},
},
@ -1730,12 +1731,12 @@ func TestPreempt(t *testing.T) {
extender.CachedNodeNameToInfo = cachedNodeInfoMap
extenders = append(extenders, extender)
}
fwk, err := st.NewFramework(
fwk, err := tf.NewFramework(
ctx,
[]st.RegisterPluginFunc{
[]tf.RegisterPluginFunc{
test.registerPlugin,
st.RegisterQueueSortPlugin(queuesort.Name, queuesort.New),
st.RegisterBindPlugin(defaultbinder.Name, defaultbinder.New),
tf.RegisterQueueSortPlugin(queuesort.Name, queuesort.New),
tf.RegisterBindPlugin(defaultbinder.Name, defaultbinder.New),
},
"",
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"
csilibplugins "k8s.io/csi-translation-lib/plugins"
"k8s.io/kubernetes/pkg/scheduler/framework"
fakeframework "k8s.io/kubernetes/pkg/scheduler/framework/fake"
st "k8s.io/kubernetes/pkg/scheduler/testing"
tf "k8s.io/kubernetes/pkg/scheduler/testing/framework"
volumeutil "k8s.io/kubernetes/pkg/volume/util"
"k8s.io/kubernetes/test/utils/ktesting"
"k8s.io/utils/pointer"
@ -641,8 +641,8 @@ func TestCSILimits(t *testing.T) {
}
}
func getFakeCSIPVLister(volumeName string, driverNames ...string) fakeframework.PersistentVolumeLister {
pvLister := fakeframework.PersistentVolumeLister{}
func getFakeCSIPVLister(volumeName string, driverNames ...string) tf.PersistentVolumeLister {
pvLister := tf.PersistentVolumeLister{}
for _, driver := range driverNames {
for j := 0; j < 4; j++ {
volumeHandle := fmt.Sprintf("%s-%s-%d", volumeName, driver, j)
@ -686,8 +686,8 @@ func getFakeCSIPVLister(volumeName string, driverNames ...string) fakeframework.
return pvLister
}
func getFakeCSIPVCLister(volumeName, scName string, driverNames ...string) fakeframework.PersistentVolumeClaimLister {
pvcLister := fakeframework.PersistentVolumeClaimLister{}
func getFakeCSIPVCLister(volumeName, scName string, driverNames ...string) tf.PersistentVolumeClaimLister {
pvcLister := tf.PersistentVolumeClaimLister{}
for _, driver := range driverNames {
for j := 0; j < 4; j++ {
v := fmt.Sprintf("%s-%s-%d", volumeName, driver, j)
@ -729,8 +729,8 @@ func enableMigrationOnNode(csiNode *storagev1.CSINode, pluginName string) {
csiNode.Annotations = nodeInfoAnnotations
}
func getFakeCSIStorageClassLister(scName, provisionerName string) fakeframework.StorageClassLister {
return fakeframework.StorageClassLister{
func getFakeCSIStorageClassLister(scName, provisionerName string) tf.StorageClassLister {
return tf.StorageClassLister{
{
ObjectMeta: metav1.ObjectMeta{Name: scName},
Provisioner: provisionerName,
@ -738,8 +738,8 @@ func getFakeCSIStorageClassLister(scName, provisionerName string) fakeframework.
}
}
func getFakeCSINodeLister(csiNode *storagev1.CSINode) fakeframework.CSINodeLister {
csiNodeLister := fakeframework.CSINodeLister{}
func getFakeCSINodeLister(csiNode *storagev1.CSINode) tf.CSINodeLister {
csiNodeLister := tf.CSINodeLister{}
if csiNode != nil {
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"
csilibplugins "k8s.io/csi-translation-lib/plugins"
"k8s.io/kubernetes/pkg/scheduler/framework"
fakeframework "k8s.io/kubernetes/pkg/scheduler/framework/fake"
"k8s.io/kubernetes/pkg/scheduler/framework/plugins/feature"
st "k8s.io/kubernetes/pkg/scheduler/testing"
tf "k8s.io/kubernetes/pkg/scheduler/testing/framework"
"k8s.io/utils/pointer"
)
@ -974,8 +974,8 @@ func TestGetMaxVols(t *testing.T) {
}
}
func getFakePVCLister(filterName string) fakeframework.PersistentVolumeClaimLister {
return fakeframework.PersistentVolumeClaimLister{
func getFakePVCLister(filterName string) tf.PersistentVolumeClaimLister {
return tf.PersistentVolumeClaimLister{
{
ObjectMeta: metav1.ObjectMeta{Name: "some" + filterName + "Vol"},
Spec: v1.PersistentVolumeClaimSpec{
@ -1035,8 +1035,8 @@ func getFakePVCLister(filterName string) fakeframework.PersistentVolumeClaimList
}
}
func getFakePVLister(filterName string) fakeframework.PersistentVolumeLister {
return fakeframework.PersistentVolumeLister{
func getFakePVLister(filterName string) tf.PersistentVolumeLister {
return tf.PersistentVolumeLister{
{
ObjectMeta: metav1.ObjectMeta{Name: "some" + filterName + "Vol"},
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/kubernetes/pkg/scheduler/apis/config"
"k8s.io/kubernetes/pkg/scheduler/framework"
fakeframework "k8s.io/kubernetes/pkg/scheduler/framework/fake"
plugintesting "k8s.io/kubernetes/pkg/scheduler/framework/plugins/testing"
"k8s.io/kubernetes/pkg/scheduler/internal/cache"
st "k8s.io/kubernetes/pkg/scheduler/testing"
tf "k8s.io/kubernetes/pkg/scheduler/testing/framework"
)
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) {
pvLister := fakeframework.PersistentVolumeLister{
pvLister := tf.PersistentVolumeLister{
{
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"},
Spec: v1.PersistentVolumeClaimSpec{VolumeName: "Vol_1"},
@ -283,7 +283,7 @@ func TestSingleZone(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"}},
},
@ -301,7 +301,7 @@ func TestMultiZone(t *testing.T) {
},
}
pvcLister := fakeframework.PersistentVolumeClaimLister{
pvcLister := tf.PersistentVolumeClaimLister{
{
ObjectMeta: metav1.ObjectMeta{Name: "PVC_1", Namespace: "default"},
Spec: v1.PersistentVolumeClaimSpec{VolumeName: "Vol_1"},
@ -423,7 +423,7 @@ func TestWithBinding(t *testing.T) {
classImmediate = "Class_Immediate"
)
scLister := fakeframework.StorageClassLister{
scLister := tf.StorageClassLister{
{
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"}},
},
}
pvcLister := fakeframework.PersistentVolumeClaimLister{
pvcLister := tf.PersistentVolumeClaimLister{
{
ObjectMeta: metav1.ObjectMeta{Name: "PVC_1", Namespace: "default"},
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"
internalqueue "k8s.io/kubernetes/pkg/scheduler/internal/queue"
st "k8s.io/kubernetes/pkg/scheduler/testing"
tf "k8s.io/kubernetes/pkg/scheduler/testing/framework"
)
var (
@ -268,9 +269,9 @@ func TestDryRunPreemption(t *testing.T) {
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
logger, _ := ktesting.NewTestContext(t)
registeredPlugins := append([]st.RegisterPluginFunc{
st.RegisterQueueSortPlugin(queuesort.Name, queuesort.New)},
st.RegisterBindPlugin(defaultbinder.Name, defaultbinder.New),
registeredPlugins := append([]tf.RegisterPluginFunc{
tf.RegisterQueueSortPlugin(queuesort.Name, queuesort.New)},
tf.RegisterBindPlugin(defaultbinder.Name, defaultbinder.New),
)
var objs []runtime.Object
for _, p := range append(tt.testPods, tt.initPods...) {
@ -284,7 +285,7 @@ func TestDryRunPreemption(t *testing.T) {
_, ctx := ktesting.NewTestContext(t)
ctx, cancel := context.WithCancel(ctx)
defer cancel()
fwk, err := st.NewFramework(
fwk, err := tf.NewFramework(
ctx,
registeredPlugins, "",
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"
"k8s.io/kubernetes/pkg/scheduler/profile"
st "k8s.io/kubernetes/pkg/scheduler/testing"
tf "k8s.io/kubernetes/pkg/scheduler/testing/framework"
testingclock "k8s.io/utils/clock/testing"
"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,
client kubernetes.Interface, informerFactory informers.SharedInformerFactory) (*Scheduler, framework.Framework, error) {
logger := klog.FromContext(ctx)
registerPluginFuncs := []st.RegisterPluginFunc{
st.RegisterQueueSortPlugin(queuesort.Name, queuesort.New),
st.RegisterBindPlugin(defaultbinder.Name, defaultbinder.New),
registerPluginFuncs := []tf.RegisterPluginFunc{
tf.RegisterQueueSortPlugin(queuesort.Name, queuesort.New),
tf.RegisterBindPlugin(defaultbinder.Name, defaultbinder.New),
}
eventBroadcaster := events.NewBroadcaster(&events.EventSinkImpl{Interface: client.EventsV1()})
fwk, err := st.NewFramework(ctx,
fwk, err := tf.NewFramework(ctx,
registerPluginFuncs,
testSchedulerName,
frameworkruntime.WithClientSet(client),
@ -593,22 +594,22 @@ func TestInitPluginsWithIndexers(t *testing.T) {
t.Run(tt.name, func(t *testing.T) {
fakeInformerFactory := NewInformerFactory(&fake.Clientset{}, 0*time.Second)
var registerPluginFuncs []st.RegisterPluginFunc
var registerPluginFuncs []tf.RegisterPluginFunc
for name, entrypoint := range tt.entrypoints {
registerPluginFuncs = append(registerPluginFuncs,
// anything supported by TestPlugin is fine
st.RegisterFilterPlugin(name, entrypoint),
tf.RegisterFilterPlugin(name, entrypoint),
)
}
// we always need this
registerPluginFuncs = append(registerPluginFuncs,
st.RegisterQueueSortPlugin(queuesort.Name, queuesort.New),
st.RegisterBindPlugin(defaultbinder.Name, defaultbinder.New),
tf.RegisterQueueSortPlugin(queuesort.Name, queuesort.New),
tf.RegisterBindPlugin(defaultbinder.Name, defaultbinder.New),
)
_, ctx := ktesting.NewTestContext(t)
ctx, cancel := context.WithCancel(ctx)
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 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.
*/
package testing
package framework
import (
"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.
*/
package fake
package framework
import (
"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.
*/
package testing
package framework
import (
"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.
*/
package testing
package framework
import (
"context"