mock_threshold_notifier_test.go

Documentation: k8s.io/kubernetes/pkg/kubelet/eviction

     1  /*
     2  Copyright 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  // Code generated by MockGen. DO NOT EDIT.
    18  // Source: types.go
    19  
    20  // Package eviction is a generated GoMock package.
    21  package eviction
    22  
    23  import (
    24  	context "context"
    25  	reflect "reflect"
    26  	time "time"
    27  
    28  	gomock "github.com/golang/mock/gomock"
    29  	v1alpha1 "k8s.io/kubelet/pkg/apis/stats/v1alpha1"
    30  )
    31  
    32  // MockManager is a mock of Manager interface.
    33  type MockManager struct {
    34  	ctrl     *gomock.Controller
    35  	recorder *MockManagerMockRecorder
    36  }
    37  
    38  // MockManagerMockRecorder is the mock recorder for MockManager.
    39  type MockManagerMockRecorder struct {
    40  	mock *MockManager
    41  }
    42  
    43  // NewMockManager creates a new mock instance.
    44  func NewMockManager(ctrl *gomock.Controller) *MockManager {
    45  	mock := &MockManager{ctrl: ctrl}
    46  	mock.recorder = &MockManagerMockRecorder{mock}
    47  	return mock
    48  }
    49  
    50  // EXPECT returns an object that allows the caller to indicate expected use.
    51  func (m *MockManager) EXPECT() *MockManagerMockRecorder {
    52  	return m.recorder
    53  }
    54  
    55  // IsUnderDiskPressure mocks base method.
    56  func (m *MockManager) IsUnderDiskPressure() bool {
    57  	m.ctrl.T.Helper()
    58  	ret := m.ctrl.Call(m, "IsUnderDiskPressure")
    59  	ret0, _ := ret[0].(bool)
    60  	return ret0
    61  }
    62  
    63  // IsUnderDiskPressure indicates an expected call of IsUnderDiskPressure.
    64  func (mr *MockManagerMockRecorder) IsUnderDiskPressure() *gomock.Call {
    65  	mr.mock.ctrl.T.Helper()
    66  	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsUnderDiskPressure", reflect.TypeOf((*MockManager)(nil).IsUnderDiskPressure))
    67  }
    68  
    69  // IsUnderMemoryPressure mocks base method.
    70  func (m *MockManager) IsUnderMemoryPressure() bool {
    71  	m.ctrl.T.Helper()
    72  	ret := m.ctrl.Call(m, "IsUnderMemoryPressure")
    73  	ret0, _ := ret[0].(bool)
    74  	return ret0
    75  }
    76  
    77  // IsUnderMemoryPressure indicates an expected call of IsUnderMemoryPressure.
    78  func (mr *MockManagerMockRecorder) IsUnderMemoryPressure() *gomock.Call {
    79  	mr.mock.ctrl.T.Helper()
    80  	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsUnderMemoryPressure", reflect.TypeOf((*MockManager)(nil).IsUnderMemoryPressure))
    81  }
    82  
    83  // IsUnderPIDPressure mocks base method.
    84  func (m *MockManager) IsUnderPIDPressure() bool {
    85  	m.ctrl.T.Helper()
    86  	ret := m.ctrl.Call(m, "IsUnderPIDPressure")
    87  	ret0, _ := ret[0].(bool)
    88  	return ret0
    89  }
    90  
    91  // IsUnderPIDPressure indicates an expected call of IsUnderPIDPressure.
    92  func (mr *MockManagerMockRecorder) IsUnderPIDPressure() *gomock.Call {
    93  	mr.mock.ctrl.T.Helper()
    94  	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsUnderPIDPressure", reflect.TypeOf((*MockManager)(nil).IsUnderPIDPressure))
    95  }
    96  
    97  // Start mocks base method.
    98  func (m *MockManager) Start(diskInfoProvider DiskInfoProvider, podFunc ActivePodsFunc, podCleanedUpFunc PodCleanedUpFunc, monitoringInterval time.Duration) {
    99  	m.ctrl.T.Helper()
   100  	m.ctrl.Call(m, "Start", diskInfoProvider, podFunc, podCleanedUpFunc, monitoringInterval)
   101  }
   102  
   103  // Start indicates an expected call of Start.
   104  func (mr *MockManagerMockRecorder) Start(diskInfoProvider, podFunc, podCleanedUpFunc, monitoringInterval interface{}) *gomock.Call {
   105  	mr.mock.ctrl.T.Helper()
   106  	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Start", reflect.TypeOf((*MockManager)(nil).Start), diskInfoProvider, podFunc, podCleanedUpFunc, monitoringInterval)
   107  }
   108  
   109  // MockDiskInfoProvider is a mock of DiskInfoProvider interface.
   110  type MockDiskInfoProvider struct {
   111  	ctrl     *gomock.Controller
   112  	recorder *MockDiskInfoProviderMockRecorder
   113  }
   114  
   115  // MockDiskInfoProviderMockRecorder is the mock recorder for MockDiskInfoProvider.
   116  type MockDiskInfoProviderMockRecorder struct {
   117  	mock *MockDiskInfoProvider
   118  }
   119  
   120  // NewMockDiskInfoProvider creates a new mock instance.
   121  func NewMockDiskInfoProvider(ctrl *gomock.Controller) *MockDiskInfoProvider {
   122  	mock := &MockDiskInfoProvider{ctrl: ctrl}
   123  	mock.recorder = &MockDiskInfoProviderMockRecorder{mock}
   124  	return mock
   125  }
   126  
   127  // EXPECT returns an object that allows the caller to indicate expected use.
   128  func (m *MockDiskInfoProvider) EXPECT() *MockDiskInfoProviderMockRecorder {
   129  	return m.recorder
   130  }
   131  
   132  // HasDedicatedImageFs mocks base method.
   133  func (m *MockDiskInfoProvider) HasDedicatedImageFs(ctx context.Context) (bool, error) {
   134  	m.ctrl.T.Helper()
   135  	ret := m.ctrl.Call(m, "HasDedicatedImageFs", ctx)
   136  	ret0, _ := ret[0].(bool)
   137  	ret1, _ := ret[1].(error)
   138  	return ret0, ret1
   139  }
   140  
   141  // HasDedicatedImageFs indicates an expected call of HasDedicatedImageFs.
   142  func (mr *MockDiskInfoProviderMockRecorder) HasDedicatedImageFs(ctx interface{}) *gomock.Call {
   143  	mr.mock.ctrl.T.Helper()
   144  	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HasDedicatedImageFs", reflect.TypeOf((*MockDiskInfoProvider)(nil).HasDedicatedImageFs), ctx)
   145  }
   146  
   147  // MockImageGC is a mock of ImageGC interface.
   148  type MockImageGC struct {
   149  	ctrl     *gomock.Controller
   150  	recorder *MockImageGCMockRecorder
   151  }
   152  
   153  // MockImageGCMockRecorder is the mock recorder for MockImageGC.
   154  type MockImageGCMockRecorder struct {
   155  	mock *MockImageGC
   156  }
   157  
   158  // NewMockImageGC creates a new mock instance.
   159  func NewMockImageGC(ctrl *gomock.Controller) *MockImageGC {
   160  	mock := &MockImageGC{ctrl: ctrl}
   161  	mock.recorder = &MockImageGCMockRecorder{mock}
   162  	return mock
   163  }
   164  
   165  // EXPECT returns an object that allows the caller to indicate expected use.
   166  func (m *MockImageGC) EXPECT() *MockImageGCMockRecorder {
   167  	return m.recorder
   168  }
   169  
   170  // DeleteUnusedImages mocks base method.
   171  func (m *MockImageGC) DeleteUnusedImages(ctx context.Context) error {
   172  	m.ctrl.T.Helper()
   173  	ret := m.ctrl.Call(m, "DeleteUnusedImages", ctx)
   174  	ret0, _ := ret[0].(error)
   175  	return ret0
   176  }
   177  
   178  // DeleteUnusedImages indicates an expected call of DeleteUnusedImages.
   179  func (mr *MockImageGCMockRecorder) DeleteUnusedImages(ctx interface{}) *gomock.Call {
   180  	mr.mock.ctrl.T.Helper()
   181  	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteUnusedImages", reflect.TypeOf((*MockImageGC)(nil).DeleteUnusedImages), ctx)
   182  }
   183  
   184  // MockContainerGC is a mock of ContainerGC interface.
   185  type MockContainerGC struct {
   186  	ctrl     *gomock.Controller
   187  	recorder *MockContainerGCMockRecorder
   188  }
   189  
   190  // MockContainerGCMockRecorder is the mock recorder for MockContainerGC.
   191  type MockContainerGCMockRecorder struct {
   192  	mock *MockContainerGC
   193  }
   194  
   195  // NewMockContainerGC creates a new mock instance.
   196  func NewMockContainerGC(ctrl *gomock.Controller) *MockContainerGC {
   197  	mock := &MockContainerGC{ctrl: ctrl}
   198  	mock.recorder = &MockContainerGCMockRecorder{mock}
   199  	return mock
   200  }
   201  
   202  // EXPECT returns an object that allows the caller to indicate expected use.
   203  func (m *MockContainerGC) EXPECT() *MockContainerGCMockRecorder {
   204  	return m.recorder
   205  }
   206  
   207  // DeleteAllUnusedContainers mocks base method.
   208  func (m *MockContainerGC) DeleteAllUnusedContainers(ctx context.Context) error {
   209  	m.ctrl.T.Helper()
   210  	ret := m.ctrl.Call(m, "DeleteAllUnusedContainers", ctx)
   211  	ret0, _ := ret[0].(error)
   212  	return ret0
   213  }
   214  
   215  // DeleteAllUnusedContainers indicates an expected call of DeleteAllUnusedContainers.
   216  func (mr *MockContainerGCMockRecorder) DeleteAllUnusedContainers(ctx interface{}) *gomock.Call {
   217  	mr.mock.ctrl.T.Helper()
   218  	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteAllUnusedContainers", reflect.TypeOf((*MockContainerGC)(nil).DeleteAllUnusedContainers), ctx)
   219  }
   220  
   221  // IsContainerFsSeparateFromImageFs mocks base method.
   222  func (m *MockContainerGC) IsContainerFsSeparateFromImageFs(ctx context.Context) bool {
   223  	m.ctrl.T.Helper()
   224  	ret := m.ctrl.Call(m, "IsContainerFsSeparateFromImageFs", ctx)
   225  	ret0, _ := ret[0].(bool)
   226  	return ret0
   227  }
   228  
   229  // IsContainerFsSeparateFromImageFs indicates an expected call of IsContainerFsSeparateFromImageFs.
   230  func (mr *MockContainerGCMockRecorder) IsContainerFsSeparateFromImageFs(ctx interface{}) *gomock.Call {
   231  	mr.mock.ctrl.T.Helper()
   232  	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsContainerFsSeparateFromImageFs", reflect.TypeOf((*MockContainerGC)(nil).IsContainerFsSeparateFromImageFs), ctx)
   233  }
   234  
   235  // MockCgroupNotifier is a mock of CgroupNotifier interface.
   236  type MockCgroupNotifier struct {
   237  	ctrl     *gomock.Controller
   238  	recorder *MockCgroupNotifierMockRecorder
   239  }
   240  
   241  // MockCgroupNotifierMockRecorder is the mock recorder for MockCgroupNotifier.
   242  type MockCgroupNotifierMockRecorder struct {
   243  	mock *MockCgroupNotifier
   244  }
   245  
   246  // NewMockCgroupNotifier creates a new mock instance.
   247  func NewMockCgroupNotifier(ctrl *gomock.Controller) *MockCgroupNotifier {
   248  	mock := &MockCgroupNotifier{ctrl: ctrl}
   249  	mock.recorder = &MockCgroupNotifierMockRecorder{mock}
   250  	return mock
   251  }
   252  
   253  // EXPECT returns an object that allows the caller to indicate expected use.
   254  func (m *MockCgroupNotifier) EXPECT() *MockCgroupNotifierMockRecorder {
   255  	return m.recorder
   256  }
   257  
   258  // Start mocks base method.
   259  func (m *MockCgroupNotifier) Start(eventCh chan<- struct{}) {
   260  	m.ctrl.T.Helper()
   261  	m.ctrl.Call(m, "Start", eventCh)
   262  }
   263  
   264  // Start indicates an expected call of Start.
   265  func (mr *MockCgroupNotifierMockRecorder) Start(eventCh interface{}) *gomock.Call {
   266  	mr.mock.ctrl.T.Helper()
   267  	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Start", reflect.TypeOf((*MockCgroupNotifier)(nil).Start), eventCh)
   268  }
   269  
   270  // Stop mocks base method.
   271  func (m *MockCgroupNotifier) Stop() {
   272  	m.ctrl.T.Helper()
   273  	m.ctrl.Call(m, "Stop")
   274  }
   275  
   276  // Stop indicates an expected call of Stop.
   277  func (mr *MockCgroupNotifierMockRecorder) Stop() *gomock.Call {
   278  	mr.mock.ctrl.T.Helper()
   279  	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Stop", reflect.TypeOf((*MockCgroupNotifier)(nil).Stop))
   280  }
   281  
   282  // MockNotifierFactory is a mock of NotifierFactory interface.
   283  type MockNotifierFactory struct {
   284  	ctrl     *gomock.Controller
   285  	recorder *MockNotifierFactoryMockRecorder
   286  }
   287  
   288  // MockNotifierFactoryMockRecorder is the mock recorder for MockNotifierFactory.
   289  type MockNotifierFactoryMockRecorder struct {
   290  	mock *MockNotifierFactory
   291  }
   292  
   293  // NewMockNotifierFactory creates a new mock instance.
   294  func NewMockNotifierFactory(ctrl *gomock.Controller) *MockNotifierFactory {
   295  	mock := &MockNotifierFactory{ctrl: ctrl}
   296  	mock.recorder = &MockNotifierFactoryMockRecorder{mock}
   297  	return mock
   298  }
   299  
   300  // EXPECT returns an object that allows the caller to indicate expected use.
   301  func (m *MockNotifierFactory) EXPECT() *MockNotifierFactoryMockRecorder {
   302  	return m.recorder
   303  }
   304  
   305  // NewCgroupNotifier mocks base method.
   306  func (m *MockNotifierFactory) NewCgroupNotifier(path, attribute string, threshold int64) (CgroupNotifier, error) {
   307  	m.ctrl.T.Helper()
   308  	ret := m.ctrl.Call(m, "NewCgroupNotifier", path, attribute, threshold)
   309  	ret0, _ := ret[0].(CgroupNotifier)
   310  	ret1, _ := ret[1].(error)
   311  	return ret0, ret1
   312  }
   313  
   314  // NewCgroupNotifier indicates an expected call of NewCgroupNotifier.
   315  func (mr *MockNotifierFactoryMockRecorder) NewCgroupNotifier(path, attribute, threshold interface{}) *gomock.Call {
   316  	mr.mock.ctrl.T.Helper()
   317  	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewCgroupNotifier", reflect.TypeOf((*MockNotifierFactory)(nil).NewCgroupNotifier), path, attribute, threshold)
   318  }
   319  
   320  // MockThresholdNotifier is a mock of ThresholdNotifier interface.
   321  type MockThresholdNotifier struct {
   322  	ctrl     *gomock.Controller
   323  	recorder *MockThresholdNotifierMockRecorder
   324  }
   325  
   326  // MockThresholdNotifierMockRecorder is the mock recorder for MockThresholdNotifier.
   327  type MockThresholdNotifierMockRecorder struct {
   328  	mock *MockThresholdNotifier
   329  }
   330  
   331  // NewMockThresholdNotifier creates a new mock instance.
   332  func NewMockThresholdNotifier(ctrl *gomock.Controller) *MockThresholdNotifier {
   333  	mock := &MockThresholdNotifier{ctrl: ctrl}
   334  	mock.recorder = &MockThresholdNotifierMockRecorder{mock}
   335  	return mock
   336  }
   337  
   338  // EXPECT returns an object that allows the caller to indicate expected use.
   339  func (m *MockThresholdNotifier) EXPECT() *MockThresholdNotifierMockRecorder {
   340  	return m.recorder
   341  }
   342  
   343  // Description mocks base method.
   344  func (m *MockThresholdNotifier) Description() string {
   345  	m.ctrl.T.Helper()
   346  	ret := m.ctrl.Call(m, "Description")
   347  	ret0, _ := ret[0].(string)
   348  	return ret0
   349  }
   350  
   351  // Description indicates an expected call of Description.
   352  func (mr *MockThresholdNotifierMockRecorder) Description() *gomock.Call {
   353  	mr.mock.ctrl.T.Helper()
   354  	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Description", reflect.TypeOf((*MockThresholdNotifier)(nil).Description))
   355  }
   356  
   357  // Start mocks base method.
   358  func (m *MockThresholdNotifier) Start() {
   359  	m.ctrl.T.Helper()
   360  	m.ctrl.Call(m, "Start")
   361  }
   362  
   363  // Start indicates an expected call of Start.
   364  func (mr *MockThresholdNotifierMockRecorder) Start() *gomock.Call {
   365  	mr.mock.ctrl.T.Helper()
   366  	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Start", reflect.TypeOf((*MockThresholdNotifier)(nil).Start))
   367  }
   368  
   369  // UpdateThreshold mocks base method.
   370  func (m *MockThresholdNotifier) UpdateThreshold(summary *v1alpha1.Summary) error {
   371  	m.ctrl.T.Helper()
   372  	ret := m.ctrl.Call(m, "UpdateThreshold", summary)
   373  	ret0, _ := ret[0].(error)
   374  	return ret0
   375  }
   376  
   377  // UpdateThreshold indicates an expected call of UpdateThreshold.
   378  func (mr *MockThresholdNotifierMockRecorder) UpdateThreshold(summary interface{}) *gomock.Call {
   379  	mr.mock.ctrl.T.Helper()
   380  	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateThreshold", reflect.TypeOf((*MockThresholdNotifier)(nil).UpdateThreshold), summary)
   381  }
   382
View as plain text