efritz/chevron

MockLogger has 52 methods (exceeds 20 allowed). Consider refactoring.

Open

type MockLogger struct {
    statsLogWithFieldsLock          sync.RWMutex
    statLogWithFieldsFuncCallCount  int
    statLogWithFieldsFuncCallParams []LoggerLogWithFieldsParamSet
    LogWithFieldsFunc               func(logging.LogLevel, logging.Fields, string, ...interface{})

Similar blocks of code found in 5 locations. Consider refactoring.

Open

func (m *MockLogger) ErrorWithFields(v0 logging.Fields, v1 string, v2 ...interface{}) {
    m.statsErrorWithFieldsLock.Lock()
    m.statErrorWithFieldsFuncCallCount++
    m.statErrorWithFieldsFuncCallParams = append(m.statErrorWithFieldsFuncCallParams, LoggerErrorWithFieldsParamSet{v0, v1, v2})
    m.statsErrorWithFieldsLock.Unlock()

• Read up
  Read up

Similar blocks of code found in 5 locations. Consider refactoring.

Open

func (m *MockLogger) FatalWithFields(v0 logging.Fields, v1 string, v2 ...interface{}) {
    m.statsFatalWithFieldsLock.Lock()
    m.statFatalWithFieldsFuncCallCount++
    m.statFatalWithFieldsFuncCallParams = append(m.statFatalWithFieldsFuncCallParams, LoggerFatalWithFieldsParamSet{v0, v1, v2})
    m.statsFatalWithFieldsLock.Unlock()

• Read up
  Read up

Similar blocks of code found in 5 locations. Consider refactoring.

Open

func (m *MockLogger) WarningWithFields(v0 logging.Fields, v1 string, v2 ...interface{}) {
    m.statsWarningWithFieldsLock.Lock()
    m.statWarningWithFieldsFuncCallCount++
    m.statWarningWithFieldsFuncCallParams = append(m.statWarningWithFieldsFuncCallParams, LoggerWarningWithFieldsParamSet{v0, v1, v2})
    m.statsWarningWithFieldsLock.Unlock()

• Read up
  Read up

Similar blocks of code found in 5 locations. Consider refactoring.

Open

func (m *MockLogger) InfoWithFields(v0 logging.Fields, v1 string, v2 ...interface{}) {
    m.statsInfoWithFieldsLock.Lock()
    m.statInfoWithFieldsFuncCallCount++
    m.statInfoWithFieldsFuncCallParams = append(m.statInfoWithFieldsFuncCallParams, LoggerInfoWithFieldsParamSet{v0, v1, v2})
    m.statsInfoWithFieldsLock.Unlock()

• Read up
  Read up

Similar blocks of code found in 5 locations. Consider refactoring.

Open

func (m *MockLogger) DebugWithFields(v0 logging.Fields, v1 string, v2 ...interface{}) {
    m.statsDebugWithFieldsLock.Lock()
    m.statDebugWithFieldsFuncCallCount++
    m.statDebugWithFieldsFuncCallParams = append(m.statDebugWithFieldsFuncCallParams, LoggerDebugWithFieldsParamSet{v0, v1, v2})
    m.statsDebugWithFieldsLock.Unlock()

• Read up
  Read up

Similar blocks of code found in 5 locations. Consider refactoring.

Open

func (m *MockLogger) Info(v0 string, v1 ...interface{}) {
    m.statsInfoLock.Lock()
    m.statInfoFuncCallCount++
    m.statInfoFuncCallParams = append(m.statInfoFuncCallParams, LoggerInfoParamSet{v0, v1})
    m.statsInfoLock.Unlock()

• Read up
  Read up

Similar blocks of code found in 5 locations. Consider refactoring.

Open

func (m *MockLogger) Error(v0 string, v1 ...interface{}) {
    m.statsErrorLock.Lock()
    m.statErrorFuncCallCount++
    m.statErrorFuncCallParams = append(m.statErrorFuncCallParams, LoggerErrorParamSet{v0, v1})
    m.statsErrorLock.Unlock()

• Read up
  Read up

Similar blocks of code found in 5 locations. Consider refactoring.

Open

func (m *MockLogger) Warning(v0 string, v1 ...interface{}) {
    m.statsWarningLock.Lock()
    m.statWarningFuncCallCount++
    m.statWarningFuncCallParams = append(m.statWarningFuncCallParams, LoggerWarningParamSet{v0, v1})
    m.statsWarningLock.Unlock()

• Read up
  Read up

Similar blocks of code found in 5 locations. Consider refactoring.

Open

func (m *MockLogger) Debug(v0 string, v1 ...interface{}) {
    m.statsDebugLock.Lock()
    m.statDebugFuncCallCount++
    m.statDebugFuncCallParams = append(m.statDebugFuncCallParams, LoggerDebugParamSet{v0, v1})
    m.statsDebugLock.Unlock()

• Read up
  Read up

Similar blocks of code found in 5 locations. Consider refactoring.

Open

func (m *MockLogger) Fatal(v0 string, v1 ...interface{}) {
    m.statsFatalLock.Lock()
    m.statFatalFuncCallCount++
    m.statFatalFuncCallParams = append(m.statFatalFuncCallParams, LoggerFatalParamSet{v0, v1})
    m.statsFatalLock.Unlock()

• Read up
  Read up

exported type LoggerWithFieldsParamSet should have comment or be unexported

Open

type LoggerWithFieldsParamSet struct {

• Exclude checks
  • Disable engine
  • Disable check

exported method MockLogger.DebugFuncCallCount should have comment or be unexported

Open

func (m *MockLogger) DebugFuncCallCount() int {

• Exclude checks
  • Disable engine
  • Disable check

exported type LoggerInfoParamSet should have comment or be unexported

Open

type LoggerInfoParamSet struct {

• Exclude checks
  • Disable engine
  • Disable check

exported method MockLogger.ErrorWithFields should have comment or be unexported

Open

func (m *MockLogger) ErrorWithFields(v0 logging.Fields, v1 string, v2 ...interface{}) {

• Exclude checks
  • Disable engine
  • Disable check

exported method MockLogger.Debug should have comment or be unexported

Open

func (m *MockLogger) Debug(v0 string, v1 ...interface{}) {

• Exclude checks
  • Disable engine
  • Disable check

exported method MockLogger.FatalFuncCallParams should have comment or be unexported

Open

func (m *MockLogger) FatalFuncCallParams() []LoggerFatalParamSet {

• Exclude checks
  • Disable engine
  • Disable check

exported type LoggerWarningParamSet should have comment or be unexported

Open

type LoggerWarningParamSet struct {

• Exclude checks
  • Disable engine
  • Disable check

exported type LoggerLogWithFieldsParamSet should have comment or be unexported

Open

type LoggerLogWithFieldsParamSet struct {

• Exclude checks
  • Disable engine
  • Disable check

exported method MockLogger.DebugWithFields should have comment or be unexported

Open

func (m *MockLogger) DebugWithFields(v0 logging.Fields, v1 string, v2 ...interface{}) {

• Exclude checks
  • Disable engine
  • Disable check

exported type MockLogger should have comment or be unexported

Open

type MockLogger struct {

• Exclude checks
  • Disable engine
  • Disable check

exported type LoggerDebugWithFieldsParamSet should have comment or be unexported

Open

type LoggerDebugWithFieldsParamSet struct {

• Exclude checks
  • Disable engine
  • Disable check

exported method MockLogger.InfoFuncCallParams should have comment or be unexported

Open

func (m *MockLogger) InfoFuncCallParams() []LoggerInfoParamSet {

• Exclude checks
  • Disable engine
  • Disable check

exported method MockLogger.WarningFuncCallCount should have comment or be unexported

Open

func (m *MockLogger) WarningFuncCallCount() int {

• Exclude checks
  • Disable engine
  • Disable check

exported method MockLogger.WarningWithFieldsFuncCallParams should have comment or be unexported

Open

func (m *MockLogger) WarningWithFieldsFuncCallParams() []LoggerWarningWithFieldsParamSet {

• Exclude checks
  • Disable engine
  • Disable check

exported method MockLogger.ErrorWithFieldsFuncCallCount should have comment or be unexported

Open

func (m *MockLogger) ErrorWithFieldsFuncCallCount() int {

• Exclude checks
  • Disable engine
  • Disable check

exported method MockLogger.InfoFuncCallCount should have comment or be unexported

Open

func (m *MockLogger) InfoFuncCallCount() int {

• Exclude checks
  • Disable engine
  • Disable check

exported type LoggerErrorWithFieldsParamSet should have comment or be unexported

Open

type LoggerErrorWithFieldsParamSet struct {

• Exclude checks
  • Disable engine
  • Disable check

exported type LoggerDebugParamSet should have comment or be unexported

Open

type LoggerDebugParamSet struct {

• Exclude checks
  • Disable engine
  • Disable check

exported type LoggerInfoWithFieldsParamSet should have comment or be unexported

Open

type LoggerInfoWithFieldsParamSet struct {

• Exclude checks
  • Disable engine
  • Disable check

exported method MockLogger.WarningWithFieldsFuncCallCount should have comment or be unexported

Open

func (m *MockLogger) WarningWithFieldsFuncCallCount() int {

• Exclude checks
  • Disable engine
  • Disable check

exported method MockLogger.ErrorFuncCallParams should have comment or be unexported

Open

func (m *MockLogger) ErrorFuncCallParams() []LoggerErrorParamSet {

• Exclude checks
  • Disable engine
  • Disable check

exported method MockLogger.WithFields should have comment or be unexported

Open

func (m *MockLogger) WithFields(v0 logging.Fields) logging.Logger {

• Exclude checks
  • Disable engine
  • Disable check

exported method MockLogger.WithFieldsFuncCallParams should have comment or be unexported

Open

func (m *MockLogger) WithFieldsFuncCallParams() []LoggerWithFieldsParamSet {

• Exclude checks
  • Disable engine
  • Disable check

exported type LoggerFatalParamSet should have comment or be unexported

Open

type LoggerFatalParamSet struct {

• Exclude checks
  • Disable engine
  • Disable check

exported type LoggerErrorParamSet should have comment or be unexported

Open

type LoggerErrorParamSet struct {

• Exclude checks
  • Disable engine
  • Disable check

exported method MockLogger.InfoWithFieldsFuncCallCount should have comment or be unexported

Open

func (m *MockLogger) InfoWithFieldsFuncCallCount() int {

• Exclude checks
  • Disable engine
  • Disable check

exported method MockLogger.Sync should have comment or be unexported

Open

func (m *MockLogger) Sync() error {

• Exclude checks
  • Disable engine
  • Disable check

exported method MockLogger.WithFieldsFuncCallCount should have comment or be unexported

Open

func (m *MockLogger) WithFieldsFuncCallCount() int {

• Exclude checks
  • Disable engine
  • Disable check

exported type LoggerWarningWithFieldsParamSet should have comment or be unexported

Open

type LoggerWarningWithFieldsParamSet struct {

• Exclude checks
  • Disable engine
  • Disable check

exported method MockLogger.FatalFuncCallCount should have comment or be unexported

Open

func (m *MockLogger) FatalFuncCallCount() int {

• Exclude checks
  • Disable engine
  • Disable check

exported method MockLogger.WarningFuncCallParams should have comment or be unexported

Open

func (m *MockLogger) WarningFuncCallParams() []LoggerWarningParamSet {

• Exclude checks
  • Disable engine
  • Disable check

exported method MockLogger.ErrorFuncCallCount should have comment or be unexported

Open

func (m *MockLogger) ErrorFuncCallCount() int {

• Exclude checks
  • Disable engine
  • Disable check

exported method MockLogger.LogWithFieldsFuncCallCount should have comment or be unexported

Open

func (m *MockLogger) LogWithFieldsFuncCallCount() int {

• Exclude checks
  • Disable engine
  • Disable check

exported type LoggerSyncParamSet should have comment or be unexported

Open

type LoggerSyncParamSet struct{}

• Exclude checks
  • Disable engine
  • Disable check

exported method MockLogger.Fatal should have comment or be unexported

Open

func (m *MockLogger) Fatal(v0 string, v1 ...interface{}) {

• Exclude checks
  • Disable engine
  • Disable check

exported method MockLogger.SyncFuncCallCount should have comment or be unexported

Open

func (m *MockLogger) SyncFuncCallCount() int {

• Exclude checks
  • Disable engine
  • Disable check

exported method MockLogger.Warning should have comment or be unexported

Open

func (m *MockLogger) Warning(v0 string, v1 ...interface{}) {

• Exclude checks
  • Disable engine
  • Disable check

exported method MockLogger.InfoWithFieldsFuncCallParams should have comment or be unexported

Open

func (m *MockLogger) InfoWithFieldsFuncCallParams() []LoggerInfoWithFieldsParamSet {

• Exclude checks
  • Disable engine
  • Disable check

exported method MockLogger.SyncFuncCallParams should have comment or be unexported

Open

func (m *MockLogger) SyncFuncCallParams() []LoggerSyncParamSet {

• Exclude checks
  • Disable engine
  • Disable check

exported method MockLogger.DebugWithFieldsFuncCallParams should have comment or be unexported

Open

func (m *MockLogger) DebugWithFieldsFuncCallParams() []LoggerDebugWithFieldsParamSet {

• Exclude checks
  • Disable engine
  • Disable check

exported method MockLogger.Info should have comment or be unexported

Open

func (m *MockLogger) Info(v0 string, v1 ...interface{}) {

• Exclude checks
  • Disable engine
  • Disable check

exported method MockLogger.DebugWithFieldsFuncCallCount should have comment or be unexported

Open

func (m *MockLogger) DebugWithFieldsFuncCallCount() int {

• Exclude checks
  • Disable engine
  • Disable check

exported method MockLogger.ErrorWithFieldsFuncCallParams should have comment or be unexported

Open

func (m *MockLogger) ErrorWithFieldsFuncCallParams() []LoggerErrorWithFieldsParamSet {

• Exclude checks
  • Disable engine
  • Disable check

exported method MockLogger.DebugFuncCallParams should have comment or be unexported

Open

func (m *MockLogger) DebugFuncCallParams() []LoggerDebugParamSet {

• Exclude checks
  • Disable engine
  • Disable check

exported method MockLogger.LogWithFieldsFuncCallParams should have comment or be unexported

Open

func (m *MockLogger) LogWithFieldsFuncCallParams() []LoggerLogWithFieldsParamSet {

• Exclude checks
  • Disable engine
  • Disable check

exported function NewMockLogger should have comment or be unexported

Open

func NewMockLogger() *MockLogger {

• Exclude checks
  • Disable engine
  • Disable check

exported method MockLogger.WarningWithFields should have comment or be unexported

Open

func (m *MockLogger) WarningWithFields(v0 logging.Fields, v1 string, v2 ...interface{}) {

• Exclude checks
  • Disable engine
  • Disable check

exported method MockLogger.FatalWithFields should have comment or be unexported

Open

func (m *MockLogger) FatalWithFields(v0 logging.Fields, v1 string, v2 ...interface{}) {

• Exclude checks
  • Disable engine
  • Disable check

exported method MockLogger.LogWithFields should have comment or be unexported

Open

func (m *MockLogger) LogWithFields(v0 logging.LogLevel, v1 logging.Fields, v2 string, v3 ...interface{}) {

• Exclude checks
  • Disable engine
  • Disable check

exported type LoggerFatalWithFieldsParamSet should have comment or be unexported

Open

type LoggerFatalWithFieldsParamSet struct {

• Exclude checks
  • Disable engine
  • Disable check

exported method MockLogger.FatalWithFieldsFuncCallCount should have comment or be unexported

Open

func (m *MockLogger) FatalWithFieldsFuncCallCount() int {

• Exclude checks
  • Disable engine
  • Disable check

exported method MockLogger.FatalWithFieldsFuncCallParams should have comment or be unexported

Open

func (m *MockLogger) FatalWithFieldsFuncCallParams() []LoggerFatalWithFieldsParamSet {

• Exclude checks
  • Disable engine
  • Disable check

exported method MockLogger.InfoWithFields should have comment or be unexported

Open

func (m *MockLogger) InfoWithFields(v0 logging.Fields, v1 string, v2 ...interface{}) {

• Exclude checks
  • Disable engine
  • Disable check