pod_resources_test.go

Documentation: k8s.io/kubernetes/pkg/scheduler/util

     1  /*
     2  Copyright 2017 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  	"testing"
    21  
    22  	"github.com/stretchr/testify/assert"
    23  
    24  	v1 "k8s.io/api/core/v1"
    25  	"k8s.io/apimachinery/pkg/api/resource"
    26  )
    27  
    28  func TestGetNonZeroRequest(t *testing.T) {
    29  	tests := []struct {
    30  		name           string
    31  		requests       v1.ResourceList
    32  		expectedCPU    int64
    33  		expectedMemory int64
    34  	}{
    35  		{
    36  			"cpu_and_memory_not_found",
    37  			v1.ResourceList{},
    38  			DefaultMilliCPURequest,
    39  			DefaultMemoryRequest,
    40  		},
    41  		{
    42  			"only_cpu_exist",
    43  			v1.ResourceList{
    44  				v1.ResourceCPU: resource.MustParse("200m"),
    45  			},
    46  			200,
    47  			DefaultMemoryRequest,
    48  		},
    49  		{
    50  			"only_memory_exist",
    51  			v1.ResourceList{
    52  				v1.ResourceMemory: resource.MustParse("400Mi"),
    53  			},
    54  			DefaultMilliCPURequest,
    55  			400 * 1024 * 1024,
    56  		},
    57  		{
    58  			"cpu_memory_exist",
    59  			v1.ResourceList{
    60  				v1.ResourceCPU:    resource.MustParse("200m"),
    61  				v1.ResourceMemory: resource.MustParse("400Mi"),
    62  			},
    63  			200,
    64  			400 * 1024 * 1024,
    65  		},
    66  	}
    67  
    68  	for _, test := range tests {
    69  		t.Run(test.name, func(t *testing.T) {
    70  			realCPU, realMemory := GetNonzeroRequests(&test.requests)
    71  			assert.EqualValuesf(t, test.expectedCPU, realCPU, "Failed to test: %s", test.name)
    72  			assert.EqualValuesf(t, test.expectedMemory, realMemory, "Failed to test: %s", test.name)
    73  		})
    74  	}
    75  }
    76  
    77  func TestGetRequestForResource(t *testing.T) {
    78  	tests := []struct {
    79  		name             string
    80  		requests         v1.ResourceList
    81  		resource         v1.ResourceName
    82  		expectedQuantity int64
    83  		nonZero          bool
    84  	}{
    85  		{
    86  			"extended_resource_not_found",
    87  			v1.ResourceList{},
    88  			v1.ResourceName("intel.com/foo"),
    89  			0,
    90  			true,
    91  		},
    92  		{
    93  			"extended_resource_found",
    94  			v1.ResourceList{
    95  				v1.ResourceName("intel.com/foo"): resource.MustParse("4"),
    96  			},
    97  			v1.ResourceName("intel.com/foo"),
    98  			4,
    99  			true,
   100  		},
   101  		{
   102  			"cpu_not_found",
   103  			v1.ResourceList{},
   104  			v1.ResourceCPU,
   105  			DefaultMilliCPURequest,
   106  			true,
   107  		},
   108  		{
   109  			"memory_not_found",
   110  			v1.ResourceList{},
   111  			v1.ResourceMemory,
   112  			DefaultMemoryRequest,
   113  			true,
   114  		},
   115  		{
   116  			"cpu_exist",
   117  			v1.ResourceList{
   118  				v1.ResourceCPU: resource.MustParse("200m"),
   119  			},
   120  			v1.ResourceCPU,
   121  			200,
   122  			true,
   123  		},
   124  		{
   125  			"memory_exist",
   126  			v1.ResourceList{
   127  				v1.ResourceMemory: resource.MustParse("400Mi"),
   128  			},
   129  			v1.ResourceMemory,
   130  			400 * 1024 * 1024,
   131  			true,
   132  		},
   133  		{
   134  			"ephemeralStorage_exist",
   135  			v1.ResourceList{
   136  				v1.ResourceEphemeralStorage: resource.MustParse("400Mi"),
   137  			},
   138  			v1.ResourceEphemeralStorage,
   139  			400 * 1024 * 1024,
   140  			true,
   141  		},
   142  		{
   143  			"ephemeralStorage_not_found",
   144  			v1.ResourceList{},
   145  			v1.ResourceEphemeralStorage,
   146  			0,
   147  			true,
   148  		},
   149  		{
   150  			"cpu_not_found, useRequested is true",
   151  			v1.ResourceList{},
   152  			v1.ResourceCPU,
   153  			0,
   154  			false,
   155  		},
   156  		{
   157  			"memory_not_found, useRequested is true",
   158  			v1.ResourceList{},
   159  			v1.ResourceMemory,
   160  			0,
   161  			false,
   162  		},
   163  	}
   164  
   165  	for _, test := range tests {
   166  		t.Run(test.name, func(t *testing.T) {
   167  			realQuantity := GetRequestForResource(test.resource, &test.requests, test.nonZero)
   168  			var realQuantityI64 int64
   169  			if test.resource == v1.ResourceCPU {
   170  				realQuantityI64 = realQuantity.MilliValue()
   171  			} else {
   172  				realQuantityI64 = realQuantity.Value()
   173  			}
   174  			assert.EqualValuesf(t, test.expectedQuantity, realQuantityI64, "Failed to test: %s", test.name)
   175  		})
   176  	}
   177  }
   178
View as plain text