mocks

Oct 2, 2024

Changes in this version

+ func WithMockAll(options *loggerMockOptions)

+ type LoggerMock interface

+ EXPECT func() *Logger_Expecter

+ type LoggerMockOption func(*loggerMockOptions)

+ func WithMockUntilLevel(level int) LoggerMockOption

+ func WithTestingT(t *testing.T) LoggerMockOption

+ type Mock interface

+ AssertCalled func(t mock.TestingT, methodName string, arguments ...interface{}) bool

+ AssertExpectations func(t mock.TestingT) bool

+ AssertNotCalled func(t mock.TestingT, methodName string, arguments ...interface{}) bool

+ AssertNumberOfCalls func(t mock.TestingT, methodName string, expectedCalls int) bool

+ Called func(arguments ...interface{}) mock.Arguments

+ IsMethodCallable func(t mock.TestingT, methodName string, arguments ...interface{}) bool

+ MethodCalled func(methodName string, arguments ...interface{}) mock.Arguments

+ On func(methodName string, arguments ...interface{}) *mock.Call

+ String func() string

+ Test func(t mock.TestingT)

+ TestData func() objx.Map

Oct 12, 2023

Changes in this version

+ type Logger struct

+ func NewLogger(t mockConstructorTestingTNewLogger) *Logger

+ func NewLoggerMock() *Logger

+ func NewLoggerMockedAll() *Logger

+ func NewLoggerMockedUntilLevel(level int) *Logger

+ func (_m *Logger) Debug(format string, args ...interface{})

+ func (_m *Logger) EXPECT() *Logger_Expecter

+ func (_m *Logger) Error(format string, args ...interface{})

+ func (_m *Logger) Info(format string, args ...interface{})

+ func (_m *Logger) Warn(format string, args ...interface{})

+ func (_m *Logger) WithChannel(channel string) log.Logger

+ func (_m *Logger) WithContext(ctx context.Context) log.Logger

+ func (_m *Logger) WithFields(_a0 log.Fields) log.Logger

+ type Logger_Debug_Call struct

+ func (_c *Logger_Debug_Call) Return() *Logger_Debug_Call

+ func (_c *Logger_Debug_Call) Run(run func(format string, args ...interface{})) *Logger_Debug_Call

+ func (_c *Logger_Debug_Call) RunAndReturn(run func(string, ...interface{})) *Logger_Debug_Call

+ type Logger_Error_Call struct

+ func (_c *Logger_Error_Call) Return() *Logger_Error_Call

+ func (_c *Logger_Error_Call) Run(run func(format string, args ...interface{})) *Logger_Error_Call

+ func (_c *Logger_Error_Call) RunAndReturn(run func(string, ...interface{})) *Logger_Error_Call

+ type Logger_Expecter struct

+ func (_e *Logger_Expecter) Debug(format interface{}, args ...interface{}) *Logger_Debug_Call

+ func (_e *Logger_Expecter) Error(format interface{}, args ...interface{}) *Logger_Error_Call

+ func (_e *Logger_Expecter) Info(format interface{}, args ...interface{}) *Logger_Info_Call

+ func (_e *Logger_Expecter) Warn(format interface{}, args ...interface{}) *Logger_Warn_Call

+ func (_e *Logger_Expecter) WithChannel(channel interface{}) *Logger_WithChannel_Call

+ func (_e *Logger_Expecter) WithContext(ctx interface{}) *Logger_WithContext_Call

+ func (_e *Logger_Expecter) WithFields(_a0 interface{}) *Logger_WithFields_Call

+ type Logger_Info_Call struct

+ func (_c *Logger_Info_Call) Return() *Logger_Info_Call

+ func (_c *Logger_Info_Call) Run(run func(format string, args ...interface{})) *Logger_Info_Call

+ func (_c *Logger_Info_Call) RunAndReturn(run func(string, ...interface{})) *Logger_Info_Call

+ type Logger_Warn_Call struct

+ func (_c *Logger_Warn_Call) Return() *Logger_Warn_Call

+ func (_c *Logger_Warn_Call) Run(run func(format string, args ...interface{})) *Logger_Warn_Call

+ func (_c *Logger_Warn_Call) RunAndReturn(run func(string, ...interface{})) *Logger_Warn_Call

+ type Logger_WithChannel_Call struct

+ func (_c *Logger_WithChannel_Call) Return(_a0 log.Logger) *Logger_WithChannel_Call

+ func (_c *Logger_WithChannel_Call) Run(run func(channel string)) *Logger_WithChannel_Call

+ func (_c *Logger_WithChannel_Call) RunAndReturn(run func(string) log.Logger) *Logger_WithChannel_Call

+ type Logger_WithContext_Call struct

+ func (_c *Logger_WithContext_Call) Return(_a0 log.Logger) *Logger_WithContext_Call

+ func (_c *Logger_WithContext_Call) Run(run func(ctx context.Context)) *Logger_WithContext_Call

+ func (_c *Logger_WithContext_Call) RunAndReturn(run func(context.Context) log.Logger) *Logger_WithContext_Call

+ type Logger_WithFields_Call struct

+ func (_c *Logger_WithFields_Call) Return(_a0 log.Logger) *Logger_WithFields_Call

+ func (_c *Logger_WithFields_Call) Run(run func(_a0 log.Fields)) *Logger_WithFields_Call

+ func (_c *Logger_WithFields_Call) RunAndReturn(run func(log.Fields) log.Logger) *Logger_WithFields_Call

+ type SentryHub struct

+ func NewSentryHub(t mockConstructorTestingTNewSentryHub) *SentryHub

+ func (_m *SentryHub) CaptureException(exception error) *sentry.EventID

+ func (_m *SentryHub) ConfigureScope(f func(*sentry.Scope))

+ func (_m *SentryHub) EXPECT() *SentryHub_Expecter

+ func (_m *SentryHub) Flush(timeout time.Duration) bool

+ func (_m *SentryHub) WithScope(f func(*sentry.Scope))

+ type SentryHub_CaptureException_Call struct

+ func (_c *SentryHub_CaptureException_Call) Return(_a0 *sentry.EventID) *SentryHub_CaptureException_Call

+ func (_c *SentryHub_CaptureException_Call) Run(run func(exception error)) *SentryHub_CaptureException_Call

+ func (_c *SentryHub_CaptureException_Call) RunAndReturn(run func(error) *sentry.EventID) *SentryHub_CaptureException_Call

+ type SentryHub_ConfigureScope_Call struct

+ func (_c *SentryHub_ConfigureScope_Call) Return() *SentryHub_ConfigureScope_Call

+ func (_c *SentryHub_ConfigureScope_Call) Run(run func(f func(*sentry.Scope))) *SentryHub_ConfigureScope_Call

+ func (_c *SentryHub_ConfigureScope_Call) RunAndReturn(run func(func(*sentry.Scope))) *SentryHub_ConfigureScope_Call

+ type SentryHub_Expecter struct

+ func (_e *SentryHub_Expecter) CaptureException(exception interface{}) *SentryHub_CaptureException_Call

+ func (_e *SentryHub_Expecter) ConfigureScope(f interface{}) *SentryHub_ConfigureScope_Call

+ func (_e *SentryHub_Expecter) Flush(timeout interface{}) *SentryHub_Flush_Call

+ func (_e *SentryHub_Expecter) WithScope(f interface{}) *SentryHub_WithScope_Call

+ type SentryHub_Flush_Call struct

+ func (_c *SentryHub_Flush_Call) Return(_a0 bool) *SentryHub_Flush_Call

+ func (_c *SentryHub_Flush_Call) Run(run func(timeout time.Duration)) *SentryHub_Flush_Call

+ func (_c *SentryHub_Flush_Call) RunAndReturn(run func(time.Duration) bool) *SentryHub_Flush_Call

+ type SentryHub_WithScope_Call struct

+ func (_c *SentryHub_WithScope_Call) Return() *SentryHub_WithScope_Call

+ func (_c *SentryHub_WithScope_Call) Run(run func(f func(*sentry.Scope))) *SentryHub_WithScope_Call

+ func (_c *SentryHub_WithScope_Call) RunAndReturn(run func(func(*sentry.Scope))) *SentryHub_WithScope_Call