mocks.*Logger_Warningf_Call.RunAndReturn - Code Metrics - cronnoss/tk-api - Measure and Improve Code Quality continuously with Scrutinizer

mocks.*Logger_Warningf_Call.RunAndReturn A
last analyzed 2024-09-17 15:27 UTC

↳ Parent: internal/server/mocks/logger_mock.go

Complexity

Conditions

Size

Total Lines	3
Code Lines	3

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	1
eloc	3
dl	0
loc	3
rs	10
c	0
b	0
f	0
nop	1

// Code generated by mockery v2.43.2. DO NOT EDIT.

package mocks

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

// Logger is an autogenerated mock type for the Logger type
type Logger struct {
	mock.Mock
}

type Logger_Expecter struct {
	mock *mock.Mock
}

func (_m *Logger) EXPECT() *Logger_Expecter {
	return &Logger_Expecter{mock: &_m.Mock}
}

// Debugf provides a mock function with given fields: format, a
func (_m *Logger) Debugf(format string, a ...interface{}) {
	var _ca []interface{}
	_ca = append(_ca, format)
	_ca = append(_ca, a...)
	_m.Called(_ca...)
}

// Logger_Debugf_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Debugf'
type Logger_Debugf_Call struct {
	*mock.Call
}

// Debugf is a helper method to define mock.On call
//   - format string
//   - a ...interface{}
func (_e *Logger_Expecter) Debugf(format interface{}, a ...interface{}) *Logger_Debugf_Call {
	return &Logger_Debugf_Call{Call: _e.mock.On("Debugf",
		append([]interface{}{format}, a...)...)}
}

func (_c *Logger_Debugf_Call) Run(run func(format string, a ...interface{})) *Logger_Debugf_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]interface{}, len(args)-1)
		for i, a := range args[1:] {
			if a != nil {
				variadicArgs[i] = a.(interface{})
			}
		}
		run(args[0].(string), variadicArgs...)
	})
	return _c
}

func (_c *Logger_Debugf_Call) Return() *Logger_Debugf_Call {
	_c.Call.Return()
	return _c
}

func (_c *Logger_Debugf_Call) RunAndReturn(run func(string, ...interface{})) *Logger_Debugf_Call {
	_c.Call.Return(run)
	return _c
}

// Errorf provides a mock function with given fields: format, a
func (_m *Logger) Errorf(format string, a ...interface{}) {
	var _ca []interface{}
	_ca = append(_ca, format)
	_ca = append(_ca, a...)
	_m.Called(_ca...)
}

// Logger_Errorf_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Errorf'
type Logger_Errorf_Call struct {
	*mock.Call
}

// Errorf is a helper method to define mock.On call
//   - format string
//   - a ...interface{}
func (_e *Logger_Expecter) Errorf(format interface{}, a ...interface{}) *Logger_Errorf_Call {
	return &Logger_Errorf_Call{Call: _e.mock.On("Errorf",
		append([]interface{}{format}, a...)...)}
}

func (_c *Logger_Errorf_Call) Run(run func(format string, a ...interface{})) *Logger_Errorf_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]interface{}, len(args)-1)
		for i, a := range args[1:] {
			if a != nil {
				variadicArgs[i] = a.(interface{})
			}
		}
		run(args[0].(string), variadicArgs...)
	})
	return _c
}

func (_c *Logger_Errorf_Call) Return() *Logger_Errorf_Call {
	_c.Call.Return()
	return _c
}

func (_c *Logger_Errorf_Call) RunAndReturn(run func(string, ...interface{})) *Logger_Errorf_Call {
	_c.Call.Return(run)
	return _c
}

// Fatalf provides a mock function with given fields: format, a
func (_m *Logger) Fatalf(format string, a ...interface{}) {
	var _ca []interface{}
	_ca = append(_ca, format)
	_ca = append(_ca, a...)
	_m.Called(_ca...)
}

// Logger_Fatalf_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Fatalf'
type Logger_Fatalf_Call struct {
	*mock.Call
}

// Fatalf is a helper method to define mock.On call
//   - format string
//   - a ...interface{}
func (_e *Logger_Expecter) Fatalf(format interface{}, a ...interface{}) *Logger_Fatalf_Call {
	return &Logger_Fatalf_Call{Call: _e.mock.On("Fatalf",
		append([]interface{}{format}, a...)...)}
}

func (_c *Logger_Fatalf_Call) Run(run func(format string, a ...interface{})) *Logger_Fatalf_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]interface{}, len(args)-1)
		for i, a := range args[1:] {
			if a != nil {
				variadicArgs[i] = a.(interface{})
			}
		}
		run(args[0].(string), variadicArgs...)
	})
	return _c
}

func (_c *Logger_Fatalf_Call) Return() *Logger_Fatalf_Call {
	_c.Call.Return()
	return _c
}

func (_c *Logger_Fatalf_Call) RunAndReturn(run func(string, ...interface{})) *Logger_Fatalf_Call {
	_c.Call.Return(run)
	return _c
}

// Infof provides a mock function with given fields: format, a
func (_m *Logger) Infof(format string, a ...interface{}) {
	var _ca []interface{}
	_ca = append(_ca, format)
	_ca = append(_ca, a...)
	_m.Called(_ca...)
}

// Logger_Infof_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Infof'
type Logger_Infof_Call struct {
	*mock.Call
}

// Infof is a helper method to define mock.On call
//   - format string
//   - a ...interface{}
func (_e *Logger_Expecter) Infof(format interface{}, a ...interface{}) *Logger_Infof_Call {
	return &Logger_Infof_Call{Call: _e.mock.On("Infof",
		append([]interface{}{format}, a...)...)}
}

func (_c *Logger_Infof_Call) Run(run func(format string, a ...interface{})) *Logger_Infof_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]interface{}, len(args)-1)
		for i, a := range args[1:] {
			if a != nil {
				variadicArgs[i] = a.(interface{})
			}
		}
		run(args[0].(string), variadicArgs...)
	})
	return _c
}

func (_c *Logger_Infof_Call) Return() *Logger_Infof_Call {
	_c.Call.Return()
	return _c
}

func (_c *Logger_Infof_Call) RunAndReturn(run func(string, ...interface{})) *Logger_Infof_Call {
	_c.Call.Return(run)
	return _c
}

// Warningf provides a mock function with given fields: format, a
func (_m *Logger) Warningf(format string, a ...interface{}) {
	var _ca []interface{}
	_ca = append(_ca, format)
	_ca = append(_ca, a...)
	_m.Called(_ca...)
}

// Logger_Warningf_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Warningf'
type Logger_Warningf_Call struct {
	*mock.Call
}

// Warningf is a helper method to define mock.On call
//   - format string
//   - a ...interface{}
func (_e *Logger_Expecter) Warningf(format interface{}, a ...interface{}) *Logger_Warningf_Call {
	return &Logger_Warningf_Call{Call: _e.mock.On("Warningf",
		append([]interface{}{format}, a...)...)}
}

func (_c *Logger_Warningf_Call) Run(run func(format string, a ...interface{})) *Logger_Warningf_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]interface{}, len(args)-1)
		for i, a := range args[1:] {
			if a != nil {
				variadicArgs[i] = a.(interface{})
			}
		}
		run(args[0].(string), variadicArgs...)
	})
	return _c
}

func (_c *Logger_Warningf_Call) Return() *Logger_Warningf_Call {
	_c.Call.Return()
	return _c
}

func (_c *Logger_Warningf_Call) RunAndReturn(run func(string, ...interface{})) *Logger_Warningf_Call {
	_c.Call.Return(run)
	return _c
}

// NewLogger creates a new instance of Logger. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
// The first argument is typically a *testing.T value.
func NewLogger(t interface {
	mock.TestingT
	Cleanup(func())
}) *Logger {
	mock := &Logger{}
	mock.Mock.Test(t)

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

	return mock
}


1			// Code generated by mockery v2.43.2. DO NOT EDIT.
2
3			package mocks
4
5			import mock "github.com/stretchr/testify/mock"
6
7			// Logger is an autogenerated mock type for the Logger type
8			type Logger struct {
9			mock.Mock
10			}
11
12			type Logger_Expecter struct {
13			mock *mock.Mock
14			}
15
16			func (_m Logger) EXPECT() Logger_Expecter {
17			return &Logger_Expecter{mock: &_m.Mock}
18			}
19
20			// Debugf provides a mock function with given fields: format, a
21			func (_m *Logger) Debugf(format string, a ...interface{}) {
22			var _ca []interface{}
23			_ca = append(_ca, format)
24			_ca = append(_ca, a...)
25			_m.Called(_ca...)
26			}
27
28			// Logger_Debugf_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Debugf'
29			type Logger_Debugf_Call struct {
30			*mock.Call
31			}
32
33			// Debugf is a helper method to define mock.On call
34			// - format string
35			// - a ...interface{}
36			func (_e Logger_Expecter) Debugf(format interface{}, a ...interface{}) Logger_Debugf_Call {
37			return &Logger_Debugf_Call{Call: _e.mock.On("Debugf",
38			append([]interface{}{format}, a...)...)}
39			}
40
41			func (_c Logger_Debugf_Call) Run(run func(format string, a ...interface{})) Logger_Debugf_Call {
42			_c.Call.Run(func(args mock.Arguments) {
43			variadicArgs := make([]interface{}, len(args)-1)
44			for i, a := range args[1:] {
45			if a != nil {
46			variadicArgs[i] = a.(interface{})
47			}
48			}
49			run(args[0].(string), variadicArgs...)
50			})
51			return _c
52			}
53
54			func (_c Logger_Debugf_Call) Return() Logger_Debugf_Call {
55			_c.Call.Return()
56			return _c
57			}
58
59			func (_c Logger_Debugf_Call) RunAndReturn(run func(string, ...interface{})) Logger_Debugf_Call {
60			_c.Call.Return(run)
61			return _c
62			}
63
64			// Errorf provides a mock function with given fields: format, a
65			func (_m *Logger) Errorf(format string, a ...interface{}) {
66			var _ca []interface{}
67			_ca = append(_ca, format)
68			_ca = append(_ca, a...)
69			_m.Called(_ca...)
70			}
71
72			// Logger_Errorf_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Errorf'
73			type Logger_Errorf_Call struct {
74			*mock.Call
75			}
76
77			// Errorf is a helper method to define mock.On call
78			// - format string
79			// - a ...interface{}
80			func (_e Logger_Expecter) Errorf(format interface{}, a ...interface{}) Logger_Errorf_Call {
81			return &Logger_Errorf_Call{Call: _e.mock.On("Errorf",
82			append([]interface{}{format}, a...)...)}
83			}
84
85			func (_c Logger_Errorf_Call) Run(run func(format string, a ...interface{})) Logger_Errorf_Call {
86			_c.Call.Run(func(args mock.Arguments) {
87			variadicArgs := make([]interface{}, len(args)-1)
88			for i, a := range args[1:] {
89			if a != nil {
90			variadicArgs[i] = a.(interface{})
91			}
92			}
93			run(args[0].(string), variadicArgs...)
94			})
95			return _c
96			}
97
98			func (_c Logger_Errorf_Call) Return() Logger_Errorf_Call {
99			_c.Call.Return()
100			return _c
101			}
102
103			func (_c Logger_Errorf_Call) RunAndReturn(run func(string, ...interface{})) Logger_Errorf_Call {
104			_c.Call.Return(run)
105			return _c
106			}
107
108			// Fatalf provides a mock function with given fields: format, a
109			func (_m *Logger) Fatalf(format string, a ...interface{}) {
110			var _ca []interface{}
111			_ca = append(_ca, format)
112			_ca = append(_ca, a...)
113			_m.Called(_ca...)
114			}
115
116			// Logger_Fatalf_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Fatalf'
117			type Logger_Fatalf_Call struct {
118			*mock.Call
119			}
120
121			// Fatalf is a helper method to define mock.On call
122			// - format string
123			// - a ...interface{}
124			func (_e Logger_Expecter) Fatalf(format interface{}, a ...interface{}) Logger_Fatalf_Call {
125			return &Logger_Fatalf_Call{Call: _e.mock.On("Fatalf",
126			append([]interface{}{format}, a...)...)}
127			}
128
129			func (_c Logger_Fatalf_Call) Run(run func(format string, a ...interface{})) Logger_Fatalf_Call {
130			_c.Call.Run(func(args mock.Arguments) {
131			variadicArgs := make([]interface{}, len(args)-1)
132			for i, a := range args[1:] {
133			if a != nil {
134			variadicArgs[i] = a.(interface{})
135			}
136			}
137			run(args[0].(string), variadicArgs...)
138			})
139			return _c
140			}
141
142			func (_c Logger_Fatalf_Call) Return() Logger_Fatalf_Call {
143			_c.Call.Return()
144			return _c
145			}
146
147			func (_c Logger_Fatalf_Call) RunAndReturn(run func(string, ...interface{})) Logger_Fatalf_Call {
148			_c.Call.Return(run)
149			return _c
150			}
151
152			// Infof provides a mock function with given fields: format, a
153			func (_m *Logger) Infof(format string, a ...interface{}) {
154			var _ca []interface{}
155			_ca = append(_ca, format)
156			_ca = append(_ca, a...)
157			_m.Called(_ca...)
158			}
159
160			// Logger_Infof_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Infof'
161			type Logger_Infof_Call struct {
162			*mock.Call
163			}
164
165			// Infof is a helper method to define mock.On call
166			// - format string
167			// - a ...interface{}
168			func (_e Logger_Expecter) Infof(format interface{}, a ...interface{}) Logger_Infof_Call {
169			return &Logger_Infof_Call{Call: _e.mock.On("Infof",
170			append([]interface{}{format}, a...)...)}
171			}
172
173			func (_c Logger_Infof_Call) Run(run func(format string, a ...interface{})) Logger_Infof_Call {
174			_c.Call.Run(func(args mock.Arguments) {
175			variadicArgs := make([]interface{}, len(args)-1)
176			for i, a := range args[1:] {
177			if a != nil {
178			variadicArgs[i] = a.(interface{})
179			}
180			}
181			run(args[0].(string), variadicArgs...)
182			})
183			return _c
184			}
185
186			func (_c Logger_Infof_Call) Return() Logger_Infof_Call {
187			_c.Call.Return()
188			return _c
189			}
190
191			func (_c Logger_Infof_Call) RunAndReturn(run func(string, ...interface{})) Logger_Infof_Call {
192			_c.Call.Return(run)
193			return _c
194			}
195
196			// Warningf provides a mock function with given fields: format, a
197			func (_m *Logger) Warningf(format string, a ...interface{}) {
198			var _ca []interface{}
199			_ca = append(_ca, format)
200			_ca = append(_ca, a...)
201			_m.Called(_ca...)
202			}
203
204			// Logger_Warningf_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Warningf'
205			type Logger_Warningf_Call struct {
206			*mock.Call
207			}
208
209			// Warningf is a helper method to define mock.On call
210			// - format string
211			// - a ...interface{}
212			func (_e Logger_Expecter) Warningf(format interface{}, a ...interface{}) Logger_Warningf_Call {
213			return &Logger_Warningf_Call{Call: _e.mock.On("Warningf",
214			append([]interface{}{format}, a...)...)}
215			}
216
217			func (_c Logger_Warningf_Call) Run(run func(format string, a ...interface{})) Logger_Warningf_Call {
218			_c.Call.Run(func(args mock.Arguments) {
219			variadicArgs := make([]interface{}, len(args)-1)
220			for i, a := range args[1:] {
221			if a != nil {
222			variadicArgs[i] = a.(interface{})
223			}
224			}
225			run(args[0].(string), variadicArgs...)
226			})
227			return _c
228			}
229
230			func (_c Logger_Warningf_Call) Return() Logger_Warningf_Call {
231			_c.Call.Return()
232			return _c
233			}
234
235			func (_c Logger_Warningf_Call) RunAndReturn(run func(string, ...interface{})) Logger_Warningf_Call {
236			_c.Call.Return(run)
237			return _c
238			}
239
240			// NewLogger creates a new instance of Logger. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
241			// The first argument is typically a *testing.T value.
242			func NewLogger(t interface {
243			mock.TestingT
244			Cleanup(func())
245			}) *Logger {
246			mock := &Logger{}
247			mock.Mock.Test(t)
248
249			t.Cleanup(func() { mock.AssertExpectations(t) })
250
251			return mock
252			}
253

cronnoss / tk-api

mocks.*Logger_Warningf_Call.RunAndReturn A last analyzed 2024-09-17 15:27 UTC

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like

mocks.*Logger_Warningf_Call.RunAndReturn A
last analyzed 2024-09-17 15:27 UTC