go.temporal.io/server@v1.23.0/common/log/interface_mock.go (about)

     1  // The MIT License
     2  //
     3  // Copyright (c) 2020 Temporal Technologies Inc.  All rights reserved.
     4  //
     5  // Copyright (c) 2020 Uber Technologies, Inc.
     6  //
     7  // Permission is hereby granted, free of charge, to any person obtaining a copy
     8  // of this software and associated documentation files (the "Software"), to deal
     9  // in the Software without restriction, including without limitation the rights
    10  // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
    11  // copies of the Software, and to permit persons to whom the Software is
    12  // furnished to do so, subject to the following conditions:
    13  //
    14  // The above copyright notice and this permission notice shall be included in
    15  // all copies or substantial portions of the Software.
    16  //
    17  // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
    18  // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
    19  // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
    20  // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
    21  // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
    22  // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
    23  // THE SOFTWARE.
    24  
    25  // Code generated by MockGen. DO NOT EDIT.
    26  // Source: interface.go
    27  
    28  // Package log is a generated GoMock package.
    29  package log
    30  
    31  import (
    32  	reflect "reflect"
    33  
    34  	gomock "github.com/golang/mock/gomock"
    35  	tag "go.temporal.io/server/common/log/tag"
    36  )
    37  
    38  // MockLogger is a mock of Logger interface.
    39  type MockLogger struct {
    40  	ctrl     *gomock.Controller
    41  	recorder *MockLoggerMockRecorder
    42  }
    43  
    44  // MockLoggerMockRecorder is the mock recorder for MockLogger.
    45  type MockLoggerMockRecorder struct {
    46  	mock *MockLogger
    47  }
    48  
    49  // NewMockLogger creates a new mock instance.
    50  func NewMockLogger(ctrl *gomock.Controller) *MockLogger {
    51  	mock := &MockLogger{ctrl: ctrl}
    52  	mock.recorder = &MockLoggerMockRecorder{mock}
    53  	return mock
    54  }
    55  
    56  // EXPECT returns an object that allows the caller to indicate expected use.
    57  func (m *MockLogger) EXPECT() *MockLoggerMockRecorder {
    58  	return m.recorder
    59  }
    60  
    61  // DPanic mocks base method.
    62  func (m *MockLogger) DPanic(msg string, tags ...tag.Tag) {
    63  	m.ctrl.T.Helper()
    64  	varargs := []interface{}{msg}
    65  	for _, a := range tags {
    66  		varargs = append(varargs, a)
    67  	}
    68  	m.ctrl.Call(m, "DPanic", varargs...)
    69  }
    70  
    71  // DPanic indicates an expected call of DPanic.
    72  func (mr *MockLoggerMockRecorder) DPanic(msg interface{}, tags ...interface{}) *gomock.Call {
    73  	mr.mock.ctrl.T.Helper()
    74  	varargs := append([]interface{}{msg}, tags...)
    75  	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DPanic", reflect.TypeOf((*MockLogger)(nil).DPanic), varargs...)
    76  }
    77  
    78  // Debug mocks base method.
    79  func (m *MockLogger) Debug(msg string, tags ...tag.Tag) {
    80  	m.ctrl.T.Helper()
    81  	varargs := []interface{}{msg}
    82  	for _, a := range tags {
    83  		varargs = append(varargs, a)
    84  	}
    85  	m.ctrl.Call(m, "Debug", varargs...)
    86  }
    87  
    88  // Debug indicates an expected call of Debug.
    89  func (mr *MockLoggerMockRecorder) Debug(msg interface{}, tags ...interface{}) *gomock.Call {
    90  	mr.mock.ctrl.T.Helper()
    91  	varargs := append([]interface{}{msg}, tags...)
    92  	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Debug", reflect.TypeOf((*MockLogger)(nil).Debug), varargs...)
    93  }
    94  
    95  // Error mocks base method.
    96  func (m *MockLogger) Error(msg string, tags ...tag.Tag) {
    97  	m.ctrl.T.Helper()
    98  	varargs := []interface{}{msg}
    99  	for _, a := range tags {
   100  		varargs = append(varargs, a)
   101  	}
   102  	m.ctrl.Call(m, "Error", varargs...)
   103  }
   104  
   105  // Error indicates an expected call of Error.
   106  func (mr *MockLoggerMockRecorder) Error(msg interface{}, tags ...interface{}) *gomock.Call {
   107  	mr.mock.ctrl.T.Helper()
   108  	varargs := append([]interface{}{msg}, tags...)
   109  	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Error", reflect.TypeOf((*MockLogger)(nil).Error), varargs...)
   110  }
   111  
   112  // Fatal mocks base method.
   113  func (m *MockLogger) Fatal(msg string, tags ...tag.Tag) {
   114  	m.ctrl.T.Helper()
   115  	varargs := []interface{}{msg}
   116  	for _, a := range tags {
   117  		varargs = append(varargs, a)
   118  	}
   119  	m.ctrl.Call(m, "Fatal", varargs...)
   120  }
   121  
   122  // Fatal indicates an expected call of Fatal.
   123  func (mr *MockLoggerMockRecorder) Fatal(msg interface{}, tags ...interface{}) *gomock.Call {
   124  	mr.mock.ctrl.T.Helper()
   125  	varargs := append([]interface{}{msg}, tags...)
   126  	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Fatal", reflect.TypeOf((*MockLogger)(nil).Fatal), varargs...)
   127  }
   128  
   129  // Info mocks base method.
   130  func (m *MockLogger) Info(msg string, tags ...tag.Tag) {
   131  	m.ctrl.T.Helper()
   132  	varargs := []interface{}{msg}
   133  	for _, a := range tags {
   134  		varargs = append(varargs, a)
   135  	}
   136  	m.ctrl.Call(m, "Info", varargs...)
   137  }
   138  
   139  // Info indicates an expected call of Info.
   140  func (mr *MockLoggerMockRecorder) Info(msg interface{}, tags ...interface{}) *gomock.Call {
   141  	mr.mock.ctrl.T.Helper()
   142  	varargs := append([]interface{}{msg}, tags...)
   143  	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Info", reflect.TypeOf((*MockLogger)(nil).Info), varargs...)
   144  }
   145  
   146  // Panic mocks base method.
   147  func (m *MockLogger) Panic(msg string, tags ...tag.Tag) {
   148  	m.ctrl.T.Helper()
   149  	varargs := []interface{}{msg}
   150  	for _, a := range tags {
   151  		varargs = append(varargs, a)
   152  	}
   153  	m.ctrl.Call(m, "Panic", varargs...)
   154  }
   155  
   156  // Panic indicates an expected call of Panic.
   157  func (mr *MockLoggerMockRecorder) Panic(msg interface{}, tags ...interface{}) *gomock.Call {
   158  	mr.mock.ctrl.T.Helper()
   159  	varargs := append([]interface{}{msg}, tags...)
   160  	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Panic", reflect.TypeOf((*MockLogger)(nil).Panic), varargs...)
   161  }
   162  
   163  // Warn mocks base method.
   164  func (m *MockLogger) Warn(msg string, tags ...tag.Tag) {
   165  	m.ctrl.T.Helper()
   166  	varargs := []interface{}{msg}
   167  	for _, a := range tags {
   168  		varargs = append(varargs, a)
   169  	}
   170  	m.ctrl.Call(m, "Warn", varargs...)
   171  }
   172  
   173  // Warn indicates an expected call of Warn.
   174  func (mr *MockLoggerMockRecorder) Warn(msg interface{}, tags ...interface{}) *gomock.Call {
   175  	mr.mock.ctrl.T.Helper()
   176  	varargs := append([]interface{}{msg}, tags...)
   177  	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Warn", reflect.TypeOf((*MockLogger)(nil).Warn), varargs...)
   178  }
   179  
   180  // MockWithLogger is a mock of WithLogger interface.
   181  type MockWithLogger struct {
   182  	ctrl     *gomock.Controller
   183  	recorder *MockWithLoggerMockRecorder
   184  }
   185  
   186  // MockWithLoggerMockRecorder is the mock recorder for MockWithLogger.
   187  type MockWithLoggerMockRecorder struct {
   188  	mock *MockWithLogger
   189  }
   190  
   191  // NewMockWithLogger creates a new mock instance.
   192  func NewMockWithLogger(ctrl *gomock.Controller) *MockWithLogger {
   193  	mock := &MockWithLogger{ctrl: ctrl}
   194  	mock.recorder = &MockWithLoggerMockRecorder{mock}
   195  	return mock
   196  }
   197  
   198  // EXPECT returns an object that allows the caller to indicate expected use.
   199  func (m *MockWithLogger) EXPECT() *MockWithLoggerMockRecorder {
   200  	return m.recorder
   201  }
   202  
   203  // With mocks base method.
   204  func (m *MockWithLogger) With(tags ...tag.Tag) Logger {
   205  	m.ctrl.T.Helper()
   206  	varargs := []interface{}{}
   207  	for _, a := range tags {
   208  		varargs = append(varargs, a)
   209  	}
   210  	ret := m.ctrl.Call(m, "With", varargs...)
   211  	ret0, _ := ret[0].(Logger)
   212  	return ret0
   213  }
   214  
   215  // With indicates an expected call of With.
   216  func (mr *MockWithLoggerMockRecorder) With(tags ...interface{}) *gomock.Call {
   217  	mr.mock.ctrl.T.Helper()
   218  	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "With", reflect.TypeOf((*MockWithLogger)(nil).With), tags...)
   219  }
   220  
   221  // MockSkipLogger is a mock of SkipLogger interface.
   222  type MockSkipLogger struct {
   223  	ctrl     *gomock.Controller
   224  	recorder *MockSkipLoggerMockRecorder
   225  }
   226  
   227  // MockSkipLoggerMockRecorder is the mock recorder for MockSkipLogger.
   228  type MockSkipLoggerMockRecorder struct {
   229  	mock *MockSkipLogger
   230  }
   231  
   232  // NewMockSkipLogger creates a new mock instance.
   233  func NewMockSkipLogger(ctrl *gomock.Controller) *MockSkipLogger {
   234  	mock := &MockSkipLogger{ctrl: ctrl}
   235  	mock.recorder = &MockSkipLoggerMockRecorder{mock}
   236  	return mock
   237  }
   238  
   239  // EXPECT returns an object that allows the caller to indicate expected use.
   240  func (m *MockSkipLogger) EXPECT() *MockSkipLoggerMockRecorder {
   241  	return m.recorder
   242  }
   243  
   244  // Skip mocks base method.
   245  func (m *MockSkipLogger) Skip(extraSkip int) Logger {
   246  	m.ctrl.T.Helper()
   247  	ret := m.ctrl.Call(m, "Skip", extraSkip)
   248  	ret0, _ := ret[0].(Logger)
   249  	return ret0
   250  }
   251  
   252  // Skip indicates an expected call of Skip.
   253  func (mr *MockSkipLoggerMockRecorder) Skip(extraSkip interface{}) *gomock.Call {
   254  	mr.mock.ctrl.T.Helper()
   255  	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Skip", reflect.TypeOf((*MockSkipLogger)(nil).Skip), extraSkip)
   256  }