12982588012

Committed 27 Jan 2025 05:23AM UTC coverage: 62.219%. Remained the same

Build # 12982588012

Build Type

Pull #498

github

Committed by

web-flow

Commit Message

chore(deps): bump sigs.k8s.io/controller-runtime from 0.20.0 to 0.20.1

Bumps [sigs.k8s.io/controller-runtime](https://github.com/kubernetes-sigs/controller-runtime) from 0.20.0 to 0.20.1.
- [Release notes](https://github.com/kubernetes-sigs/controller-runtime/releases)
- [Changelog](https://github.com/kubernetes-sigs/controller-runtime/blob/main/RELEASE.md)
- [Commits](https://github.com/kubernetes-sigs/controller-runtime/compare/v0.20.0...v0.20.1)

---
updated-dependencies:
- dependency-name: sigs.k8s.io/controller-runtime
  dependency-type: direct:production
  update-type: version-update:semver-patch
...

Signed-off-by: dependabot[bot] <support@github.com>

Pull Request Pull Request #498: chore(deps): bump sigs.k8s.io/controller-runtime from 0.20.0 to 0.20.1

Run Details

746 of 1199 relevant lines covered (62.22%)

0.7 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

27.38

/pkg/mocks/client/mock.go

// Code generated by MockGen. DO NOT EDIT.
// Source: sigs.k8s.io/controller-runtime/pkg/client (interfaces: Client)
//
// Generated by this command:
//
//        mockgen -destination pkg/mocks/client/mock.go sigs.k8s.io/controller-runtime/pkg/client Client
//

// Package mock_client is a generated GoMock package.
package mock_client

import (
        context "context"
        reflect "reflect"

        gomock "go.uber.org/mock/gomock"
        meta "k8s.io/apimachinery/pkg/api/meta"
        runtime "k8s.io/apimachinery/pkg/runtime"
        schema "k8s.io/apimachinery/pkg/runtime/schema"
        client "sigs.k8s.io/controller-runtime/pkg/client"
)

// MockClient is a mock of Client interface.
type MockClient struct {
        ctrl     *gomock.Controller
        recorder *MockClientMockRecorder
        isgomock struct{}
}

// MockClientMockRecorder is the mock recorder for MockClient.
type MockClientMockRecorder struct {
        mock *MockClient
}

// NewMockClient creates a new mock instance.
func NewMockClient(ctrl *gomock.Controller) *MockClient {
        mock := &MockClient{ctrl: ctrl}
        mock.recorder = &MockClientMockRecorder{mock}
        return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockClient) EXPECT() *MockClientMockRecorder {
        return m.recorder
}

// Create mocks base method.
func (m *MockClient) Create(ctx context.Context, obj client.Object, opts ...client.CreateOption) error {
        m.ctrl.T.Helper()
        varargs := []any{ctx, obj}
        for _, a := range opts {
                varargs = append(varargs, a)
        }
        ret := m.ctrl.Call(m, "Create", varargs...)
        ret0, _ := ret[0].(error)
        return ret0
}

// Create indicates an expected call of Create.
func (mr *MockClientMockRecorder) Create(ctx, obj any, opts ...any) *gomock.Call {
        mr.mock.ctrl.T.Helper()
        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(ctx context.Context, obj client.Object, opts ...client.DeleteOption) error {
        m.ctrl.T.Helper()
        varargs := []any{ctx, obj}
        for _, a := range opts {
                varargs = append(varargs, a)
        }
        ret := m.ctrl.Call(m, "Delete", varargs...)
        ret0, _ := ret[0].(error)
        return ret0
}

// Delete indicates an expected call of Delete.
func (mr *MockClientMockRecorder) Delete(ctx, obj any, opts ...any) *gomock.Call {
        mr.mock.ctrl.T.Helper()
        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(ctx context.Context, obj client.Object, opts ...client.DeleteAllOfOption) error {
        m.ctrl.T.Helper()
        varargs := []any{ctx, obj}
        for _, a := range opts {
                varargs = append(varargs, a)
        }
        ret := m.ctrl.Call(m, "DeleteAllOf", varargs...)
        ret0, _ := ret[0].(error)
        return ret0
}

// DeleteAllOf indicates an expected call of DeleteAllOf.
func (mr *MockClientMockRecorder) DeleteAllOf(ctx, obj any, opts ...any) *gomock.Call {
        mr.mock.ctrl.T.Helper()
        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(ctx context.Context, key client.ObjectKey, obj client.Object, opts ...client.GetOption) error {
        m.ctrl.T.Helper()
        varargs := []any{ctx, key, obj}
        for _, a := range opts {
                varargs = append(varargs, a)
        }
        ret := m.ctrl.Call(m, "Get", varargs...)
        ret0, _ := ret[0].(error)
        return ret0
}

// Get indicates an expected call of Get.
func (mr *MockClientMockRecorder) Get(ctx, key, obj any, opts ...any) *gomock.Call {
        mr.mock.ctrl.T.Helper()
        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(obj runtime.Object) (schema.GroupVersionKind, error) {
        m.ctrl.T.Helper()
        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(obj any) *gomock.Call {
        mr.mock.ctrl.T.Helper()
        return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GroupVersionKindFor", reflect.TypeOf((*MockClient)(nil).GroupVersionKindFor), obj)
}

// IsObjectNamespaced mocks base method.
func (m *MockClient) IsObjectNamespaced(obj runtime.Object) (bool, error) {
        m.ctrl.T.Helper()
        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(obj any) *gomock.Call {
        mr.mock.ctrl.T.Helper()
        return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsObjectNamespaced", reflect.TypeOf((*MockClient)(nil).IsObjectNamespaced), obj)
}

// List mocks base method.
func (m *MockClient) List(ctx context.Context, list client.ObjectList, opts ...client.ListOption) error {
        m.ctrl.T.Helper()
        varargs := []any{ctx, list}
        for _, a := range opts {
                varargs = append(varargs, a)
        }
        ret := m.ctrl.Call(m, "List", varargs...)
        ret0, _ := ret[0].(error)
        return ret0
}

// List indicates an expected call of List.
func (mr *MockClientMockRecorder) List(ctx, list any, opts ...any) *gomock.Call {
        mr.mock.ctrl.T.Helper()
        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(ctx context.Context, obj client.Object, patch client.Patch, opts ...client.PatchOption) error {
        m.ctrl.T.Helper()
        varargs := []any{ctx, obj, patch}
        for _, a := range opts {
                varargs = append(varargs, a)
        }
        ret := m.ctrl.Call(m, "Patch", varargs...)
        ret0, _ := ret[0].(error)
        return ret0
}

// Patch indicates an expected call of Patch.
func (mr *MockClientMockRecorder) Patch(ctx, obj, patch any, opts ...any) *gomock.Call {
        mr.mock.ctrl.T.Helper()
        varargs := append([]any{ctx, obj, patch}, opts...)
        return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Patch", reflect.TypeOf((*MockClient)(nil).Patch), varargs...)
}

// RESTMapper mocks base method.
func (m *MockClient) RESTMapper() meta.RESTMapper {
        m.ctrl.T.Helper()
        ret := m.ctrl.Call(m, "RESTMapper")
        ret0, _ := ret[0].(meta.RESTMapper)
        return ret0
}

// RESTMapper indicates an expected call of RESTMapper.
func (mr *MockClientMockRecorder) RESTMapper() *gomock.Call {
        mr.mock.ctrl.T.Helper()
        return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RESTMapper", reflect.TypeOf((*MockClient)(nil).RESTMapper))
}

// Scheme mocks base method.
func (m *MockClient) Scheme() *runtime.Scheme {
        m.ctrl.T.Helper()
        ret := m.ctrl.Call(m, "Scheme")
        ret0, _ := ret[0].(*runtime.Scheme)
        return ret0
}

// Scheme indicates an expected call of Scheme.
func (mr *MockClientMockRecorder) Scheme() *gomock.Call {
        mr.mock.ctrl.T.Helper()
        return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Scheme", reflect.TypeOf((*MockClient)(nil).Scheme))
}

// Status mocks base method.
func (m *MockClient) Status() client.SubResourceWriter {
        m.ctrl.T.Helper()
        ret := m.ctrl.Call(m, "Status")
        ret0, _ := ret[0].(client.SubResourceWriter)
        return ret0
}

// Status indicates an expected call of Status.
func (mr *MockClientMockRecorder) Status() *gomock.Call {
        mr.mock.ctrl.T.Helper()
        return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Status", reflect.TypeOf((*MockClient)(nil).Status))
}

// SubResource mocks base method.
func (m *MockClient) SubResource(subResource string) client.SubResourceClient {
        m.ctrl.T.Helper()
        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(subResource any) *gomock.Call {
        mr.mock.ctrl.T.Helper()
        return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SubResource", reflect.TypeOf((*MockClient)(nil).SubResource), subResource)
}

// Update mocks base method.
func (m *MockClient) Update(ctx context.Context, obj client.Object, opts ...client.UpdateOption) error {
        m.ctrl.T.Helper()
        varargs := []any{ctx, obj}
        for _, a := range opts {
                varargs = append(varargs, a)
        }
        ret := m.ctrl.Call(m, "Update", varargs...)
        ret0, _ := ret[0].(error)
        return ret0
}

// Update indicates an expected call of Update.
func (mr *MockClientMockRecorder) Update(ctx, obj any, opts ...any) *gomock.Call {
        mr.mock.ctrl.T.Helper()
        varargs := append([]any{ctx, obj}, opts...)
        return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Update", reflect.TypeOf((*MockClient)(nil).Update), varargs...)
}

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

bakito / k8s-event-logger-operator / 12982588012

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous