db-migrator.go

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

3
package mockaction
4

5
import mock "github.com/stretchr/testify/mock"
6

7
// Console is an autogenerated mock type for the Console type
8
type Console struct {
9
	mock.Mock
10
}
11

12
type Console_Expecter struct {
13
	mock *mock.Mock
14
}
15

16
func (_m *Console) EXPECT() *Console_Expecter {
17
	return &Console_Expecter{mock: &_m.Mock}
18
}
19

20
// Confirm provides a mock function with given fields: s
21
func (_m *Console) Confirm(s string) bool {
22
	ret := _m.Called(s)
23

24
	var r0 bool
25
	if rf, ok := ret.Get(0).(func(string) bool); ok {
26
		r0 = rf(s)
27
	} else {
28
		r0 = ret.Get(0).(bool)
29
	}
30

31
	return r0
32
}
33

34
// Console_Confirm_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Confirm'
35
type Console_Confirm_Call struct {
36
	*mock.Call
37
}
38

39
// Confirm is a helper method to define mock.On call
40
//   - s string
41
func (_e *Console_Expecter) Confirm(s interface{}) *Console_Confirm_Call {
42
	return &Console_Confirm_Call{Call: _e.mock.On("Confirm", s)}
43
}
44

45
func (_c *Console_Confirm_Call) Run(run func(s string)) *Console_Confirm_Call {
46
	_c.Call.Run(func(args mock.Arguments) {
47
		run(args[0].(string))
48
	})
49
	return _c
50
}
51

52
func (_c *Console_Confirm_Call) Return(_a0 bool) *Console_Confirm_Call {
53
	_c.Call.Return(_a0)
54
	return _c
55
}
56

57
func (_c *Console_Confirm_Call) RunAndReturn(run func(string) bool) *Console_Confirm_Call {
58
	_c.Call.Return(run)
59
	return _c
60
}
61

62
// Error provides a mock function with given fields: message
63
func (_m *Console) Error(message string) {
64
	_m.Called(message)
65
}
66

67
// Console_Error_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Error'
68
type Console_Error_Call struct {
69
	*mock.Call
70
}
71

72
// Error is a helper method to define mock.On call
73
//   - message string
74
func (_e *Console_Expecter) Error(message interface{}) *Console_Error_Call {
75
	return &Console_Error_Call{Call: _e.mock.On("Error", message)}
76
}
77

78
func (_c *Console_Error_Call) Run(run func(message string)) *Console_Error_Call {
79
	_c.Call.Run(func(args mock.Arguments) {
80
		run(args[0].(string))
81
	})
82
	return _c
83
}
84

85
func (_c *Console_Error_Call) Return() *Console_Error_Call {
86
	_c.Call.Return()
87
	return _c
88
}
89

90
func (_c *Console_Error_Call) RunAndReturn(run func(string)) *Console_Error_Call {
91
	_c.Call.Return(run)
92
	return _c
93
}
94

95
// ErrorLn provides a mock function with given fields: message
96
func (_m *Console) ErrorLn(message string) {
97
	_m.Called(message)
98
}
99

100
// Console_ErrorLn_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ErrorLn'
101
type Console_ErrorLn_Call struct {
102
	*mock.Call
103
}
104

105
// ErrorLn is a helper method to define mock.On call
106
//   - message string
107
func (_e *Console_Expecter) ErrorLn(message interface{}) *Console_ErrorLn_Call {
108
	return &Console_ErrorLn_Call{Call: _e.mock.On("ErrorLn", message)}
109
}
110

111
func (_c *Console_ErrorLn_Call) Run(run func(message string)) *Console_ErrorLn_Call {
112
	_c.Call.Run(func(args mock.Arguments) {
113
		run(args[0].(string))
114
	})
115
	return _c
116
}
117

118
func (_c *Console_ErrorLn_Call) Return() *Console_ErrorLn_Call {
119
	_c.Call.Return()
120
	return _c
121
}
122

123
func (_c *Console_ErrorLn_Call) RunAndReturn(run func(string)) *Console_ErrorLn_Call {
124
	_c.Call.Return(run)
125
	return _c
126
}
127

128
// Errorf provides a mock function with given fields: message, a
129
func (_m *Console) Errorf(message string, a ...interface{}) {
130
	var _ca []interface{}
131
	_ca = append(_ca, message)
132
	_ca = append(_ca, a...)
133
	_m.Called(_ca...)
134
}
135

136
// Console_Errorf_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Errorf'
137
type Console_Errorf_Call struct {
138
	*mock.Call
139
}
140

141
// Errorf is a helper method to define mock.On call
142
//   - message string
143
//   - a ...interface{}
144
func (_e *Console_Expecter) Errorf(message interface{}, a ...interface{}) *Console_Errorf_Call {
145
	return &Console_Errorf_Call{Call: _e.mock.On("Errorf",
146
		append([]interface{}{message}, a...)...)}
147
}
148

149
func (_c *Console_Errorf_Call) Run(run func(message string, a ...interface{})) *Console_Errorf_Call {
150
	_c.Call.Run(func(args mock.Arguments) {
151
		variadicArgs := make([]interface{}, len(args)-1)
152
		for i, a := range args[1:] {
153
			if a != nil {
154
				variadicArgs[i] = a.(interface{})
155
			}
156
		}
157
		run(args[0].(string), variadicArgs...)
158
	})
159
	return _c
160
}
161

162
func (_c *Console_Errorf_Call) Return() *Console_Errorf_Call {
163
	_c.Call.Return()
164
	return _c
165
}
166

167
func (_c *Console_Errorf_Call) RunAndReturn(run func(string, ...interface{})) *Console_Errorf_Call {
168
	_c.Call.Return(run)
169
	return _c
170
}
171

172
// Fatal provides a mock function with given fields: err
173
func (_m *Console) Fatal(err error) {
174
	_m.Called(err)
175
}
176

177
// Console_Fatal_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Fatal'
178
type Console_Fatal_Call struct {
179
	*mock.Call
180
}
181

182
// Fatal is a helper method to define mock.On call
183
//   - err error
184
func (_e *Console_Expecter) Fatal(err interface{}) *Console_Fatal_Call {
185
	return &Console_Fatal_Call{Call: _e.mock.On("Fatal", err)}
186
}
187

188
func (_c *Console_Fatal_Call) Run(run func(err error)) *Console_Fatal_Call {
189
	_c.Call.Run(func(args mock.Arguments) {
190
		run(args[0].(error))
191
	})
192
	return _c
193
}
194

195
func (_c *Console_Fatal_Call) Return() *Console_Fatal_Call {
196
	_c.Call.Return()
197
	return _c
198
}
199

200
func (_c *Console_Fatal_Call) RunAndReturn(run func(error)) *Console_Fatal_Call {
201
	_c.Call.Return(run)
202
	return _c
203
}
204

205
// Info provides a mock function with given fields: message
206
func (_m *Console) Info(message string) {
207
	_m.Called(message)
208
}
209

210
// Console_Info_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Info'
211
type Console_Info_Call struct {
212
	*mock.Call
213
}
214

215
// Info is a helper method to define mock.On call
216
//   - message string
217
func (_e *Console_Expecter) Info(message interface{}) *Console_Info_Call {
218
	return &Console_Info_Call{Call: _e.mock.On("Info", message)}
219
}
220

221
func (_c *Console_Info_Call) Run(run func(message string)) *Console_Info_Call {
222
	_c.Call.Run(func(args mock.Arguments) {
223
		run(args[0].(string))
224
	})
225
	return _c
226
}
227

228
func (_c *Console_Info_Call) Return() *Console_Info_Call {
229
	_c.Call.Return()
230
	return _c
231
}
232

233
func (_c *Console_Info_Call) RunAndReturn(run func(string)) *Console_Info_Call {
234
	_c.Call.Return(run)
235
	return _c
236
}
237

238
// InfoLn provides a mock function with given fields: message
239
func (_m *Console) InfoLn(message string) {
240
	_m.Called(message)
241
}
242

243
// Console_InfoLn_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'InfoLn'
244
type Console_InfoLn_Call struct {
245
	*mock.Call
246
}
247

248
// InfoLn is a helper method to define mock.On call
249
//   - message string
250
func (_e *Console_Expecter) InfoLn(message interface{}) *Console_InfoLn_Call {
251
	return &Console_InfoLn_Call{Call: _e.mock.On("InfoLn", message)}
252
}
253

254
func (_c *Console_InfoLn_Call) Run(run func(message string)) *Console_InfoLn_Call {
255
	_c.Call.Run(func(args mock.Arguments) {
256
		run(args[0].(string))
257
	})
258
	return _c
259
}
260

261
func (_c *Console_InfoLn_Call) Return() *Console_InfoLn_Call {
262
	_c.Call.Return()
263
	return _c
264
}
265

266
func (_c *Console_InfoLn_Call) RunAndReturn(run func(string)) *Console_InfoLn_Call {
267
	_c.Call.Return(run)
268
	return _c
269
}
270

271
// Infof provides a mock function with given fields: message, a
272
func (_m *Console) Infof(message string, a ...interface{}) {
273
	var _ca []interface{}
274
	_ca = append(_ca, message)
275
	_ca = append(_ca, a...)
276
	_m.Called(_ca...)
277
}
278

279
// Console_Infof_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Infof'
280
type Console_Infof_Call struct {
281
	*mock.Call
282
}
283

284
// Infof is a helper method to define mock.On call
285
//   - message string
286
//   - a ...interface{}
287
func (_e *Console_Expecter) Infof(message interface{}, a ...interface{}) *Console_Infof_Call {
288
	return &Console_Infof_Call{Call: _e.mock.On("Infof",
289
		append([]interface{}{message}, a...)...)}
290
}
291

292
func (_c *Console_Infof_Call) Run(run func(message string, a ...interface{})) *Console_Infof_Call {
293
	_c.Call.Run(func(args mock.Arguments) {
294
		variadicArgs := make([]interface{}, len(args)-1)
295
		for i, a := range args[1:] {
296
			if a != nil {
297
				variadicArgs[i] = a.(interface{})
298
			}
299
		}
300
		run(args[0].(string), variadicArgs...)
301
	})
302
	return _c
303
}
304

305
func (_c *Console_Infof_Call) Return() *Console_Infof_Call {
306
	_c.Call.Return()
307
	return _c
308
}
309

310
func (_c *Console_Infof_Call) RunAndReturn(run func(string, ...interface{})) *Console_Infof_Call {
311
	_c.Call.Return(run)
312
	return _c
313
}
314

315
// NumberPlural provides a mock function with given fields: count, one, many
316
func (_m *Console) NumberPlural(count int, one string, many string) string {
317
	ret := _m.Called(count, one, many)
318

319
	var r0 string
320
	if rf, ok := ret.Get(0).(func(int, string, string) string); ok {
321
		r0 = rf(count, one, many)
322
	} else {
323
		r0 = ret.Get(0).(string)
324
	}
325

326
	return r0
327
}
328

329
// Console_NumberPlural_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'NumberPlural'
330
type Console_NumberPlural_Call struct {
331
	*mock.Call
332
}
333

334
// NumberPlural is a helper method to define mock.On call
335
//   - count int
336
//   - one string
337
//   - many string
338
func (_e *Console_Expecter) NumberPlural(count interface{}, one interface{}, many interface{}) *Console_NumberPlural_Call {
339
	return &Console_NumberPlural_Call{Call: _e.mock.On("NumberPlural", count, one, many)}
340
}
341

342
func (_c *Console_NumberPlural_Call) Run(run func(count int, one string, many string)) *Console_NumberPlural_Call {
343
	_c.Call.Run(func(args mock.Arguments) {
344
		run(args[0].(int), args[1].(string), args[2].(string))
345
	})
346
	return _c
347
}
348

349
func (_c *Console_NumberPlural_Call) Return(_a0 string) *Console_NumberPlural_Call {
350
	_c.Call.Return(_a0)
351
	return _c
352
}
353

354
func (_c *Console_NumberPlural_Call) RunAndReturn(run func(int, string, string) string) *Console_NumberPlural_Call {
355
	_c.Call.Return(run)
356
	return _c
357
}
358

359
// Success provides a mock function with given fields: message
360
func (_m *Console) Success(message string) {
361
	_m.Called(message)
362
}
363

364
// Console_Success_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Success'
365
type Console_Success_Call struct {
366
	*mock.Call
367
}
368

369
// Success is a helper method to define mock.On call
370
//   - message string
371
func (_e *Console_Expecter) Success(message interface{}) *Console_Success_Call {
372
	return &Console_Success_Call{Call: _e.mock.On("Success", message)}
373
}
374

375
func (_c *Console_Success_Call) Run(run func(message string)) *Console_Success_Call {
376
	_c.Call.Run(func(args mock.Arguments) {
377
		run(args[0].(string))
378
	})
379
	return _c
380
}
381

382
func (_c *Console_Success_Call) Return() *Console_Success_Call {
383
	_c.Call.Return()
384
	return _c
385
}
386

387
func (_c *Console_Success_Call) RunAndReturn(run func(string)) *Console_Success_Call {
388
	_c.Call.Return(run)
389
	return _c
390
}
391

392
// SuccessLn provides a mock function with given fields: message
393
func (_m *Console) SuccessLn(message string) {
394
	_m.Called(message)
395
}
396

397
// Console_SuccessLn_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SuccessLn'
398
type Console_SuccessLn_Call struct {
399
	*mock.Call
400
}
401

402
// SuccessLn is a helper method to define mock.On call
403
//   - message string
404
func (_e *Console_Expecter) SuccessLn(message interface{}) *Console_SuccessLn_Call {
405
	return &Console_SuccessLn_Call{Call: _e.mock.On("SuccessLn", message)}
406
}
407

408
func (_c *Console_SuccessLn_Call) Run(run func(message string)) *Console_SuccessLn_Call {
409
	_c.Call.Run(func(args mock.Arguments) {
410
		run(args[0].(string))
411
	})
412
	return _c
413
}
414

415
func (_c *Console_SuccessLn_Call) Return() *Console_SuccessLn_Call {
416
	_c.Call.Return()
417
	return _c
418
}
419

420
func (_c *Console_SuccessLn_Call) RunAndReturn(run func(string)) *Console_SuccessLn_Call {
421
	_c.Call.Return(run)
422
	return _c
423
}
424

425
// Successf provides a mock function with given fields: message, a
426
func (_m *Console) Successf(message string, a ...interface{}) {
427
	var _ca []interface{}
428
	_ca = append(_ca, message)
429
	_ca = append(_ca, a...)
430
	_m.Called(_ca...)
431
}
432

433
// Console_Successf_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Successf'
434
type Console_Successf_Call struct {
435
	*mock.Call
436
}
437

438
// Successf is a helper method to define mock.On call
439
//   - message string
440
//   - a ...interface{}
441
func (_e *Console_Expecter) Successf(message interface{}, a ...interface{}) *Console_Successf_Call {
442
	return &Console_Successf_Call{Call: _e.mock.On("Successf",
443
		append([]interface{}{message}, a...)...)}
444
}
445

446
func (_c *Console_Successf_Call) Run(run func(message string, a ...interface{})) *Console_Successf_Call {
447
	_c.Call.Run(func(args mock.Arguments) {
448
		variadicArgs := make([]interface{}, len(args)-1)
449
		for i, a := range args[1:] {
450
			if a != nil {
451
				variadicArgs[i] = a.(interface{})
452
			}
453
		}
454
		run(args[0].(string), variadicArgs...)
455
	})
456
	return _c
457
}
458

459
func (_c *Console_Successf_Call) Return() *Console_Successf_Call {
460
	_c.Call.Return()
461
	return _c
462
}
463

464
func (_c *Console_Successf_Call) RunAndReturn(run func(string, ...interface{})) *Console_Successf_Call {
465
	_c.Call.Return(run)
466
	return _c
467
}
468

469
// Warn provides a mock function with given fields: message
470
func (_m *Console) Warn(message string) {
471
	_m.Called(message)
472
}
473

474
// Console_Warn_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Warn'
475
type Console_Warn_Call struct {
476
	*mock.Call
477
}
478

479
// Warn is a helper method to define mock.On call
480
//   - message string
481
func (_e *Console_Expecter) Warn(message interface{}) *Console_Warn_Call {
482
	return &Console_Warn_Call{Call: _e.mock.On("Warn", message)}
483
}
484

485
func (_c *Console_Warn_Call) Run(run func(message string)) *Console_Warn_Call {
486
	_c.Call.Run(func(args mock.Arguments) {
487
		run(args[0].(string))
488
	})
489
	return _c
490
}
491

492
func (_c *Console_Warn_Call) Return() *Console_Warn_Call {
493
	_c.Call.Return()
494
	return _c
495
}
496

497
func (_c *Console_Warn_Call) RunAndReturn(run func(string)) *Console_Warn_Call {
498
	_c.Call.Return(run)
499
	return _c
500
}
501

502
// WarnLn provides a mock function with given fields: message
503
func (_m *Console) WarnLn(message string) {
504
	_m.Called(message)
505
}
506

507
// Console_WarnLn_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'WarnLn'
508
type Console_WarnLn_Call struct {
509
	*mock.Call
510
}
511

512
// WarnLn is a helper method to define mock.On call
513
//   - message string
514
func (_e *Console_Expecter) WarnLn(message interface{}) *Console_WarnLn_Call {
515
	return &Console_WarnLn_Call{Call: _e.mock.On("WarnLn", message)}
516
}
517

518
func (_c *Console_WarnLn_Call) Run(run func(message string)) *Console_WarnLn_Call {
519
	_c.Call.Run(func(args mock.Arguments) {
520
		run(args[0].(string))
521
	})
522
	return _c
523
}
524

525
func (_c *Console_WarnLn_Call) Return() *Console_WarnLn_Call {
526
	_c.Call.Return()
527
	return _c
528
}
529

530
func (_c *Console_WarnLn_Call) RunAndReturn(run func(string)) *Console_WarnLn_Call {
531
	_c.Call.Return(run)
532
	return _c
533
}
534

535
// Warnf provides a mock function with given fields: message, a
536
func (_m *Console) Warnf(message string, a ...interface{}) {
537
	var _ca []interface{}
538
	_ca = append(_ca, message)
539
	_ca = append(_ca, a...)
540
	_m.Called(_ca...)
541
}
542

543
// Console_Warnf_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Warnf'
544
type Console_Warnf_Call struct {
545
	*mock.Call
546
}
547

548
// Warnf is a helper method to define mock.On call
549
//   - message string
550
//   - a ...interface{}
551
func (_e *Console_Expecter) Warnf(message interface{}, a ...interface{}) *Console_Warnf_Call {
552
	return &Console_Warnf_Call{Call: _e.mock.On("Warnf",
553
		append([]interface{}{message}, a...)...)}
554
}
555

556
func (_c *Console_Warnf_Call) Run(run func(message string, a ...interface{})) *Console_Warnf_Call {
557
	_c.Call.Run(func(args mock.Arguments) {
558
		variadicArgs := make([]interface{}, len(args)-1)
559
		for i, a := range args[1:] {
560
			if a != nil {
561
				variadicArgs[i] = a.(interface{})
562
			}
563
		}
564
		run(args[0].(string), variadicArgs...)
565
	})
566
	return _c
567
}
568

569
func (_c *Console_Warnf_Call) Return() *Console_Warnf_Call {
570
	_c.Call.Return()
571
	return _c
572
}
573

574
func (_c *Console_Warnf_Call) RunAndReturn(run func(string, ...interface{})) *Console_Warnf_Call {
575
	_c.Call.Return(run)
576
	return _c
577
}
578

579
type mockConstructorTestingTNewConsole interface {
580
	mock.TestingT
581
	Cleanup(func())
582
}
583

584
// NewConsole creates a new instance of Console. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
585
func NewConsole(t mockConstructorTestingTNewConsole) *Console {
586
	mock := &Console{}
587
	mock.Mock.Test(t)
588

589
	t.Cleanup(func() { mock.AssertExpectations(t) })
590

591
	return mock
592
}
593