forked from jaegertracing/jaeger-client-go
/
mock_span.go
260 lines (221 loc) Β· 8.78 KB
/
mock_span.go
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
// Code generated by MockGen. DO NOT EDIT.
// Copyright (c) 2020 The Jaeger Authors.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
// Source: vendor/github.com/opentracing/opentracing-go/span.go
// Package mock_opentracing is a generated GoMock package.
package mock_opentracing
import (
gomock "github.com/golang/mock/gomock"
opentracing "github.com/opentracing/opentracing-go"
log "github.com/opentracing/opentracing-go/log"
reflect "reflect"
)
// MockSpanContext is a mock of SpanContext interface
type MockSpanContext struct {
ctrl *gomock.Controller
recorder *MockSpanContextMockRecorder
}
// MockSpanContextMockRecorder is the mock recorder for MockSpanContext
type MockSpanContextMockRecorder struct {
mock *MockSpanContext
}
// NewMockSpanContext creates a new mock instance
func NewMockSpanContext(ctrl *gomock.Controller) *MockSpanContext {
mock := &MockSpanContext{ctrl: ctrl}
mock.recorder = &MockSpanContextMockRecorder{mock}
return mock
}
// EXPECT returns an object that allows the caller to indicate expected use
func (m *MockSpanContext) EXPECT() *MockSpanContextMockRecorder {
return m.recorder
}
// ForeachBaggageItem mocks base method
func (m *MockSpanContext) ForeachBaggageItem(handler func(string, string) bool) {
m.ctrl.T.Helper()
m.ctrl.Call(m, "ForeachBaggageItem", handler)
}
// ForeachBaggageItem indicates an expected call of ForeachBaggageItem
func (mr *MockSpanContextMockRecorder) ForeachBaggageItem(handler interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ForeachBaggageItem", reflect.TypeOf((*MockSpanContext)(nil).ForeachBaggageItem), handler)
}
// MockSpan is a mock of Span interface
type MockSpan struct {
ctrl *gomock.Controller
recorder *MockSpanMockRecorder
}
// MockSpanMockRecorder is the mock recorder for MockSpan
type MockSpanMockRecorder struct {
mock *MockSpan
}
// NewMockSpan creates a new mock instance
func NewMockSpan(ctrl *gomock.Controller) *MockSpan {
mock := &MockSpan{ctrl: ctrl}
mock.recorder = &MockSpanMockRecorder{mock}
return mock
}
// EXPECT returns an object that allows the caller to indicate expected use
func (m *MockSpan) EXPECT() *MockSpanMockRecorder {
return m.recorder
}
// Finish mocks base method
func (m *MockSpan) Finish() {
m.ctrl.T.Helper()
m.ctrl.Call(m, "Finish")
}
// Finish indicates an expected call of Finish
func (mr *MockSpanMockRecorder) Finish() *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Finish", reflect.TypeOf((*MockSpan)(nil).Finish))
}
// FinishWithOptions mocks base method
func (m *MockSpan) FinishWithOptions(opts opentracing.FinishOptions) {
m.ctrl.T.Helper()
m.ctrl.Call(m, "FinishWithOptions", opts)
}
// FinishWithOptions indicates an expected call of FinishWithOptions
func (mr *MockSpanMockRecorder) FinishWithOptions(opts interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FinishWithOptions", reflect.TypeOf((*MockSpan)(nil).FinishWithOptions), opts)
}
// Context mocks base method
func (m *MockSpan) Context() opentracing.SpanContext {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "Context")
ret0, _ := ret[0].(opentracing.SpanContext)
return ret0
}
// Context indicates an expected call of Context
func (mr *MockSpanMockRecorder) Context() *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Context", reflect.TypeOf((*MockSpan)(nil).Context))
}
// SetOperationName mocks base method
func (m *MockSpan) SetOperationName(operationName string) opentracing.Span {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "SetOperationName", operationName)
ret0, _ := ret[0].(opentracing.Span)
return ret0
}
// SetOperationName indicates an expected call of SetOperationName
func (mr *MockSpanMockRecorder) SetOperationName(operationName interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetOperationName", reflect.TypeOf((*MockSpan)(nil).SetOperationName), operationName)
}
// SetTag mocks base method
func (m *MockSpan) SetTag(key string, value interface{}) opentracing.Span {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "SetTag", key, value)
ret0, _ := ret[0].(opentracing.Span)
return ret0
}
// SetTag indicates an expected call of SetTag
func (mr *MockSpanMockRecorder) SetTag(key, value interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetTag", reflect.TypeOf((*MockSpan)(nil).SetTag), key, value)
}
// LogFields mocks base method
func (m *MockSpan) LogFields(fields ...log.Field) {
m.ctrl.T.Helper()
varargs := []interface{}{}
for _, a := range fields {
varargs = append(varargs, a)
}
m.ctrl.Call(m, "LogFields", varargs...)
}
// LogFields indicates an expected call of LogFields
func (mr *MockSpanMockRecorder) LogFields(fields ...interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LogFields", reflect.TypeOf((*MockSpan)(nil).LogFields), fields...)
}
// LogKV mocks base method
func (m *MockSpan) LogKV(alternatingKeyValues ...interface{}) {
m.ctrl.T.Helper()
varargs := []interface{}{}
for _, a := range alternatingKeyValues {
varargs = append(varargs, a)
}
m.ctrl.Call(m, "LogKV", varargs...)
}
// LogKV indicates an expected call of LogKV
func (mr *MockSpanMockRecorder) LogKV(alternatingKeyValues ...interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LogKV", reflect.TypeOf((*MockSpan)(nil).LogKV), alternatingKeyValues...)
}
// SetBaggageItem mocks base method
func (m *MockSpan) SetBaggageItem(restrictedKey, value string) opentracing.Span {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "SetBaggageItem", restrictedKey, value)
ret0, _ := ret[0].(opentracing.Span)
return ret0
}
// SetBaggageItem indicates an expected call of SetBaggageItem
func (mr *MockSpanMockRecorder) SetBaggageItem(restrictedKey, value interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetBaggageItem", reflect.TypeOf((*MockSpan)(nil).SetBaggageItem), restrictedKey, value)
}
// BaggageItem mocks base method
func (m *MockSpan) BaggageItem(restrictedKey string) string {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "BaggageItem", restrictedKey)
ret0, _ := ret[0].(string)
return ret0
}
// BaggageItem indicates an expected call of BaggageItem
func (mr *MockSpanMockRecorder) BaggageItem(restrictedKey interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BaggageItem", reflect.TypeOf((*MockSpan)(nil).BaggageItem), restrictedKey)
}
// Tracer mocks base method
func (m *MockSpan) Tracer() opentracing.Tracer {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "Tracer")
ret0, _ := ret[0].(opentracing.Tracer)
return ret0
}
// Tracer indicates an expected call of Tracer
func (mr *MockSpanMockRecorder) Tracer() *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Tracer", reflect.TypeOf((*MockSpan)(nil).Tracer))
}
// LogEvent mocks base method
func (m *MockSpan) LogEvent(event string) {
m.ctrl.T.Helper()
m.ctrl.Call(m, "LogEvent", event)
}
// LogEvent indicates an expected call of LogEvent
func (mr *MockSpanMockRecorder) LogEvent(event interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LogEvent", reflect.TypeOf((*MockSpan)(nil).LogEvent), event)
}
// LogEventWithPayload mocks base method
func (m *MockSpan) LogEventWithPayload(event string, payload interface{}) {
m.ctrl.T.Helper()
m.ctrl.Call(m, "LogEventWithPayload", event, payload)
}
// LogEventWithPayload indicates an expected call of LogEventWithPayload
func (mr *MockSpanMockRecorder) LogEventWithPayload(event, payload interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LogEventWithPayload", reflect.TypeOf((*MockSpan)(nil).LogEventWithPayload), event, payload)
}
// Log mocks base method
func (m *MockSpan) Log(data opentracing.LogData) {
m.ctrl.T.Helper()
m.ctrl.Call(m, "Log", data)
}
// Log indicates an expected call of Log
func (mr *MockSpanMockRecorder) Log(data interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Log", reflect.TypeOf((*MockSpan)(nil).Log), data)
}