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
|
// Copyright The OpenTelemetry Authors
// SPDX-License-Identifier: Apache-2.0
package propagation_test
import (
"context"
"slices"
"strings"
"testing"
"github.com/stretchr/testify/assert"
"go.opentelemetry.io/otel/propagation"
)
type ctxKeyType uint
var ctxKey ctxKeyType
type carrier []string
func (c *carrier) Keys() []string { return nil }
func (c *carrier) Get(string) string { return "" }
func (c *carrier) Set(setter, _ string) {
*c = append(*c, setter)
}
type propagator struct {
Name string
}
func (p propagator) Inject(ctx context.Context, carrier propagation.TextMapCarrier) {
carrier.Set(p.Name, "")
}
func (p propagator) Extract(ctx context.Context, carrier propagation.TextMapCarrier) context.Context {
v := ctx.Value(ctxKey)
if v == nil {
ctx = context.WithValue(ctx, ctxKey, []string{p.Name})
} else {
orig := v.([]string)
ctx = context.WithValue(ctx, ctxKey, append(orig, p.Name))
}
return ctx
}
func (p propagator) Fields() []string { return []string{p.Name} }
func TestCompositeTextMapPropagatorFields(t *testing.T) {
a, b1, b2 := propagator{"a"}, propagator{"b"}, propagator{"b"}
want := map[string]struct{}{
"a": {},
"b": {},
}
got := propagation.NewCompositeTextMapPropagator(a, b1, b2).Fields()
if len(got) != len(want) {
t.Fatalf("invalid fields from composite: %v (want %v)", got, want)
}
for _, v := range got {
if _, ok := want[v]; !ok {
t.Errorf("invalid field returned from composite: %q", v)
}
}
}
func TestCompositeTextMapPropagatorInject(t *testing.T) {
a, b := propagator{"a"}, propagator{"b"}
c := make(carrier, 0, 2)
propagation.NewCompositeTextMapPropagator(a, b).Inject(context.Background(), &c)
if got := strings.Join([]string(c), ","); got != "a,b" {
t.Errorf("invalid inject order: %s", got)
}
}
func TestCompositeTextMapPropagatorExtract(t *testing.T) {
a, b := propagator{"a"}, propagator{"b"}
ctx := context.Background()
ctx = propagation.NewCompositeTextMapPropagator(a, b).Extract(ctx, nil)
v := ctx.Value(ctxKey)
if v == nil {
t.Fatal("no composite extraction")
}
if got := strings.Join(v.([]string), ","); got != "a,b" {
t.Errorf("invalid extract order: %s", got)
}
}
func TestMapCarrierGet(t *testing.T) {
carrier := propagation.MapCarrier{
"foo": "bar",
"baz": "qux",
}
assert.Equal(t, "bar", carrier.Get("foo"))
assert.Equal(t, "qux", carrier.Get("baz"))
}
func TestMapCarrierSet(t *testing.T) {
carrier := make(propagation.MapCarrier)
carrier.Set("foo", "bar")
carrier.Set("baz", "qux")
assert.Equal(t, "bar", carrier["foo"])
assert.Equal(t, "qux", carrier["baz"])
}
func TestMapCarrierKeys(t *testing.T) {
carrier := propagation.MapCarrier{
"foo": "bar",
"baz": "qux",
}
keys := carrier.Keys()
slices.Sort(keys)
assert.Equal(t, []string{"baz", "foo"}, keys)
}
|
