1// Code generated by mockery; DO NOT EDIT.
2// github.com/vektra/mockery
3// template: testify
4
5package mocks
6
7import (
8 "bnema.dev/ermite/internal/domain"
9 mock "github.com/stretchr/testify/mock"
10)
11
12// NewPasskeyVerifier creates a new instance of PasskeyVerifier. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
13// The first argument is typically a *testing.T value.
14func NewPasskeyVerifier(t interface {
15 mock.TestingT
16 Cleanup(func())
17}) *PasskeyVerifier {
18 if helper, ok := t.(interface{ Helper() }); ok {
19 helper.Helper()
20 }
21
22 mock := &PasskeyVerifier{}
23 mock.Mock.Test(t)
24
25 t.Cleanup(func() {
26 if helper, ok := t.(interface{ Helper() }); ok {
27 helper.Helper()
28 }
29 mock.AssertExpectations(t)
30 })
31
32 return mock
33}
34
35// PasskeyVerifier is an autogenerated mock type for the PasskeyVerifier type
36type PasskeyVerifier struct {
37 mock.Mock
38}
39
40type PasskeyVerifier_Expecter struct {
41 mock *mock.Mock
42}
43
44func (_m *PasskeyVerifier) EXPECT() *PasskeyVerifier_Expecter {
45 return &PasskeyVerifier_Expecter{mock: &_m.Mock}
46}
47
48// BeginLogin provides a mock function for the type PasskeyVerifier
49func (_mock *PasskeyVerifier) BeginLogin() ([]byte, []byte, error) {
50 ret := _mock.Called()
51
52 if len(ret) == 0 {
53 panic("no return value specified for BeginLogin")
54 }
55
56 var r0 []byte
57 var r1 []byte
58 var r2 error
59 if returnFunc, ok := ret.Get(0).(func() ([]byte, []byte, error)); ok {
60 return returnFunc()
61 }
62 if returnFunc, ok := ret.Get(0).(func() []byte); ok {
63 r0 = returnFunc()
64 } else {
65 if ret.Get(0) != nil {
66 r0 = ret.Get(0).([]byte)
67 }
68 }
69 if returnFunc, ok := ret.Get(1).(func() []byte); ok {
70 r1 = returnFunc()
71 } else {
72 if ret.Get(1) != nil {
73 r1 = ret.Get(1).([]byte)
74 }
75 }
76 if returnFunc, ok := ret.Get(2).(func() error); ok {
77 r2 = returnFunc()
78 } else {
79 r2 = ret.Error(2)
80 }
81 return r0, r1, r2
82}
83
84// PasskeyVerifier_BeginLogin_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'BeginLogin'
85type PasskeyVerifier_BeginLogin_Call struct {
86 *mock.Call
87}
88
89// BeginLogin is a helper method to define mock.On call
90func (_e *PasskeyVerifier_Expecter) BeginLogin() *PasskeyVerifier_BeginLogin_Call {
91 return &PasskeyVerifier_BeginLogin_Call{Call: _e.mock.On("BeginLogin")}
92}
93
94func (_c *PasskeyVerifier_BeginLogin_Call) Run(run func()) *PasskeyVerifier_BeginLogin_Call {
95 _c.Call.Run(func(args mock.Arguments) {
96 run()
97 })
98 return _c
99}
100
101func (_c *PasskeyVerifier_BeginLogin_Call) Return(options []byte, ceremony []byte, err error) *PasskeyVerifier_BeginLogin_Call {
102 _c.Call.Return(options, ceremony, err)
103 return _c
104}
105
106func (_c *PasskeyVerifier_BeginLogin_Call) RunAndReturn(run func() ([]byte, []byte, error)) *PasskeyVerifier_BeginLogin_Call {
107 _c.Call.Return(run)
108 return _c
109}
110
111// BeginRegistration provides a mock function for the type PasskeyVerifier
112func (_mock *PasskeyVerifier) BeginRegistration(userHandle []byte, existing []domain.Passkey) ([]byte, []byte, error) {
113 ret := _mock.Called(userHandle, existing)
114
115 if len(ret) == 0 {
116 panic("no return value specified for BeginRegistration")
117 }
118
119 var r0 []byte
120 var r1 []byte
121 var r2 error
122 if returnFunc, ok := ret.Get(0).(func([]byte, []domain.Passkey) ([]byte, []byte, error)); ok {
123 return returnFunc(userHandle, existing)
124 }
125 if returnFunc, ok := ret.Get(0).(func([]byte, []domain.Passkey) []byte); ok {
126 r0 = returnFunc(userHandle, existing)
127 } else {
128 if ret.Get(0) != nil {
129 r0 = ret.Get(0).([]byte)
130 }
131 }
132 if returnFunc, ok := ret.Get(1).(func([]byte, []domain.Passkey) []byte); ok {
133 r1 = returnFunc(userHandle, existing)
134 } else {
135 if ret.Get(1) != nil {
136 r1 = ret.Get(1).([]byte)
137 }
138 }
139 if returnFunc, ok := ret.Get(2).(func([]byte, []domain.Passkey) error); ok {
140 r2 = returnFunc(userHandle, existing)
141 } else {
142 r2 = ret.Error(2)
143 }
144 return r0, r1, r2
145}
146
147// PasskeyVerifier_BeginRegistration_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'BeginRegistration'
148type PasskeyVerifier_BeginRegistration_Call struct {
149 *mock.Call
150}
151
152// BeginRegistration is a helper method to define mock.On call
153// - userHandle []byte
154// - existing []domain.Passkey
155func (_e *PasskeyVerifier_Expecter) BeginRegistration(userHandle any, existing any) *PasskeyVerifier_BeginRegistration_Call {
156 return &PasskeyVerifier_BeginRegistration_Call{Call: _e.mock.On("BeginRegistration", userHandle, existing)}
157}
158
159func (_c *PasskeyVerifier_BeginRegistration_Call) Run(run func(userHandle []byte, existing []domain.Passkey)) *PasskeyVerifier_BeginRegistration_Call {
160 _c.Call.Run(func(args mock.Arguments) {
161 var arg0 []byte
162 if args[0] != nil {
163 arg0 = args[0].([]byte)
164 }
165 var arg1 []domain.Passkey
166 if args[1] != nil {
167 arg1 = args[1].([]domain.Passkey)
168 }
169 run(
170 arg0,
171 arg1,
172 )
173 })
174 return _c
175}
176
177func (_c *PasskeyVerifier_BeginRegistration_Call) Return(options []byte, ceremony []byte, err error) *PasskeyVerifier_BeginRegistration_Call {
178 _c.Call.Return(options, ceremony, err)
179 return _c
180}
181
182func (_c *PasskeyVerifier_BeginRegistration_Call) RunAndReturn(run func(userHandle []byte, existing []domain.Passkey) ([]byte, []byte, error)) *PasskeyVerifier_BeginRegistration_Call {
183 _c.Call.Return(run)
184 return _c
185}
186
187// FinishLogin provides a mock function for the type PasskeyVerifier
188func (_mock *PasskeyVerifier) FinishLogin(userHandle []byte, ceremony []byte, response []byte, lookup func(id []byte) (domain.Passkey, error)) (domain.Passkey, error) {
189 ret := _mock.Called(userHandle, ceremony, response, lookup)
190
191 if len(ret) == 0 {
192 panic("no return value specified for FinishLogin")
193 }
194
195 var r0 domain.Passkey
196 var r1 error
197 if returnFunc, ok := ret.Get(0).(func([]byte, []byte, []byte, func(id []byte) (domain.Passkey, error)) (domain.Passkey, error)); ok {
198 return returnFunc(userHandle, ceremony, response, lookup)
199 }
200 if returnFunc, ok := ret.Get(0).(func([]byte, []byte, []byte, func(id []byte) (domain.Passkey, error)) domain.Passkey); ok {
201 r0 = returnFunc(userHandle, ceremony, response, lookup)
202 } else {
203 r0 = ret.Get(0).(domain.Passkey)
204 }
205 if returnFunc, ok := ret.Get(1).(func([]byte, []byte, []byte, func(id []byte) (domain.Passkey, error)) error); ok {
206 r1 = returnFunc(userHandle, ceremony, response, lookup)
207 } else {
208 r1 = ret.Error(1)
209 }
210 return r0, r1
211}
212
213// PasskeyVerifier_FinishLogin_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'FinishLogin'
214type PasskeyVerifier_FinishLogin_Call struct {
215 *mock.Call
216}
217
218// FinishLogin is a helper method to define mock.On call
219// - userHandle []byte
220// - ceremony []byte
221// - response []byte
222// - lookup func(id []byte) (domain.Passkey, error)
223func (_e *PasskeyVerifier_Expecter) FinishLogin(userHandle any, ceremony any, response any, lookup any) *PasskeyVerifier_FinishLogin_Call {
224 return &PasskeyVerifier_FinishLogin_Call{Call: _e.mock.On("FinishLogin", userHandle, ceremony, response, lookup)}
225}
226
227func (_c *PasskeyVerifier_FinishLogin_Call) Run(run func(userHandle []byte, ceremony []byte, response []byte, lookup func(id []byte) (domain.Passkey, error))) *PasskeyVerifier_FinishLogin_Call {
228 _c.Call.Run(func(args mock.Arguments) {
229 var arg0 []byte
230 if args[0] != nil {
231 arg0 = args[0].([]byte)
232 }
233 var arg1 []byte
234 if args[1] != nil {
235 arg1 = args[1].([]byte)
236 }
237 var arg2 []byte
238 if args[2] != nil {
239 arg2 = args[2].([]byte)
240 }
241 var arg3 func(id []byte) (domain.Passkey, error)
242 if args[3] != nil {
243 arg3 = args[3].(func(id []byte) (domain.Passkey, error))
244 }
245 run(
246 arg0,
247 arg1,
248 arg2,
249 arg3,
250 )
251 })
252 return _c
253}
254
255func (_c *PasskeyVerifier_FinishLogin_Call) Return(passkey domain.Passkey, err error) *PasskeyVerifier_FinishLogin_Call {
256 _c.Call.Return(passkey, err)
257 return _c
258}
259
260func (_c *PasskeyVerifier_FinishLogin_Call) RunAndReturn(run func(userHandle []byte, ceremony []byte, response []byte, lookup func(id []byte) (domain.Passkey, error)) (domain.Passkey, error)) *PasskeyVerifier_FinishLogin_Call {
261 _c.Call.Return(run)
262 return _c
263}
264
265// FinishRegistration provides a mock function for the type PasskeyVerifier
266func (_mock *PasskeyVerifier) FinishRegistration(userHandle []byte, ceremony []byte, response []byte) (domain.Passkey, error) {
267 ret := _mock.Called(userHandle, ceremony, response)
268
269 if len(ret) == 0 {
270 panic("no return value specified for FinishRegistration")
271 }
272
273 var r0 domain.Passkey
274 var r1 error
275 if returnFunc, ok := ret.Get(0).(func([]byte, []byte, []byte) (domain.Passkey, error)); ok {
276 return returnFunc(userHandle, ceremony, response)
277 }
278 if returnFunc, ok := ret.Get(0).(func([]byte, []byte, []byte) domain.Passkey); ok {
279 r0 = returnFunc(userHandle, ceremony, response)
280 } else {
281 r0 = ret.Get(0).(domain.Passkey)
282 }
283 if returnFunc, ok := ret.Get(1).(func([]byte, []byte, []byte) error); ok {
284 r1 = returnFunc(userHandle, ceremony, response)
285 } else {
286 r1 = ret.Error(1)
287 }
288 return r0, r1
289}
290
291// PasskeyVerifier_FinishRegistration_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'FinishRegistration'
292type PasskeyVerifier_FinishRegistration_Call struct {
293 *mock.Call
294}
295
296// FinishRegistration is a helper method to define mock.On call
297// - userHandle []byte
298// - ceremony []byte
299// - response []byte
300func (_e *PasskeyVerifier_Expecter) FinishRegistration(userHandle any, ceremony any, response any) *PasskeyVerifier_FinishRegistration_Call {
301 return &PasskeyVerifier_FinishRegistration_Call{Call: _e.mock.On("FinishRegistration", userHandle, ceremony, response)}
302}
303
304func (_c *PasskeyVerifier_FinishRegistration_Call) Run(run func(userHandle []byte, ceremony []byte, response []byte)) *PasskeyVerifier_FinishRegistration_Call {
305 _c.Call.Run(func(args mock.Arguments) {
306 var arg0 []byte
307 if args[0] != nil {
308 arg0 = args[0].([]byte)
309 }
310 var arg1 []byte
311 if args[1] != nil {
312 arg1 = args[1].([]byte)
313 }
314 var arg2 []byte
315 if args[2] != nil {
316 arg2 = args[2].([]byte)
317 }
318 run(
319 arg0,
320 arg1,
321 arg2,
322 )
323 })
324 return _c
325}
326
327func (_c *PasskeyVerifier_FinishRegistration_Call) Return(passkey domain.Passkey, err error) *PasskeyVerifier_FinishRegistration_Call {
328 _c.Call.Return(passkey, err)
329 return _c
330}
331
332func (_c *PasskeyVerifier_FinishRegistration_Call) RunAndReturn(run func(userHandle []byte, ceremony []byte, response []byte) (domain.Passkey, error)) *PasskeyVerifier_FinishRegistration_Call {
333 _c.Call.Return(run)
334 return _c
335}