Debian Codegraph @

internal/global/state_test.go

raw
1 // Copyright The OpenTelemetry Authors
2 // SPDX-License-Identifier: Apache-2.0
3
4 package global
5
6 import (
7 "testing"
8
9 "github.com/stretchr/testify/assert"
10
11 "go.opentelemetry.io/otel/metric"
12 metricnoop "go.opentelemetry.io/otel/metric/noop"
13 "go.opentelemetry.io/otel/propagation"
14 "go.opentelemetry.io/otel/trace"
15 tracenoop "go.opentelemetry.io/otel/trace/noop"
16 )
17
18 type nonComparableTracerProvider struct {
19 trace.TracerProvider
20
21 nonComparable func() //nolint:unused // This is not called.
22 }
23
24 type nonComparableMeterProvider struct {
25 metric.MeterProvider
26
27 nonComparable func() //nolint:unused // This is not called.
28 }
29
30 func TestSetTracerProvider(t *testing.T) {
31 t.Run("Set With default is a noop", func(t *testing.T) {
32 ResetForTest(t)
33 SetTracerProvider(TracerProvider())
34
35 tp, ok := TracerProvider().(*tracerProvider)
36 if !ok {
37 t.Fatal("Global TracerProvider should be the default tracer provider")
38 }
39
40 if tp.delegate != nil {
41 t.Fatal("tracer provider should not delegate when setting itself")
42 }
43 })
44
45 t.Run("First Set() should replace the delegate", func(t *testing.T) {
46 ResetForTest(t)
47
48 SetTracerProvider(tracenoop.NewTracerProvider())
49
50 _, ok := TracerProvider().(*tracerProvider)
51 if ok {
52 t.Fatal("Global TracerProvider was not changed")
53 }
54 })
55
56 t.Run("Set() should delegate existing TracerProviders", func(t *testing.T) {
57 ResetForTest(t)
58
59 tp := TracerProvider()
60 SetTracerProvider(tracenoop.NewTracerProvider())
61
62 ntp := tp.(*tracerProvider)
63
64 if ntp.delegate == nil {
65 t.Fatal("The delegated tracer providers should have a delegate")
66 }
67 })
68
69 t.Run("non-comparable types should not panic", func(t *testing.T) {
70 ResetForTest(t)
71
72 tp := nonComparableTracerProvider{}
73 SetTracerProvider(tp)
74 assert.NotPanics(t, func() { SetTracerProvider(tp) })
75 })
76 }
77
78 func TestSetTextMapPropagator(t *testing.T) {
79 t.Run("Set With default is a noop", func(t *testing.T) {
80 ResetForTest(t)
81 SetTextMapPropagator(TextMapPropagator())
82
83 tmp, ok := TextMapPropagator().(*textMapPropagator)
84 if !ok {
85 t.Fatal("Global TextMapPropagator should be the default propagator")
86 }
87
88 if tmp.delegate != nil {
89 t.Fatal("TextMapPropagator should not delegate when setting itself")
90 }
91 })
92
93 t.Run("First Set() should replace the delegate", func(t *testing.T) {
94 ResetForTest(t)
95
96 SetTextMapPropagator(propagation.TraceContext{})
97
98 _, ok := TextMapPropagator().(*textMapPropagator)
99 if ok {
100 t.Fatal("Global TextMapPropagator was not changed")
101 }
102 })
103
104 t.Run("Set() should delegate existing propagators", func(t *testing.T) {
105 ResetForTest(t)
106
107 p := TextMapPropagator()
108 SetTextMapPropagator(propagation.TraceContext{})
109
110 np := p.(*textMapPropagator)
111
112 if np.delegate == nil {
113 t.Fatal("The delegated TextMapPropagators should have a delegate")
114 }
115 })
116
117 t.Run("non-comparable types should not panic", func(t *testing.T) {
118 ResetForTest(t)
119
120 // A composite TextMapPropagator is not comparable.
121 prop := propagation.NewCompositeTextMapPropagator(propagation.TraceContext{})
122 SetTextMapPropagator(prop)
123 assert.NotPanics(t, func() { SetTextMapPropagator(prop) })
124 })
125 }
126
127 func TestSetMeterProvider(t *testing.T) {
128 t.Run("Set With default is a noop", func(t *testing.T) {
129 ResetForTest(t)
130
131 SetMeterProvider(MeterProvider())
132
133 mp, ok := MeterProvider().(*meterProvider)
134 if !ok {
135 t.Fatal("Global MeterProvider should be the default meter provider")
136 }
137
138 if mp.delegate != nil {
139 t.Fatal("meter provider should not delegate when setting itself")
140 }
141 })
142
143 t.Run("First Set() should replace the delegate", func(t *testing.T) {
144 ResetForTest(t)
145
146 SetMeterProvider(metricnoop.NewMeterProvider())
147
148 _, ok := MeterProvider().(*meterProvider)
149 if ok {
150 t.Fatal("Global MeterProvider was not changed")
151 }
152 })
153
154 t.Run("Set() should delegate existing Meter Providers", func(t *testing.T) {
155 ResetForTest(t)
156
157 mp := MeterProvider()
158
159 SetMeterProvider(metricnoop.NewMeterProvider())
160
161 dmp := mp.(*meterProvider)
162
163 if dmp.delegate == nil {
164 t.Fatal("The delegated meter providers should have a delegate")
165 }
166 })
167
168 t.Run("non-comparable types should not panic", func(t *testing.T) {
169 ResetForTest(t)
170
171 mp := nonComparableMeterProvider{}
172 SetMeterProvider(mp)
173 assert.NotPanics(t, func() { SetMeterProvider(mp) })
174 })
175 }