diff --git a/Makefile b/Makefile index 2196c14..41d39f5 100644 --- a/Makefile +++ b/Makefile @@ -73,8 +73,8 @@ GOLANGCILINT ?= $(LOCALBIN)/golangci-lint ## Tool Versions ADDLICENSE_VERSION ?= v1.1.1 -GOIMPORTS_VERSION ?= v0.25.0 -MOCKGEN_VERSION ?= v0.4.0 +GOIMPORTS_VERSION ?= v0.26.0 +MOCKGEN_VERSION ?= v0.5.0 GOLANGCILINT_VERSION ?= v1.61.0 .PHONY: addlicense diff --git a/mock/controller-runtime/client/funcs.go b/mock/controller-runtime/client/funcs.go index 9b4081b..9ed656f 100644 --- a/mock/controller-runtime/client/funcs.go +++ b/mock/controller-runtime/client/funcs.go @@ -24,6 +24,7 @@ import ( type MockIndexerFunc struct { ctrl *gomock.Controller recorder *MockIndexerFuncMockRecorder + isgomock struct{} } // MockIndexerFuncMockRecorder is the mock recorder for MockIndexerFunc. @@ -44,15 +45,15 @@ func (m *MockIndexerFunc) EXPECT() *MockIndexerFuncMockRecorder { } // Call mocks base method. -func (m *MockIndexerFunc) Call(arg0 client.Object) []string { +func (m *MockIndexerFunc) Call(object client.Object) []string { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Call", arg0) + ret := m.ctrl.Call(m, "Call", object) ret0, _ := ret[0].([]string) return ret0 } // Call indicates an expected call of Call. -func (mr *MockIndexerFuncMockRecorder) Call(arg0 any) *gomock.Call { +func (mr *MockIndexerFuncMockRecorder) Call(object any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Call", reflect.TypeOf((*MockIndexerFunc)(nil).Call), arg0) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Call", reflect.TypeOf((*MockIndexerFunc)(nil).Call), object) } diff --git a/mock/controller-runtime/client/mocks.go b/mock/controller-runtime/client/mocks.go index a9541a4..088fab6 100644 --- a/mock/controller-runtime/client/mocks.go +++ b/mock/controller-runtime/client/mocks.go @@ -29,6 +29,7 @@ import ( type MockClient struct { ctrl *gomock.Controller recorder *MockClientMockRecorder + isgomock struct{} } // MockClientMockRecorder is the mock recorder for MockClient. @@ -49,10 +50,10 @@ func (m *MockClient) EXPECT() *MockClientMockRecorder { } // Create mocks base method. -func (m *MockClient) Create(arg0 context.Context, arg1 client.Object, arg2 ...client.CreateOption) error { +func (m *MockClient) Create(ctx context.Context, obj client.Object, opts ...client.CreateOption) error { m.ctrl.T.Helper() - varargs := []any{arg0, arg1} - for _, a := range arg2 { + varargs := []any{ctx, obj} + for _, a := range opts { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "Create", varargs...) @@ -61,17 +62,17 @@ func (m *MockClient) Create(arg0 context.Context, arg1 client.Object, arg2 ...cl } // Create indicates an expected call of Create. -func (mr *MockClientMockRecorder) Create(arg0, arg1 any, arg2 ...any) *gomock.Call { +func (mr *MockClientMockRecorder) Create(ctx, obj any, opts ...any) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]any{arg0, arg1}, arg2...) + varargs := append([]any{ctx, obj}, opts...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Create", reflect.TypeOf((*MockClient)(nil).Create), varargs...) } // Delete mocks base method. -func (m *MockClient) Delete(arg0 context.Context, arg1 client.Object, arg2 ...client.DeleteOption) error { +func (m *MockClient) Delete(ctx context.Context, obj client.Object, opts ...client.DeleteOption) error { m.ctrl.T.Helper() - varargs := []any{arg0, arg1} - for _, a := range arg2 { + varargs := []any{ctx, obj} + for _, a := range opts { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "Delete", varargs...) @@ -80,17 +81,17 @@ func (m *MockClient) Delete(arg0 context.Context, arg1 client.Object, arg2 ...cl } // Delete indicates an expected call of Delete. -func (mr *MockClientMockRecorder) Delete(arg0, arg1 any, arg2 ...any) *gomock.Call { +func (mr *MockClientMockRecorder) Delete(ctx, obj any, opts ...any) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]any{arg0, arg1}, arg2...) + varargs := append([]any{ctx, obj}, opts...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Delete", reflect.TypeOf((*MockClient)(nil).Delete), varargs...) } // DeleteAllOf mocks base method. -func (m *MockClient) DeleteAllOf(arg0 context.Context, arg1 client.Object, arg2 ...client.DeleteAllOfOption) error { +func (m *MockClient) DeleteAllOf(ctx context.Context, obj client.Object, opts ...client.DeleteAllOfOption) error { m.ctrl.T.Helper() - varargs := []any{arg0, arg1} - for _, a := range arg2 { + varargs := []any{ctx, obj} + for _, a := range opts { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "DeleteAllOf", varargs...) @@ -99,17 +100,17 @@ func (m *MockClient) DeleteAllOf(arg0 context.Context, arg1 client.Object, arg2 } // DeleteAllOf indicates an expected call of DeleteAllOf. -func (mr *MockClientMockRecorder) DeleteAllOf(arg0, arg1 any, arg2 ...any) *gomock.Call { +func (mr *MockClientMockRecorder) DeleteAllOf(ctx, obj any, opts ...any) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]any{arg0, arg1}, arg2...) + varargs := append([]any{ctx, obj}, opts...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteAllOf", reflect.TypeOf((*MockClient)(nil).DeleteAllOf), varargs...) } // Get mocks base method. -func (m *MockClient) Get(arg0 context.Context, arg1 types.NamespacedName, arg2 client.Object, arg3 ...client.GetOption) error { +func (m *MockClient) Get(ctx context.Context, key types.NamespacedName, obj client.Object, opts ...client.GetOption) error { m.ctrl.T.Helper() - varargs := []any{arg0, arg1, arg2} - for _, a := range arg3 { + varargs := []any{ctx, key, obj} + for _, a := range opts { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "Get", varargs...) @@ -118,47 +119,47 @@ func (m *MockClient) Get(arg0 context.Context, arg1 types.NamespacedName, arg2 c } // Get indicates an expected call of Get. -func (mr *MockClientMockRecorder) Get(arg0, arg1, arg2 any, arg3 ...any) *gomock.Call { +func (mr *MockClientMockRecorder) Get(ctx, key, obj any, opts ...any) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]any{arg0, arg1, arg2}, arg3...) + varargs := append([]any{ctx, key, obj}, opts...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Get", reflect.TypeOf((*MockClient)(nil).Get), varargs...) } // GroupVersionKindFor mocks base method. -func (m *MockClient) GroupVersionKindFor(arg0 runtime.Object) (schema.GroupVersionKind, error) { +func (m *MockClient) GroupVersionKindFor(obj runtime.Object) (schema.GroupVersionKind, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GroupVersionKindFor", arg0) + ret := m.ctrl.Call(m, "GroupVersionKindFor", obj) ret0, _ := ret[0].(schema.GroupVersionKind) ret1, _ := ret[1].(error) return ret0, ret1 } // GroupVersionKindFor indicates an expected call of GroupVersionKindFor. -func (mr *MockClientMockRecorder) GroupVersionKindFor(arg0 any) *gomock.Call { +func (mr *MockClientMockRecorder) GroupVersionKindFor(obj any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GroupVersionKindFor", reflect.TypeOf((*MockClient)(nil).GroupVersionKindFor), arg0) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GroupVersionKindFor", reflect.TypeOf((*MockClient)(nil).GroupVersionKindFor), obj) } // IsObjectNamespaced mocks base method. -func (m *MockClient) IsObjectNamespaced(arg0 runtime.Object) (bool, error) { +func (m *MockClient) IsObjectNamespaced(obj runtime.Object) (bool, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "IsObjectNamespaced", arg0) + ret := m.ctrl.Call(m, "IsObjectNamespaced", obj) ret0, _ := ret[0].(bool) ret1, _ := ret[1].(error) return ret0, ret1 } // IsObjectNamespaced indicates an expected call of IsObjectNamespaced. -func (mr *MockClientMockRecorder) IsObjectNamespaced(arg0 any) *gomock.Call { +func (mr *MockClientMockRecorder) IsObjectNamespaced(obj any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsObjectNamespaced", reflect.TypeOf((*MockClient)(nil).IsObjectNamespaced), arg0) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsObjectNamespaced", reflect.TypeOf((*MockClient)(nil).IsObjectNamespaced), obj) } // List mocks base method. -func (m *MockClient) List(arg0 context.Context, arg1 client.ObjectList, arg2 ...client.ListOption) error { +func (m *MockClient) List(ctx context.Context, list client.ObjectList, opts ...client.ListOption) error { m.ctrl.T.Helper() - varargs := []any{arg0, arg1} - for _, a := range arg2 { + varargs := []any{ctx, list} + for _, a := range opts { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "List", varargs...) @@ -167,17 +168,17 @@ func (m *MockClient) List(arg0 context.Context, arg1 client.ObjectList, arg2 ... } // List indicates an expected call of List. -func (mr *MockClientMockRecorder) List(arg0, arg1 any, arg2 ...any) *gomock.Call { +func (mr *MockClientMockRecorder) List(ctx, list any, opts ...any) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]any{arg0, arg1}, arg2...) + varargs := append([]any{ctx, list}, opts...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "List", reflect.TypeOf((*MockClient)(nil).List), varargs...) } // Patch mocks base method. -func (m *MockClient) Patch(arg0 context.Context, arg1 client.Object, arg2 client.Patch, arg3 ...client.PatchOption) error { +func (m *MockClient) Patch(ctx context.Context, obj client.Object, patch client.Patch, opts ...client.PatchOption) error { m.ctrl.T.Helper() - varargs := []any{arg0, arg1, arg2} - for _, a := range arg3 { + varargs := []any{ctx, obj, patch} + for _, a := range opts { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "Patch", varargs...) @@ -186,9 +187,9 @@ func (m *MockClient) Patch(arg0 context.Context, arg1 client.Object, arg2 client } // Patch indicates an expected call of Patch. -func (mr *MockClientMockRecorder) Patch(arg0, arg1, arg2 any, arg3 ...any) *gomock.Call { +func (mr *MockClientMockRecorder) Patch(ctx, obj, patch any, opts ...any) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]any{arg0, arg1, arg2}, arg3...) + varargs := append([]any{ctx, obj, patch}, opts...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Patch", reflect.TypeOf((*MockClient)(nil).Patch), varargs...) } @@ -235,24 +236,24 @@ func (mr *MockClientMockRecorder) Status() *gomock.Call { } // SubResource mocks base method. -func (m *MockClient) SubResource(arg0 string) client.SubResourceClient { +func (m *MockClient) SubResource(subResource string) client.SubResourceClient { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "SubResource", arg0) + ret := m.ctrl.Call(m, "SubResource", subResource) ret0, _ := ret[0].(client.SubResourceClient) return ret0 } // SubResource indicates an expected call of SubResource. -func (mr *MockClientMockRecorder) SubResource(arg0 any) *gomock.Call { +func (mr *MockClientMockRecorder) SubResource(subResource any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SubResource", reflect.TypeOf((*MockClient)(nil).SubResource), arg0) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SubResource", reflect.TypeOf((*MockClient)(nil).SubResource), subResource) } // Update mocks base method. -func (m *MockClient) Update(arg0 context.Context, arg1 client.Object, arg2 ...client.UpdateOption) error { +func (m *MockClient) Update(ctx context.Context, obj client.Object, opts ...client.UpdateOption) error { m.ctrl.T.Helper() - varargs := []any{arg0, arg1} - for _, a := range arg2 { + varargs := []any{ctx, obj} + for _, a := range opts { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "Update", varargs...) @@ -261,9 +262,9 @@ func (m *MockClient) Update(arg0 context.Context, arg1 client.Object, arg2 ...cl } // Update indicates an expected call of Update. -func (mr *MockClientMockRecorder) Update(arg0, arg1 any, arg2 ...any) *gomock.Call { +func (mr *MockClientMockRecorder) Update(ctx, obj any, opts ...any) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]any{arg0, arg1}, arg2...) + varargs := append([]any{ctx, obj}, opts...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Update", reflect.TypeOf((*MockClient)(nil).Update), varargs...) } @@ -271,6 +272,7 @@ func (mr *MockClientMockRecorder) Update(arg0, arg1 any, arg2 ...any) *gomock.Ca type MockFieldIndexer struct { ctrl *gomock.Controller recorder *MockFieldIndexerMockRecorder + isgomock struct{} } // MockFieldIndexerMockRecorder is the mock recorder for MockFieldIndexer. @@ -291,15 +293,15 @@ func (m *MockFieldIndexer) EXPECT() *MockFieldIndexerMockRecorder { } // IndexField mocks base method. -func (m *MockFieldIndexer) IndexField(arg0 context.Context, arg1 client.Object, arg2 string, arg3 client.IndexerFunc) error { +func (m *MockFieldIndexer) IndexField(ctx context.Context, obj client.Object, field string, extractValue client.IndexerFunc) error { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "IndexField", arg0, arg1, arg2, arg3) + ret := m.ctrl.Call(m, "IndexField", ctx, obj, field, extractValue) ret0, _ := ret[0].(error) return ret0 } // IndexField indicates an expected call of IndexField. -func (mr *MockFieldIndexerMockRecorder) IndexField(arg0, arg1, arg2, arg3 any) *gomock.Call { +func (mr *MockFieldIndexerMockRecorder) IndexField(ctx, obj, field, extractValue any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IndexField", reflect.TypeOf((*MockFieldIndexer)(nil).IndexField), arg0, arg1, arg2, arg3) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IndexField", reflect.TypeOf((*MockFieldIndexer)(nil).IndexField), ctx, obj, field, extractValue) } diff --git a/mock/controller-utils/clientutils/mocks.go b/mock/controller-utils/clientutils/mocks.go index ddb614b..611e8a3 100644 --- a/mock/controller-utils/clientutils/mocks.go +++ b/mock/controller-utils/clientutils/mocks.go @@ -24,6 +24,7 @@ import ( type MockPatchProvider struct { ctrl *gomock.Controller recorder *MockPatchProviderMockRecorder + isgomock struct{} } // MockPatchProviderMockRecorder is the mock recorder for MockPatchProvider. @@ -44,15 +45,15 @@ func (m *MockPatchProvider) EXPECT() *MockPatchProviderMockRecorder { } // PatchFor mocks base method. -func (m *MockPatchProvider) PatchFor(arg0 client.Object) client.Patch { +func (m *MockPatchProvider) PatchFor(obj client.Object) client.Patch { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "PatchFor", arg0) + ret := m.ctrl.Call(m, "PatchFor", obj) ret0, _ := ret[0].(client.Patch) return ret0 } // PatchFor indicates an expected call of PatchFor. -func (mr *MockPatchProviderMockRecorder) PatchFor(arg0 any) *gomock.Call { +func (mr *MockPatchProviderMockRecorder) PatchFor(obj any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PatchFor", reflect.TypeOf((*MockPatchProvider)(nil).PatchFor), arg0) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PatchFor", reflect.TypeOf((*MockPatchProvider)(nil).PatchFor), obj) } diff --git a/mock/controller-utils/metautils/funcs.go b/mock/controller-utils/metautils/funcs.go index 7943e08..5473cc9 100644 --- a/mock/controller-utils/metautils/funcs.go +++ b/mock/controller-utils/metautils/funcs.go @@ -24,6 +24,7 @@ import ( type MockEachListItemFunc struct { ctrl *gomock.Controller recorder *MockEachListItemFuncMockRecorder + isgomock struct{} } // MockEachListItemFuncMockRecorder is the mock recorder for MockEachListItemFunc. @@ -44,15 +45,15 @@ func (m *MockEachListItemFunc) EXPECT() *MockEachListItemFuncMockRecorder { } // Call mocks base method. -func (m *MockEachListItemFunc) Call(arg0 client.Object) error { +func (m *MockEachListItemFunc) Call(obj client.Object) error { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Call", arg0) + ret := m.ctrl.Call(m, "Call", obj) ret0, _ := ret[0].(error) return ret0 } // Call indicates an expected call of Call. -func (mr *MockEachListItemFuncMockRecorder) Call(arg0 any) *gomock.Call { +func (mr *MockEachListItemFuncMockRecorder) Call(obj any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Call", reflect.TypeOf((*MockEachListItemFunc)(nil).Call), arg0) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Call", reflect.TypeOf((*MockEachListItemFunc)(nil).Call), obj) }