phos/fuzz_test.go at main · johan-st/phos · GitHub

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
package phos

import (
	"context"
	"testing"
)

func FuzzParseTraceParent(f *testing.F) {
	seeds := []string{
		validVersion00TraceParent,
		validUnsampledTraceParent,
		validFutureTraceParent,
		"",
		"00-00000000000000000000000000000000-0000000000000000-00",
		"zz-not-a-traceparent",
	}
	for _, seed := range seeds {
		f.Add(seed)
	}

	f.Fuzz(func(t *testing.T, input string) {
		got, err := ParseTraceParent(input)
		if err != nil {
			return
		}
		if !isLowerHex(got.Version, 2) || got.Version == "ff" {
			t.Fatalf("accepted invalid version %#v", got)
		}
		if !isLowerHex(got.TraceID, 32) || isAllZeroHex(got.TraceID) {
			t.Fatalf("accepted invalid trace id %#v", got)
		}
		if !isLowerHex(got.Parent, 16) || isAllZeroHex(got.Parent) {
			t.Fatalf("accepted invalid parent id %#v", got)
		}
		if !isLowerHex(got.Flags, 2) {
			t.Fatalf("accepted invalid flags %#v", got)
		}

		reparsed, reparsedErr := ParseTraceParent(got.String())
		if reparsedErr != nil {
			t.Fatalf("ParseTraceParent(String()) error = %v", reparsedErr)
		}
		if reparsed != got {
			t.Fatalf("reparsed = %#v, want %#v", reparsed, got)
		}
	})
}

func FuzzInjectExtractRoundTrip(f *testing.F) {
	f.Add(validVersion00TraceParent, "rojo=1,congo=2")
	f.Add(validUnsampledTraceParent, "")
	f.Add(validVersion00TraceParent, "0")
	f.Add(validVersion00TraceParent, "a=1,,b=2")

	f.Fuzz(func(t *testing.T, traceParentValue, traceState string) {
		if _, err := ParseTraceParent(traceParentValue); err != nil {
			return
		}

		ctx := ExtractTraceContext(context.Background(), MapCarrier{
			TraceParentHeader: traceParentValue,
			TraceStateHeader:  traceState,
		})
		ctx, started := NewSpan(ctx, "child")
		defer started.End()
		sp := started

		carrier := MapCarrier{}
		InjectTraceContext(ctx, carrier)
		got, err := ParseTraceParent(carrier[TraceParentHeader])
		if err != nil {
			t.Fatalf("ParseTraceParent() error = %v", err)
		}
		if got.TraceID != sp.traceID {
			t.Fatalf("TraceID = %q, want %q", got.TraceID, sp.traceID)
		}
		if got.Parent != sp.id {
			t.Fatalf("Parent = %q, want %q", got.Parent, sp.id)
		}
		if got.Flags != outgoingTraceFlagsForValue(sp.traceFlags) {
			t.Fatalf("Flags = %q, want %q", got.Flags, outgoingTraceFlagsForValue(sp.traceFlags))
		}
		wantTraceState := traceState
		if validateTraceState(traceState) != nil {
			wantTraceState = ""
		}
		if carrier[TraceStateHeader] != wantTraceState {
			t.Fatalf("TraceState = %q, want %q", carrier[TraceStateHeader], wantTraceState)
		}
	})
}

func TestGeneratedIDsHaveExpectedShape(t *testing.T) {
	for range 100 {
		ctx, started := NewSpan(context.Background(), "root")
		sp := started

		if !isLowerHex(sp.id, 16) || isAllZeroHex(sp.id) {
			t.Fatalf("span id = %q, want 16 lowercase hex chars and not all zero", sp.id)
		}
		if !isLowerHex(sp.traceID, 32) || isAllZeroHex(sp.traceID) {
			t.Fatalf("trace id = %q, want 32 lowercase hex chars and not all zero", sp.traceID)
		}

		carrier := MapCarrier{}
		InjectTraceContext(ctx, carrier)
		if _, err := ParseTraceParent(carrier[TraceParentHeader]); err != nil {
			t.Fatalf("ParseTraceParent() error = %v", err)
		}
	}
}