scorer_test.go

Documentation: k8s.io/kubernetes/pkg/scheduler/framework/plugins/volumebinding

     1  /*
     2  Copyright 2021 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 volumebinding
    18  
    19  import (
    20  	"testing"
    21  
    22  	"k8s.io/kubernetes/pkg/scheduler/apis/config"
    23  	"k8s.io/kubernetes/pkg/scheduler/framework"
    24  	"k8s.io/kubernetes/pkg/scheduler/framework/plugins/helper"
    25  )
    26  
    27  const (
    28  	classHDD = "hdd"
    29  	classSSD = "ssd"
    30  )
    31  
    32  func TestScore(t *testing.T) {
    33  	defaultShape := make(helper.FunctionShape, 0, len(defaultShapePoint))
    34  	for _, point := range defaultShapePoint {
    35  		defaultShape = append(defaultShape, helper.FunctionShapePoint{
    36  			Utilization: int64(point.Utilization),
    37  			Score:       int64(point.Score) * (framework.MaxNodeScore / config.MaxCustomPriorityScore),
    38  		})
    39  	}
    40  	type scoreCase struct {
    41  		classResources classResourceMap
    42  		score          int64
    43  	}
    44  	tests := []struct {
    45  		name  string
    46  		shape helper.FunctionShape
    47  		cases []scoreCase
    48  	}{
    49  		{
    50  			name:  "default shape, single class",
    51  			shape: defaultShape,
    52  			cases: []scoreCase{
    53  				{
    54  					classResourceMap{
    55  						classHDD: &StorageResource{
    56  							Requested: 0,
    57  							Capacity:  100,
    58  						},
    59  					},
    60  					0,
    61  				},
    62  				{
    63  					classResourceMap{
    64  						classHDD: &StorageResource{
    65  							Requested: 30,
    66  							Capacity:  100,
    67  						},
    68  					},
    69  					30,
    70  				},
    71  				{
    72  					classResourceMap{
    73  						classHDD: &StorageResource{
    74  							Requested: 50,
    75  							Capacity:  100,
    76  						},
    77  					},
    78  					50,
    79  				},
    80  				{
    81  					classResourceMap{
    82  						classHDD: &StorageResource{
    83  							Requested: 100,
    84  							Capacity:  100,
    85  						},
    86  					},
    87  					100,
    88  				},
    89  			},
    90  		},
    91  		{
    92  			name:  "default shape, multiple classes",
    93  			shape: defaultShape,
    94  			cases: []scoreCase{
    95  				{
    96  					classResourceMap{
    97  						classHDD: &StorageResource{
    98  							Requested: 0,
    99  							Capacity:  100,
   100  						},
   101  						classSSD: &StorageResource{
   102  							Requested: 0,
   103  							Capacity:  100,
   104  						},
   105  					},
   106  					0,
   107  				},
   108  				{
   109  					classResourceMap{
   110  						classHDD: &StorageResource{
   111  							Requested: 0,
   112  							Capacity:  100,
   113  						},
   114  						classSSD: &StorageResource{
   115  							Requested: 30,
   116  							Capacity:  100,
   117  						},
   118  					},
   119  					15,
   120  				},
   121  				{
   122  					classResourceMap{
   123  						classHDD: &StorageResource{
   124  							Requested: 30,
   125  							Capacity:  100,
   126  						},
   127  						classSSD: &StorageResource{
   128  							Requested: 30,
   129  							Capacity:  100,
   130  						},
   131  					},
   132  					30,
   133  				},
   134  				{
   135  					classResourceMap{
   136  						classHDD: &StorageResource{
   137  							Requested: 30,
   138  							Capacity:  100,
   139  						},
   140  						classSSD: &StorageResource{
   141  							Requested: 60,
   142  							Capacity:  100,
   143  						},
   144  					},
   145  					45,
   146  				},
   147  				{
   148  					classResourceMap{
   149  						classHDD: &StorageResource{
   150  							Requested: 50,
   151  							Capacity:  100,
   152  						},
   153  						classSSD: &StorageResource{
   154  							Requested: 50,
   155  							Capacity:  100,
   156  						},
   157  					},
   158  					50,
   159  				},
   160  				{
   161  					classResourceMap{
   162  						classHDD: &StorageResource{
   163  							Requested: 50,
   164  							Capacity:  100,
   165  						},
   166  						classSSD: &StorageResource{
   167  							Requested: 100,
   168  							Capacity:  100,
   169  						},
   170  					},
   171  					75,
   172  				},
   173  				{
   174  					classResourceMap{
   175  						classHDD: &StorageResource{
   176  							Requested: 100,
   177  							Capacity:  100,
   178  						},
   179  						classSSD: &StorageResource{
   180  							Requested: 100,
   181  							Capacity:  100,
   182  						},
   183  					},
   184  					100,
   185  				},
   186  			},
   187  		},
   188  		{
   189  			name: "custom shape, multiple classes",
   190  			shape: helper.FunctionShape{
   191  				{
   192  					Utilization: 50,
   193  					Score:       0,
   194  				},
   195  				{
   196  					Utilization: 80,
   197  					Score:       30,
   198  				},
   199  				{
   200  					Utilization: 100,
   201  					Score:       50,
   202  				},
   203  			},
   204  			cases: []scoreCase{
   205  				{
   206  					classResourceMap{
   207  						classHDD: &StorageResource{
   208  							Requested: 0,
   209  							Capacity:  100,
   210  						},
   211  						classSSD: &StorageResource{
   212  							Requested: 0,
   213  							Capacity:  100,
   214  						},
   215  					},
   216  					0,
   217  				},
   218  				{
   219  					classResourceMap{
   220  						classHDD: &StorageResource{
   221  							Requested: 0,
   222  							Capacity:  100,
   223  						},
   224  						classSSD: &StorageResource{
   225  							Requested: 30,
   226  							Capacity:  100,
   227  						},
   228  					},
   229  					0,
   230  				},
   231  				{
   232  					classResourceMap{
   233  						classHDD: &StorageResource{
   234  							Requested: 30,
   235  							Capacity:  100,
   236  						},
   237  						classSSD: &StorageResource{
   238  							Requested: 30,
   239  							Capacity:  100,
   240  						},
   241  					},
   242  					0,
   243  				},
   244  				{
   245  					classResourceMap{
   246  						classHDD: &StorageResource{
   247  							Requested: 30,
   248  							Capacity:  100,
   249  						},
   250  						classSSD: &StorageResource{
   251  							Requested: 60,
   252  							Capacity:  100,
   253  						},
   254  					},
   255  					5,
   256  				},
   257  				{
   258  					classResourceMap{
   259  						classHDD: &StorageResource{
   260  							Requested: 50,
   261  							Capacity:  100,
   262  						},
   263  						classSSD: &StorageResource{
   264  							Requested: 100,
   265  							Capacity:  100,
   266  						},
   267  					},
   268  					25,
   269  				},
   270  				{
   271  					classResourceMap{
   272  						classHDD: &StorageResource{
   273  							Requested: 90,
   274  							Capacity:  100,
   275  						},
   276  						classSSD: &StorageResource{
   277  							Requested: 90,
   278  							Capacity:  100,
   279  						},
   280  					},
   281  					40,
   282  				},
   283  				{
   284  					classResourceMap{
   285  						classHDD: &StorageResource{
   286  							Requested: 100,
   287  							Capacity:  100,
   288  						},
   289  						classSSD: &StorageResource{
   290  							Requested: 100,
   291  							Capacity:  100,
   292  						},
   293  					},
   294  					50,
   295  				},
   296  			},
   297  		},
   298  	}
   299  
   300  	for _, tt := range tests {
   301  		t.Run(tt.name, func(t *testing.T) {
   302  			f := buildScorerFunction(tt.shape)
   303  			for _, c := range tt.cases {
   304  				gotScore := f(c.classResources)
   305  				if gotScore != c.score {
   306  					t.Errorf("Expect %d, but got %d", c.score, gotScore)
   307  				}
   308  			}
   309  		})
   310  	}
   311  }
   312
View as plain text