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 }