Debian Codegraph @

mocktracer/mocktracer_test.go

raw
1 package mocktracer
2
3 import (
4 "net/http"
5 "reflect"
6 "sync"
7 "testing"
8 "time"
9
10 "github.com/stretchr/testify/assert"
11 "github.com/stretchr/testify/require"
12
13 "github.com/opentracing/opentracing-go"
14 "github.com/opentracing/opentracing-go/ext"
15 "github.com/opentracing/opentracing-go/log"
16 )
17
18 func TestMockTracer_StartSpan(t *testing.T) {
19 tracer := New()
20 span1 := tracer.StartSpan(
21 "a",
22 opentracing.Tags(map[string]interface{}{"x": "y"}))
23
24 span2 := span1.Tracer().StartSpan(
25 "", opentracing.ChildOf(span1.Context()))
26 span2.Finish()
27 span1.Finish()
28 spans := tracer.FinishedSpans()
29 assert.Equal(t, 2, len(spans))
30
31 parent := spans[1]
32 child := spans[0]
33 assert.Equal(t, map[string]interface{}{"x": "y"}, parent.Tags())
34 assert.Equal(t, child.ParentID, parent.Context().(MockSpanContext).SpanID)
35 }
36
37 func TestMockSpan_SetOperationName(t *testing.T) {
38 tracer := New()
39 span := tracer.StartSpan("")
40 span.SetOperationName("x")
41 assert.Equal(t, "x", span.(*MockSpan).OperationName)
42 }
43
44 func TestMockSpanContext_Baggage(t *testing.T) {
45 tracer := New()
46 span := tracer.StartSpan("x")
47 span.SetBaggageItem("x", "y")
48 assert.Equal(t, "y", span.BaggageItem("x"))
49 assert.Equal(t, map[string]string{"x": "y"}, span.Context().(MockSpanContext).Baggage)
50
51 baggage := make(map[string]string)
52 span.Context().ForeachBaggageItem(func(k, v string) bool {
53 baggage[k] = v
54 return true
55 })
56 assert.Equal(t, map[string]string{"x": "y"}, baggage)
57
58 span.SetBaggageItem("a", "b")
59 baggage = make(map[string]string)
60 span.Context().ForeachBaggageItem(func(k, v string) bool {
61 baggage[k] = v
62 return false // exit early
63 })
64 assert.Equal(t, 2, len(span.Context().(MockSpanContext).Baggage))
65 assert.Equal(t, 1, len(baggage))
66 }
67
68 func TestMockSpan_Tag(t *testing.T) {
69 tracer := New()
70 span := tracer.StartSpan("x")
71 span.SetTag("x", "y")
72 assert.Equal(t, "y", span.(*MockSpan).Tag("x"))
73 }
74
75 func TestMockSpan_Tags(t *testing.T) {
76 tracer := New()
77 span := tracer.StartSpan("x")
78 span.SetTag("x", "y")
79 assert.Equal(t, map[string]interface{}{"x": "y"}, span.(*MockSpan).Tags())
80 }
81
82 func TestMockTracer_FinishedSpans_and_Reset(t *testing.T) {
83 tracer := New()
84 span := tracer.StartSpan("x")
85 span.SetTag("x", "y")
86 span.Finish()
87 spans := tracer.FinishedSpans()
88 assert.Equal(t, 1, len(spans))
89 assert.Equal(t, map[string]interface{}{"x": "y"}, spans[0].Tags())
90
91 tracer.Reset()
92 spans = tracer.FinishedSpans()
93 assert.Equal(t, 0, len(spans))
94 }
95
96 func zeroOutTimestamps(recs []MockLogRecord) {
97 for i := range recs {
98 recs[i].Timestamp = time.Time{}
99 }
100 }
101
102 func TestMockSpan_LogKV(t *testing.T) {
103 tracer := New()
104 span := tracer.StartSpan("s")
105 span.LogKV("key0", "string0")
106 span.LogKV("key1", "string1", "key2", uint32(42))
107 span.Finish()
108 spans := tracer.FinishedSpans()
109 assert.Equal(t, 1, len(spans))
110 actual := spans[0].Logs()
111 zeroOutTimestamps(actual)
112 assert.Equal(t, []MockLogRecord{
113 MockLogRecord{
114 Fields: []MockKeyValue{
115 MockKeyValue{Key: "key0", ValueKind: reflect.String, ValueString: "string0"},
116 },
117 },
118 MockLogRecord{
119 Fields: []MockKeyValue{
120 MockKeyValue{Key: "key1", ValueKind: reflect.String, ValueString: "string1"},
121 MockKeyValue{Key: "key2", ValueKind: reflect.Uint32, ValueString: "42"},
122 },
123 },
124 }, actual)
125 }
126
127 func TestMockSpan_LogFields(t *testing.T) {
128 tracer := New()
129 span := tracer.StartSpan("s")
130 span.LogFields(log.String("key0", "string0"))
131 span.LogFields(log.String("key1", "string1"), log.Uint32("key2", uint32(42)))
132 span.LogFields(log.Lazy(func(fv log.Encoder) {
133 fv.EmitInt("key_lazy", 12)
134 }))
135 span.FinishWithOptions(opentracing.FinishOptions{
136 LogRecords: []opentracing.LogRecord{
137 {Timestamp: time.Now(), Fields: []log.Field{log.String("key9", "finish")}},
138 }})
139 spans := tracer.FinishedSpans()
140 assert.Equal(t, 1, len(spans))
141 actual := spans[0].Logs()
142 zeroOutTimestamps(actual)
143 assert.Equal(t, []MockLogRecord{
144 MockLogRecord{
145 Fields: []MockKeyValue{
146 MockKeyValue{Key: "key0", ValueKind: reflect.String, ValueString: "string0"},
147 },
148 },
149 MockLogRecord{
150 Fields: []MockKeyValue{
151 MockKeyValue{Key: "key1", ValueKind: reflect.String, ValueString: "string1"},
152 MockKeyValue{Key: "key2", ValueKind: reflect.Uint32, ValueString: "42"},
153 },
154 },
155 MockLogRecord{
156 Fields: []MockKeyValue{
157 // Note that the LazyLogger gets to control the key as well as the value.
158 MockKeyValue{Key: "key_lazy", ValueKind: reflect.Int, ValueString: "12"},
159 },
160 },
161 MockLogRecord{
162 Fields: []MockKeyValue{
163 MockKeyValue{Key: "key9", ValueKind: reflect.String, ValueString: "finish"},
164 },
165 },
166 }, actual)
167 }
168
169 func TestMockSpan_DeprecatedLogs(t *testing.T) {
170 tracer := New()
171 span := tracer.StartSpan("x")
172 span.LogEvent("x")
173 span.LogEventWithPayload("y", "z")
174 span.LogEvent("a")
175 span.FinishWithOptions(opentracing.FinishOptions{
176 BulkLogData: []opentracing.LogData{{Event: "f"}}})
177 spans := tracer.FinishedSpans()
178 assert.Equal(t, 1, len(spans))
179 actual := spans[0].Logs()
180 zeroOutTimestamps(actual)
181 assert.Equal(t, []MockLogRecord{
182 MockLogRecord{
183 Fields: []MockKeyValue{
184 MockKeyValue{Key: "event", ValueKind: reflect.String, ValueString: "x"},
185 },
186 },
187 MockLogRecord{
188 Fields: []MockKeyValue{
189 MockKeyValue{Key: "event", ValueKind: reflect.String, ValueString: "y"},
190 MockKeyValue{Key: "payload", ValueKind: reflect.String, ValueString: "z"},
191 },
192 },
193 MockLogRecord{
194 Fields: []MockKeyValue{
195 MockKeyValue{Key: "event", ValueKind: reflect.String, ValueString: "a"},
196 },
197 },
198 MockLogRecord{
199 Fields: []MockKeyValue{
200 MockKeyValue{Key: "event", ValueKind: reflect.String, ValueString: "f"},
201 },
202 },
203 }, actual)
204 }
205
206 func TestMockTracer_Propagation(t *testing.T) {
207 textCarrier := func() interface{} {
208 return opentracing.TextMapCarrier(make(map[string]string))
209 }
210 textLen := func(c interface{}) int {
211 return len(c.(opentracing.TextMapCarrier))
212 }
213
214 httpCarrier := func() interface{} {
215 httpHeaders := http.Header(make(map[string][]string))
216 return opentracing.HTTPHeadersCarrier(httpHeaders)
217 }
218 httpLen := func(c interface{}) int {
219 return len(c.(opentracing.HTTPHeadersCarrier))
220 }
221
222 tests := []struct {
223 sampled bool
224 format opentracing.BuiltinFormat
225 carrier func() interface{}
226 len func(interface{}) int
227 }{
228 {sampled: true, format: opentracing.TextMap, carrier: textCarrier, len: textLen},
229 {sampled: false, format: opentracing.TextMap, carrier: textCarrier, len: textLen},
230 {sampled: true, format: opentracing.HTTPHeaders, carrier: httpCarrier, len: httpLen},
231 {sampled: false, format: opentracing.HTTPHeaders, carrier: httpCarrier, len: httpLen},
232 }
233 for _, test := range tests {
234 tracer := New()
235 span := tracer.StartSpan("x")
236 span.SetBaggageItem("x", "y:z") // colon should be URL encoded as %3A
237 if !test.sampled {
238 ext.SamplingPriority.Set(span, 0)
239 }
240 mSpan := span.(*MockSpan)
241
242 assert.Equal(t, opentracing.ErrUnsupportedFormat,
243 tracer.Inject(span.Context(), opentracing.Binary, nil))
244 assert.Equal(t, opentracing.ErrInvalidCarrier,
245 tracer.Inject(span.Context(), opentracing.TextMap, span))
246
247 carrier := test.carrier()
248
249 err := tracer.Inject(span.Context(), test.format, carrier)
250 require.NoError(t, err)
251 assert.Equal(t, 4, test.len(carrier), "expect baggage + 2 ids + sampled")
252 if test.format == opentracing.HTTPHeaders {
253 c := carrier.(opentracing.HTTPHeadersCarrier)
254 assert.Equal(t, "y%3Az", c["Mockpfx-Baggage-X"][0])
255 }
256
257 _, err = tracer.Extract(opentracing.Binary, nil)
258 assert.Equal(t, opentracing.ErrUnsupportedFormat, err)
259 _, err = tracer.Extract(opentracing.TextMap, tracer)
260 assert.Equal(t, opentracing.ErrInvalidCarrier, err)
261
262 extractedContext, err := tracer.Extract(test.format, carrier)
263 require.NoError(t, err)
264 assert.Equal(t, mSpan.SpanContext.TraceID, extractedContext.(MockSpanContext).TraceID)
265 assert.Equal(t, mSpan.SpanContext.SpanID, extractedContext.(MockSpanContext).SpanID)
266 assert.Equal(t, test.sampled, extractedContext.(MockSpanContext).Sampled)
267 assert.Equal(t, "y:z", extractedContext.(MockSpanContext).Baggage["x"])
268 }
269 }
270
271 func TestMockSpan_Races(t *testing.T) {
272 span := New().StartSpan("x")
273 var wg sync.WaitGroup
274 wg.Add(2)
275 go func() {
276 defer wg.Done()
277 span.SetBaggageItem("test_key", "test_value")
278 }()
279 go func() {
280 defer wg.Done()
281 span.Context()
282 }()
283 wg.Wait()
284 }