kubelatte-ce

1
// Code generated by mockery v2.20.2. DO NOT EDIT.
2

3
package mocks
4

5
import (
6
	context "context"
7

8
	client "sigs.k8s.io/controller-runtime/pkg/client"
9

10
	meta "k8s.io/apimachinery/pkg/api/meta"
11

12
	mock "github.com/stretchr/testify/mock"
13

14
	runtime "k8s.io/apimachinery/pkg/runtime"
15

16
	schema "k8s.io/apimachinery/pkg/runtime/schema"
17

18
	types "k8s.io/apimachinery/pkg/types"
19
)
20

21
// Client is an autogenerated mock type for the Client type
22
type Client struct {
23
	mock.Mock
24
}
25

26
// Create provides a mock function with given fields: ctx, obj, opts
27
func (_m *Client) Create(ctx context.Context, obj client.Object, opts ...client.CreateOption) error {
28
	_va := make([]interface{}, len(opts))
29
	for _i := range opts {
30
		_va[_i] = opts[_i]
31
	}
32
	var _ca []interface{}
33
	_ca = append(_ca, ctx, obj)
34
	_ca = append(_ca, _va...)
35
	ret := _m.Called(_ca...)
36

37
	var r0 error
38
	if rf, ok := ret.Get(0).(func(context.Context, client.Object, ...client.CreateOption) error); ok {
39
		r0 = rf(ctx, obj, opts...)
40
	} else {
41
		r0 = ret.Error(0)
42
	}
43

44
	return r0
45
}
46

47
// Delete provides a mock function with given fields: ctx, obj, opts
48
func (_m *Client) Delete(ctx context.Context, obj client.Object, opts ...client.DeleteOption) error {
49
	_va := make([]interface{}, len(opts))
50
	for _i := range opts {
51
		_va[_i] = opts[_i]
52
	}
53
	var _ca []interface{}
54
	_ca = append(_ca, ctx, obj)
55
	_ca = append(_ca, _va...)
56
	ret := _m.Called(_ca...)
57

58
	var r0 error
59
	if rf, ok := ret.Get(0).(func(context.Context, client.Object, ...client.DeleteOption) error); ok {
60
		r0 = rf(ctx, obj, opts...)
61
	} else {
62
		r0 = ret.Error(0)
63
	}
64

65
	return r0
66
}
67

68
// DeleteAllOf provides a mock function with given fields: ctx, obj, opts
69
func (_m *Client) DeleteAllOf(ctx context.Context, obj client.Object, opts ...client.DeleteAllOfOption) error {
70
	_va := make([]interface{}, len(opts))
71
	for _i := range opts {
72
		_va[_i] = opts[_i]
73
	}
74
	var _ca []interface{}
75
	_ca = append(_ca, ctx, obj)
76
	_ca = append(_ca, _va...)
77
	ret := _m.Called(_ca...)
78

79
	var r0 error
80
	if rf, ok := ret.Get(0).(func(context.Context, client.Object, ...client.DeleteAllOfOption) error); ok {
81
		r0 = rf(ctx, obj, opts...)
82
	} else {
83
		r0 = ret.Error(0)
84
	}
85

86
	return r0
87
}
88

89
// Get provides a mock function with given fields: ctx, key, obj, opts
90
func (_m *Client) Get(ctx context.Context, key types.NamespacedName, obj client.Object, opts ...client.GetOption) error {
91
	_va := make([]interface{}, len(opts))
92
	for _i := range opts {
93
		_va[_i] = opts[_i]
94
	}
95
	var _ca []interface{}
96
	_ca = append(_ca, ctx, key, obj)
97
	_ca = append(_ca, _va...)
98
	ret := _m.Called(_ca...)
99

100
	var r0 error
101
	if rf, ok := ret.Get(0).(func(context.Context, types.NamespacedName, client.Object, ...client.GetOption) error); ok {
102
		r0 = rf(ctx, key, obj, opts...)
103
	} else {
104
		r0 = ret.Error(0)
105
	}
106

107
	return r0
108
}
109

110
// GroupVersionKindFor provides a mock function with given fields: obj
111
func (_m *Client) GroupVersionKindFor(obj runtime.Object) (schema.GroupVersionKind, error) {
112
	ret := _m.Called(obj)
113

114
	var r0 schema.GroupVersionKind
115
	var r1 error
116
	if rf, ok := ret.Get(0).(func(runtime.Object) (schema.GroupVersionKind, error)); ok {
117
		return rf(obj)
118
	}
119
	if rf, ok := ret.Get(0).(func(runtime.Object) schema.GroupVersionKind); ok {
120
		r0 = rf(obj)
121
	} else {
122
		r0 = ret.Get(0).(schema.GroupVersionKind)
123
	}
124

125
	if rf, ok := ret.Get(1).(func(runtime.Object) error); ok {
126
		r1 = rf(obj)
127
	} else {
128
		r1 = ret.Error(1)
129
	}
130

131
	return r0, r1
132
}
133

134
// IsObjectNamespaced provides a mock function with given fields: obj
135
func (_m *Client) IsObjectNamespaced(obj runtime.Object) (bool, error) {
136
	ret := _m.Called(obj)
137

138
	var r0 bool
139
	var r1 error
140
	if rf, ok := ret.Get(0).(func(runtime.Object) (bool, error)); ok {
141
		return rf(obj)
142
	}
143
	if rf, ok := ret.Get(0).(func(runtime.Object) bool); ok {
144
		r0 = rf(obj)
145
	} else {
146
		r0 = ret.Get(0).(bool)
147
	}
148

149
	if rf, ok := ret.Get(1).(func(runtime.Object) error); ok {
150
		r1 = rf(obj)
151
	} else {
152
		r1 = ret.Error(1)
153
	}
154

155
	return r0, r1
156
}
157

158
// List provides a mock function with given fields: ctx, list, opts
159
func (_m *Client) List(ctx context.Context, list client.ObjectList, opts ...client.ListOption) error {
160
	_va := make([]interface{}, len(opts))
161
	for _i := range opts {
162
		_va[_i] = opts[_i]
163
	}
164
	var _ca []interface{}
165
	_ca = append(_ca, ctx, list)
166
	_ca = append(_ca, _va...)
167
	ret := _m.Called(_ca...)
168

169
	var r0 error
170
	if rf, ok := ret.Get(0).(func(context.Context, client.ObjectList, ...client.ListOption) error); ok {
171
		r0 = rf(ctx, list, opts...)
172
	} else {
173
		r0 = ret.Error(0)
174
	}
175

176
	return r0
177
}
178

179
// Patch provides a mock function with given fields: ctx, obj, patch, opts
180
func (_m *Client) Patch(ctx context.Context, obj client.Object, patch client.Patch, opts ...client.PatchOption) error {
181
	_va := make([]interface{}, len(opts))
182
	for _i := range opts {
183
		_va[_i] = opts[_i]
184
	}
185
	var _ca []interface{}
186
	_ca = append(_ca, ctx, obj, patch)
187
	_ca = append(_ca, _va...)
188
	ret := _m.Called(_ca...)
189

190
	var r0 error
191
	if rf, ok := ret.Get(0).(func(context.Context, client.Object, client.Patch, ...client.PatchOption) error); ok {
192
		r0 = rf(ctx, obj, patch, opts...)
193
	} else {
194
		r0 = ret.Error(0)
195
	}
196

197
	return r0
198
}
199

200
// RESTMapper provides a mock function with given fields:
201
func (_m *Client) RESTMapper() meta.RESTMapper {
202
	ret := _m.Called()
203

204
	var r0 meta.RESTMapper
205
	if rf, ok := ret.Get(0).(func() meta.RESTMapper); ok {
206
		r0 = rf()
207
	} else {
208
		if ret.Get(0) != nil {
209
			r0 = ret.Get(0).(meta.RESTMapper)
210
		}
211
	}
212

213
	return r0
214
}
215

216
// Scheme provides a mock function with given fields:
217
func (_m *Client) Scheme() *runtime.Scheme {
218
	ret := _m.Called()
219

220
	var r0 *runtime.Scheme
221
	if rf, ok := ret.Get(0).(func() *runtime.Scheme); ok {
222
		r0 = rf()
223
	} else {
224
		if ret.Get(0) != nil {
225
			r0 = ret.Get(0).(*runtime.Scheme)
226
		}
227
	}
228

229
	return r0
230
}
231

232
// Status provides a mock function with given fields:
233
func (_m *Client) Status() client.SubResourceWriter {
234
	ret := _m.Called()
235

236
	var r0 client.SubResourceWriter
237
	if rf, ok := ret.Get(0).(func() client.SubResourceWriter); ok {
238
		r0 = rf()
239
	} else {
240
		if ret.Get(0) != nil {
241
			r0 = ret.Get(0).(client.SubResourceWriter)
242
		}
243
	}
244

245
	return r0
246
}
247

248
// SubResource provides a mock function with given fields: subResource
249
func (_m *Client) SubResource(subResource string) client.SubResourceClient {
250
	ret := _m.Called(subResource)
251

252
	var r0 client.SubResourceClient
253
	if rf, ok := ret.Get(0).(func(string) client.SubResourceClient); ok {
254
		r0 = rf(subResource)
255
	} else {
256
		if ret.Get(0) != nil {
257
			r0 = ret.Get(0).(client.SubResourceClient)
258
		}
259
	}
260

261
	return r0
262
}
263

264
// Update provides a mock function with given fields: ctx, obj, opts
265
func (_m *Client) Update(ctx context.Context, obj client.Object, opts ...client.UpdateOption) error {
266
	_va := make([]interface{}, len(opts))
267
	for _i := range opts {
268
		_va[_i] = opts[_i]
269
	}
270
	var _ca []interface{}
271
	_ca = append(_ca, ctx, obj)
272
	_ca = append(_ca, _va...)
273
	ret := _m.Called(_ca...)
274

275
	var r0 error
276
	if rf, ok := ret.Get(0).(func(context.Context, client.Object, ...client.UpdateOption) error); ok {
277
		r0 = rf(ctx, obj, opts...)
278
	} else {
279
		r0 = ret.Error(0)
280
	}
281

282
	return r0
283
}
284

285
type mockConstructorTestingTNewClient interface {
286
	mock.TestingT
287
	Cleanup(func())
288
}
289

290
// NewClient creates a new instance of Client. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
291
func NewClient(t mockConstructorTestingTNewClient) *Client {
292
	mock := &Client{}
293
	mock.Mock.Test(t)
294

295
	t.Cleanup(func() { mock.AssertExpectations(t) })
296

297
	return mock
298
}
299