aboutsummaryrefslogtreecommitdiffstats
path: root/vendor/go.opentelemetry.io/otel/trace/context_test.go
blob: c7529022991df887d33c81b71bfbdc44302901f6 (plain) (blame)
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
// Copyright The OpenTelemetry 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.

package trace // import "go.opentelemetry.io/otel/trace"

import (
	"context"
	"testing"

	"github.com/stretchr/testify/assert"
)

type testSpan struct {
	noopSpan

	ID     byte
	Remote bool
}

func (s testSpan) SpanContext() SpanContext {
	return SpanContext{
		traceID: [16]byte{1},
		spanID:  [8]byte{s.ID},
		remote:  s.Remote,
	}
}

var (
	emptySpan   = noopSpan{}
	localSpan   = testSpan{ID: 1, Remote: false}
	remoteSpan  = testSpan{ID: 1, Remote: true}
	wrappedSpan = nonRecordingSpan{sc: remoteSpan.SpanContext()}
)

func TestSpanFromContext(t *testing.T) {
	testCases := []struct {
		name         string
		context      context.Context
		expectedSpan Span
	}{
		{
			name:         "empty context",
			context:      nil,
			expectedSpan: emptySpan,
		},
		{
			name:         "background context",
			context:      context.Background(),
			expectedSpan: emptySpan,
		},
		{
			name:         "local span",
			context:      ContextWithSpan(context.Background(), localSpan),
			expectedSpan: localSpan,
		},
		{
			name:         "remote span",
			context:      ContextWithSpan(context.Background(), remoteSpan),
			expectedSpan: remoteSpan,
		},
		{
			name:         "wrapped remote span",
			context:      ContextWithRemoteSpanContext(context.Background(), remoteSpan.SpanContext()),
			expectedSpan: wrappedSpan,
		},
		{
			name:         "wrapped local span becomes remote",
			context:      ContextWithRemoteSpanContext(context.Background(), localSpan.SpanContext()),
			expectedSpan: wrappedSpan,
		},
	}

	for _, tc := range testCases {
		t.Run(tc.name, func(t *testing.T) {
			assert.Equal(t, tc.expectedSpan, SpanFromContext(tc.context))

			// Ensure SpanContextFromContext is just
			// SpanFromContext(…).SpanContext().
			assert.Equal(t, tc.expectedSpan.SpanContext(), SpanContextFromContext(tc.context))
		})
	}
}