volcano.sh/volcano@v1.9.0/pkg/scheduler/util/scheduler_helper_test.go (about)

     1  /*
     2  Copyright 2019 The Kubernetes Authors.
     3  
     4  Licensed under the Apache License, Version 2.0 (the "License");
     5  you may not use this file except in compliance with the License.
     6  You may obtain a copy of the License at
     7  
     8      http://www.apache.org/licenses/LICENSE-2.0
     9  
    10  Unless required by applicable law or agreed to in writing, software
    11  distributed under the License is distributed on an "AS IS" BASIS,
    12  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    13  See the License for the specific language governing permissions and
    14  limitations under the License.
    15  */
    16  
    17  package util
    18  
    19  import (
    20  	"reflect"
    21  	"testing"
    22  
    23  	"volcano.sh/volcano/cmd/scheduler/app/options"
    24  	"volcano.sh/volcano/pkg/scheduler/api"
    25  )
    26  
    27  func TestSelectBestNode(t *testing.T) {
    28  	cases := []struct {
    29  		NodeScores map[float64][]*api.NodeInfo
    30  		// Expected node is one of ExpectedNodes
    31  		ExpectedNodes []*api.NodeInfo
    32  	}{
    33  		{
    34  			NodeScores: map[float64][]*api.NodeInfo{
    35  				1.0: {&api.NodeInfo{Name: "node1"}, &api.NodeInfo{Name: "node2"}},
    36  				2.0: {&api.NodeInfo{Name: "node3"}, &api.NodeInfo{Name: "node4"}},
    37  			},
    38  			ExpectedNodes: []*api.NodeInfo{{Name: "node3"}, {Name: "node4"}},
    39  		},
    40  		{
    41  			NodeScores: map[float64][]*api.NodeInfo{
    42  				1.0: {&api.NodeInfo{Name: "node1"}, &api.NodeInfo{Name: "node2"}},
    43  				3.0: {&api.NodeInfo{Name: "node3"}},
    44  				2.0: {&api.NodeInfo{Name: "node4"}, &api.NodeInfo{Name: "node5"}},
    45  			},
    46  			ExpectedNodes: []*api.NodeInfo{{Name: "node3"}},
    47  		},
    48  		{
    49  			NodeScores:    map[float64][]*api.NodeInfo{},
    50  			ExpectedNodes: []*api.NodeInfo{nil},
    51  		},
    52  	}
    53  
    54  	oneOf := func(node *api.NodeInfo, nodes []*api.NodeInfo) bool {
    55  		for _, v := range nodes {
    56  			if reflect.DeepEqual(node, v) {
    57  				return true
    58  			}
    59  		}
    60  		return false
    61  	}
    62  	for i, test := range cases {
    63  		result := SelectBestNode(test.NodeScores)
    64  		if !oneOf(result, test.ExpectedNodes) {
    65  			t.Errorf("Failed test case #%d, expected: %#v, got %#v", i, test.ExpectedNodes, result)
    66  		}
    67  	}
    68  }
    69  
    70  func TestGetMinInt(t *testing.T) {
    71  	cases := []struct {
    72  		vals   []int
    73  		result int
    74  	}{
    75  		{
    76  			vals:   []int{1, 2, 3},
    77  			result: 1,
    78  		},
    79  		{
    80  			vals:   []int{10, 9, 8},
    81  			result: 8,
    82  		},
    83  		{
    84  			vals:   []int{10, 0, 8},
    85  			result: 0,
    86  		},
    87  		{
    88  			vals:   []int{},
    89  			result: 0,
    90  		},
    91  		{
    92  			vals:   []int{0, -1, 1},
    93  			result: -1,
    94  		},
    95  	}
    96  	for i, test := range cases {
    97  		result := GetMinInt(test.vals...)
    98  		if result != test.result {
    99  			t.Errorf("Failed test case #%d, expected: %#v, got %#v", i, test.result, result)
   100  		}
   101  	}
   102  }
   103  
   104  func TestNumFeasibleNodesToFind(t *testing.T) {
   105  	tests := []struct {
   106  		name                     string
   107  		percentageOfNodesToScore int32
   108  		numAllNodes              int32
   109  		wantNumNodes             int32
   110  	}{
   111  		{
   112  			name:         "not set percentageOfNodesToScore and nodes number not more than 50",
   113  			numAllNodes:  10,
   114  			wantNumNodes: 10,
   115  		},
   116  		{
   117  			name:                     "set percentageOfNodesToScore and nodes number not more than 50",
   118  			percentageOfNodesToScore: 40,
   119  			numAllNodes:              10,
   120  			wantNumNodes:             10,
   121  		},
   122  		{
   123  			name:         "not set percentageOfNodesToScore and nodes number more than 50",
   124  			numAllNodes:  1000,
   125  			wantNumNodes: 420,
   126  		},
   127  		{
   128  			name:                     "set percentageOfNodesToScore and nodes number more than 50",
   129  			percentageOfNodesToScore: 40,
   130  			numAllNodes:              1000,
   131  			wantNumNodes:             400,
   132  		},
   133  		{
   134  			name:         "not set percentageOfNodesToScore and nodes number more than 50*125",
   135  			numAllNodes:  6000,
   136  			wantNumNodes: 300,
   137  		},
   138  		{
   139  			name:                     "set percentageOfNodesToScore and nodes number more than 50*125",
   140  			percentageOfNodesToScore: 40,
   141  			numAllNodes:              6000,
   142  			wantNumNodes:             2400,
   143  		},
   144  	}
   145  	for _, tt := range tests {
   146  		t.Run(tt.name, func(t *testing.T) {
   147  			options.ServerOpts = &options.ServerOption{
   148  				MinPercentageOfNodesToFind: 5,
   149  				MinNodesToFind:             100,
   150  				PercentageOfNodesToFind:    tt.percentageOfNodesToScore,
   151  			}
   152  			if gotNumNodes := CalculateNumOfFeasibleNodesToFind(tt.numAllNodes); gotNumNodes != tt.wantNumNodes {
   153  				t.Errorf("Scheduler.numFeasibleNodesToFind() = %v, want %v", gotNumNodes, tt.wantNumNodes)
   154  			}
   155  		})
   156  	}
   157  }