mock_client.go

Documentation: edge-infra.dev/pkg/sds/lib/k8s/retryclient/mocks

     1  // Code generated by MockGen. DO NOT EDIT.
     2  // Source: sigs.k8s.io/controller-runtime/pkg/client (interfaces: Client)
     3  
     4  // Package mocks is a generated GoMock package.
     5  package mocks
     6  
     7  import (
     8  	context "context"
     9  	reflect "reflect"
    10  
    11  	gomock "github.com/golang/mock/gomock"
    12  	meta "k8s.io/apimachinery/pkg/api/meta"
    13  	runtime "k8s.io/apimachinery/pkg/runtime"
    14  	schema "k8s.io/apimachinery/pkg/runtime/schema"
    15  	types "k8s.io/apimachinery/pkg/types"
    16  	client "sigs.k8s.io/controller-runtime/pkg/client"
    17  )
    18  
    19  // MockClient is a mock of Client interface.
    20  type MockClient struct {
    21  	ctrl     *gomock.Controller
    22  	recorder *MockClientMockRecorder
    23  }
    24  
    25  // MockClientMockRecorder is the mock recorder for MockClient.
    26  type MockClientMockRecorder struct {
    27  	mock *MockClient
    28  }
    29  
    30  // NewMockClient creates a new mock instance.
    31  func NewMockClient(ctrl *gomock.Controller) *MockClient {
    32  	mock := &MockClient{ctrl: ctrl}
    33  	mock.recorder = &MockClientMockRecorder{mock}
    34  	return mock
    35  }
    36  
    37  // EXPECT returns an object that allows the caller to indicate expected use.
    38  func (m *MockClient) EXPECT() *MockClientMockRecorder {
    39  	return m.recorder
    40  }
    41  
    42  // Create mocks base method.
    43  func (m *MockClient) Create(arg0 context.Context, arg1 client.Object, arg2 ...client.CreateOption) error {
    44  	m.ctrl.T.Helper()
    45  	varargs := []interface{}{arg0, arg1}
    46  	for _, a := range arg2 {
    47  		varargs = append(varargs, a)
    48  	}
    49  	ret := m.ctrl.Call(m, "Create", varargs...)
    50  	ret0, _ := ret[0].(error)
    51  	return ret0
    52  }
    53  
    54  // Create indicates an expected call of Create.
    55  func (mr *MockClientMockRecorder) Create(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
    56  	mr.mock.ctrl.T.Helper()
    57  	varargs := append([]interface{}{arg0, arg1}, arg2...)
    58  	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Create", reflect.TypeOf((*MockClient)(nil).Create), varargs...)
    59  }
    60  
    61  // Delete mocks base method.
    62  func (m *MockClient) Delete(arg0 context.Context, arg1 client.Object, arg2 ...client.DeleteOption) error {
    63  	m.ctrl.T.Helper()
    64  	varargs := []interface{}{arg0, arg1}
    65  	for _, a := range arg2 {
    66  		varargs = append(varargs, a)
    67  	}
    68  	ret := m.ctrl.Call(m, "Delete", varargs...)
    69  	ret0, _ := ret[0].(error)
    70  	return ret0
    71  }
    72  
    73  // Delete indicates an expected call of Delete.
    74  func (mr *MockClientMockRecorder) Delete(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
    75  	mr.mock.ctrl.T.Helper()
    76  	varargs := append([]interface{}{arg0, arg1}, arg2...)
    77  	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Delete", reflect.TypeOf((*MockClient)(nil).Delete), varargs...)
    78  }
    79  
    80  // DeleteAllOf mocks base method.
    81  func (m *MockClient) DeleteAllOf(arg0 context.Context, arg1 client.Object, arg2 ...client.DeleteAllOfOption) error {
    82  	m.ctrl.T.Helper()
    83  	varargs := []interface{}{arg0, arg1}
    84  	for _, a := range arg2 {
    85  		varargs = append(varargs, a)
    86  	}
    87  	ret := m.ctrl.Call(m, "DeleteAllOf", varargs...)
    88  	ret0, _ := ret[0].(error)
    89  	return ret0
    90  }
    91  
    92  // DeleteAllOf indicates an expected call of DeleteAllOf.
    93  func (mr *MockClientMockRecorder) DeleteAllOf(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
    94  	mr.mock.ctrl.T.Helper()
    95  	varargs := append([]interface{}{arg0, arg1}, arg2...)
    96  	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteAllOf", reflect.TypeOf((*MockClient)(nil).DeleteAllOf), varargs...)
    97  }
    98  
    99  // Get mocks base method.
   100  func (m *MockClient) Get(arg0 context.Context, arg1 types.NamespacedName, arg2 client.Object, arg3 ...client.GetOption) error {
   101  	m.ctrl.T.Helper()
   102  	varargs := []interface{}{arg0, arg1, arg2}
   103  	for _, a := range arg3 {
   104  		varargs = append(varargs, a)
   105  	}
   106  	ret := m.ctrl.Call(m, "Get", varargs...)
   107  	ret0, _ := ret[0].(error)
   108  	return ret0
   109  }
   110  
   111  // Get indicates an expected call of Get.
   112  func (mr *MockClientMockRecorder) Get(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call {
   113  	mr.mock.ctrl.T.Helper()
   114  	varargs := append([]interface{}{arg0, arg1, arg2}, arg3...)
   115  	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Get", reflect.TypeOf((*MockClient)(nil).Get), varargs...)
   116  }
   117  
   118  // GroupVersionKindFor mocks base method.
   119  func (m *MockClient) GroupVersionKindFor(arg0 runtime.Object) (schema.GroupVersionKind, error) {
   120  	m.ctrl.T.Helper()
   121  	ret := m.ctrl.Call(m, "GroupVersionKindFor", arg0)
   122  	ret0, _ := ret[0].(schema.GroupVersionKind)
   123  	ret1, _ := ret[1].(error)
   124  	return ret0, ret1
   125  }
   126  
   127  // GroupVersionKindFor indicates an expected call of GroupVersionKindFor.
   128  func (mr *MockClientMockRecorder) GroupVersionKindFor(arg0 interface{}) *gomock.Call {
   129  	mr.mock.ctrl.T.Helper()
   130  	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GroupVersionKindFor", reflect.TypeOf((*MockClient)(nil).GroupVersionKindFor), arg0)
   131  }
   132  
   133  // IsObjectNamespaced mocks base method.
   134  func (m *MockClient) IsObjectNamespaced(arg0 runtime.Object) (bool, error) {
   135  	m.ctrl.T.Helper()
   136  	ret := m.ctrl.Call(m, "IsObjectNamespaced", arg0)
   137  	ret0, _ := ret[0].(bool)
   138  	ret1, _ := ret[1].(error)
   139  	return ret0, ret1
   140  }
   141  
   142  // IsObjectNamespaced indicates an expected call of IsObjectNamespaced.
   143  func (mr *MockClientMockRecorder) IsObjectNamespaced(arg0 interface{}) *gomock.Call {
   144  	mr.mock.ctrl.T.Helper()
   145  	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsObjectNamespaced", reflect.TypeOf((*MockClient)(nil).IsObjectNamespaced), arg0)
   146  }
   147  
   148  // List mocks base method.
   149  func (m *MockClient) List(arg0 context.Context, arg1 client.ObjectList, arg2 ...client.ListOption) error {
   150  	m.ctrl.T.Helper()
   151  	varargs := []interface{}{arg0, arg1}
   152  	for _, a := range arg2 {
   153  		varargs = append(varargs, a)
   154  	}
   155  	ret := m.ctrl.Call(m, "List", varargs...)
   156  	ret0, _ := ret[0].(error)
   157  	return ret0
   158  }
   159  
   160  // List indicates an expected call of List.
   161  func (mr *MockClientMockRecorder) List(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
   162  	mr.mock.ctrl.T.Helper()
   163  	varargs := append([]interface{}{arg0, arg1}, arg2...)
   164  	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "List", reflect.TypeOf((*MockClient)(nil).List), varargs...)
   165  }
   166  
   167  // Patch mocks base method.
   168  func (m *MockClient) Patch(arg0 context.Context, arg1 client.Object, arg2 client.Patch, arg3 ...client.PatchOption) error {
   169  	m.ctrl.T.Helper()
   170  	varargs := []interface{}{arg0, arg1, arg2}
   171  	for _, a := range arg3 {
   172  		varargs = append(varargs, a)
   173  	}
   174  	ret := m.ctrl.Call(m, "Patch", varargs...)
   175  	ret0, _ := ret[0].(error)
   176  	return ret0
   177  }
   178  
   179  // Patch indicates an expected call of Patch.
   180  func (mr *MockClientMockRecorder) Patch(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call {
   181  	mr.mock.ctrl.T.Helper()
   182  	varargs := append([]interface{}{arg0, arg1, arg2}, arg3...)
   183  	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Patch", reflect.TypeOf((*MockClient)(nil).Patch), varargs...)
   184  }
   185  
   186  // RESTMapper mocks base method.
   187  func (m *MockClient) RESTMapper() meta.RESTMapper {
   188  	m.ctrl.T.Helper()
   189  	ret := m.ctrl.Call(m, "RESTMapper")
   190  	ret0, _ := ret[0].(meta.RESTMapper)
   191  	return ret0
   192  }
   193  
   194  // RESTMapper indicates an expected call of RESTMapper.
   195  func (mr *MockClientMockRecorder) RESTMapper() *gomock.Call {
   196  	mr.mock.ctrl.T.Helper()
   197  	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RESTMapper", reflect.TypeOf((*MockClient)(nil).RESTMapper))
   198  }
   199  
   200  // Scheme mocks base method.
   201  func (m *MockClient) Scheme() *runtime.Scheme {
   202  	m.ctrl.T.Helper()
   203  	ret := m.ctrl.Call(m, "Scheme")
   204  	ret0, _ := ret[0].(*runtime.Scheme)
   205  	return ret0
   206  }
   207  
   208  // Scheme indicates an expected call of Scheme.
   209  func (mr *MockClientMockRecorder) Scheme() *gomock.Call {
   210  	mr.mock.ctrl.T.Helper()
   211  	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Scheme", reflect.TypeOf((*MockClient)(nil).Scheme))
   212  }
   213  
   214  // Status mocks base method.
   215  func (m *MockClient) Status() client.SubResourceWriter {
   216  	m.ctrl.T.Helper()
   217  	ret := m.ctrl.Call(m, "Status")
   218  	ret0, _ := ret[0].(client.SubResourceWriter)
   219  	return ret0
   220  }
   221  
   222  // Status indicates an expected call of Status.
   223  func (mr *MockClientMockRecorder) Status() *gomock.Call {
   224  	mr.mock.ctrl.T.Helper()
   225  	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Status", reflect.TypeOf((*MockClient)(nil).Status))
   226  }
   227  
   228  // SubResource mocks base method.
   229  func (m *MockClient) SubResource(arg0 string) client.SubResourceClient {
   230  	m.ctrl.T.Helper()
   231  	ret := m.ctrl.Call(m, "SubResource", arg0)
   232  	ret0, _ := ret[0].(client.SubResourceClient)
   233  	return ret0
   234  }
   235  
   236  // SubResource indicates an expected call of SubResource.
   237  func (mr *MockClientMockRecorder) SubResource(arg0 interface{}) *gomock.Call {
   238  	mr.mock.ctrl.T.Helper()
   239  	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SubResource", reflect.TypeOf((*MockClient)(nil).SubResource), arg0)
   240  }
   241  
   242  // Update mocks base method.
   243  func (m *MockClient) Update(arg0 context.Context, arg1 client.Object, arg2 ...client.UpdateOption) error {
   244  	m.ctrl.T.Helper()
   245  	varargs := []interface{}{arg0, arg1}
   246  	for _, a := range arg2 {
   247  		varargs = append(varargs, a)
   248  	}
   249  	ret := m.ctrl.Call(m, "Update", varargs...)
   250  	ret0, _ := ret[0].(error)
   251  	return ret0
   252  }
   253  
   254  // Update indicates an expected call of Update.
   255  func (mr *MockClientMockRecorder) Update(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
   256  	mr.mock.ctrl.T.Helper()
   257  	varargs := append([]interface{}{arg0, arg1}, arg2...)
   258  	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Update", reflect.TypeOf((*MockClient)(nil).Update), varargs...)
   259  }
   260
View as plain text