b3_test.go

Documentation: go.opencensus.io/plugin/ochttp/propagation/b3

     1  // Copyright 2018, OpenCensus Authors
     2  //
     3  // Licensed under the Apache License, Version 2.0 (the "License");
     4  // you may not use this file except in compliance with the License.
     5  // You may obtain a copy of the License at
     6  //
     7  //     http://www.apache.org/licenses/LICENSE-2.0
     8  //
     9  // Unless required by applicable law or agreed to in writing, software
    10  // distributed under the License is distributed on an "AS IS" BASIS,
    11  // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    12  // See the License for the specific language governing permissions and
    13  // limitations under the License.
    14  
    15  package b3
    16  
    17  import (
    18  	"net/http"
    19  	"reflect"
    20  	"testing"
    21  
    22  	"go.opencensus.io/trace"
    23  )
    24  
    25  func TestHTTPFormat_FromRequest(t *testing.T) {
    26  	tests := []struct {
    27  		name    string
    28  		makeReq func() *http.Request
    29  		wantSc  trace.SpanContext
    30  		wantOk  bool
    31  	}{
    32  		{
    33  			name: "128-bit trace ID + 64-bit span ID; sampled=1",
    34  			makeReq: func() *http.Request {
    35  				req, _ := http.NewRequest("GET", "http://example.com", nil)
    36  				req.Header.Set(TraceIDHeader, "463ac35c9f6413ad48485a3953bb6124")
    37  				req.Header.Set(SpanIDHeader, "0020000000000001")
    38  				req.Header.Set(SampledHeader, "1")
    39  				return req
    40  			},
    41  			wantSc: trace.SpanContext{
    42  				TraceID:      trace.TraceID{70, 58, 195, 92, 159, 100, 19, 173, 72, 72, 90, 57, 83, 187, 97, 36},
    43  				SpanID:       trace.SpanID{0, 32, 0, 0, 0, 0, 0, 1},
    44  				TraceOptions: trace.TraceOptions(1),
    45  			},
    46  			wantOk: true,
    47  		},
    48  		{
    49  			name: "short trace ID + short span ID; sampled=1",
    50  			makeReq: func() *http.Request {
    51  				req, _ := http.NewRequest("GET", "http://example.com", nil)
    52  				req.Header.Set(TraceIDHeader, "000102")
    53  				req.Header.Set(SpanIDHeader, "000102")
    54  				req.Header.Set(SampledHeader, "1")
    55  				return req
    56  			},
    57  			wantSc: trace.SpanContext{
    58  				TraceID:      trace.TraceID{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 2},
    59  				SpanID:       trace.SpanID{0, 0, 0, 0, 0, 0, 1, 2},
    60  				TraceOptions: trace.TraceOptions(1),
    61  			},
    62  			wantOk: true,
    63  		},
    64  		{
    65  			name: "64-bit trace ID + 64-bit span ID; sampled=0",
    66  			makeReq: func() *http.Request {
    67  				req, _ := http.NewRequest("GET", "http://example.com", nil)
    68  				req.Header.Set(TraceIDHeader, "0020000000000001")
    69  				req.Header.Set(SpanIDHeader, "0020000000000001")
    70  				req.Header.Set(SampledHeader, "0")
    71  				return req
    72  			},
    73  			wantSc: trace.SpanContext{
    74  				TraceID:      trace.TraceID{0, 0, 0, 0, 0, 0, 0, 0, 0, 32, 0, 0, 0, 0, 0, 1},
    75  				SpanID:       trace.SpanID{0, 32, 0, 0, 0, 0, 0, 1},
    76  				TraceOptions: trace.TraceOptions(0),
    77  			},
    78  			wantOk: true,
    79  		},
    80  		{
    81  			name: "128-bit trace ID + 64-bit span ID; no sampling header",
    82  			makeReq: func() *http.Request {
    83  				req, _ := http.NewRequest("GET", "http://example.com", nil)
    84  				req.Header.Set(TraceIDHeader, "463ac35c9f6413ad48485a3953bb6124")
    85  				req.Header.Set(SpanIDHeader, "0020000000000001")
    86  				return req
    87  			},
    88  			wantSc: trace.SpanContext{
    89  				TraceID:      trace.TraceID{70, 58, 195, 92, 159, 100, 19, 173, 72, 72, 90, 57, 83, 187, 97, 36},
    90  				SpanID:       trace.SpanID{0, 32, 0, 0, 0, 0, 0, 1},
    91  				TraceOptions: trace.TraceOptions(0),
    92  			},
    93  			wantOk: true,
    94  		},
    95  		{
    96  			name: "invalid trace ID + 64-bit span ID; no sampling header",
    97  			makeReq: func() *http.Request {
    98  				req, _ := http.NewRequest("GET", "http://example.com", nil)
    99  				req.Header.Set(TraceIDHeader, "")
   100  				req.Header.Set(SpanIDHeader, "0020000000000001")
   101  				return req
   102  			},
   103  			wantSc: trace.SpanContext{},
   104  			wantOk: false,
   105  		},
   106  		{
   107  			name: "invalid >128-bit trace ID + 64-bit span ID; no sampling header",
   108  			makeReq: func() *http.Request {
   109  				req, _ := http.NewRequest("GET", "http://example.com", nil)
   110  				req.Header.Set(TraceIDHeader, "0020000000000001002000000000000111")
   111  				req.Header.Set(SpanIDHeader, "0020000000000001")
   112  				return req
   113  			},
   114  			wantSc: trace.SpanContext{},
   115  			wantOk: false,
   116  		},
   117  		{
   118  			name: "128-bit trace ID; invalid span ID; no sampling header",
   119  			makeReq: func() *http.Request {
   120  				req, _ := http.NewRequest("GET", "http://example.com", nil)
   121  				req.Header.Set(TraceIDHeader, "463ac35c9f6413ad48485a3953bb6124")
   122  				req.Header.Set(SpanIDHeader, "")
   123  				return req
   124  			},
   125  			wantSc: trace.SpanContext{},
   126  			wantOk: false,
   127  		},
   128  		{
   129  			name: "128-bit trace ID; invalid >64 bit span ID; no sampling header",
   130  			makeReq: func() *http.Request {
   131  				req, _ := http.NewRequest("GET", "http://example.com", nil)
   132  				req.Header.Set(TraceIDHeader, "463ac35c9f6413ad48485a3953bb6124")
   133  				req.Header.Set(SpanIDHeader, "002000000000000111")
   134  				return req
   135  			},
   136  			wantSc: trace.SpanContext{},
   137  			wantOk: false,
   138  		},
   139  		{
   140  			name: "128-bit trace ID + 64-bit span ID; sampled=true",
   141  			makeReq: func() *http.Request {
   142  				req, _ := http.NewRequest("GET", "http://example.com", nil)
   143  				req.Header.Set(TraceIDHeader, "463ac35c9f6413ad48485a3953bb6124")
   144  				req.Header.Set(SpanIDHeader, "0020000000000001")
   145  				req.Header.Set(SampledHeader, "true")
   146  				return req
   147  			},
   148  			wantSc: trace.SpanContext{
   149  				TraceID:      trace.TraceID{70, 58, 195, 92, 159, 100, 19, 173, 72, 72, 90, 57, 83, 187, 97, 36},
   150  				SpanID:       trace.SpanID{0, 32, 0, 0, 0, 0, 0, 1},
   151  				TraceOptions: trace.TraceOptions(1),
   152  			},
   153  			wantOk: true,
   154  		},
   155  		{
   156  			name: "128-bit trace ID + 64-bit span ID; sampled=false",
   157  			makeReq: func() *http.Request {
   158  				req, _ := http.NewRequest("GET", "http://example.com", nil)
   159  				req.Header.Set(TraceIDHeader, "463ac35c9f6413ad48485a3953bb6124")
   160  				req.Header.Set(SpanIDHeader, "0020000000000001")
   161  				req.Header.Set(SampledHeader, "false")
   162  				return req
   163  			},
   164  			wantSc: trace.SpanContext{
   165  				TraceID:      trace.TraceID{70, 58, 195, 92, 159, 100, 19, 173, 72, 72, 90, 57, 83, 187, 97, 36},
   166  				SpanID:       trace.SpanID{0, 32, 0, 0, 0, 0, 0, 1},
   167  				TraceOptions: trace.TraceOptions(0),
   168  			},
   169  			wantOk: true,
   170  		},
   171  	}
   172  	for _, tt := range tests {
   173  		t.Run(tt.name, func(t *testing.T) {
   174  			f := &HTTPFormat{}
   175  			sc, ok := f.SpanContextFromRequest(tt.makeReq())
   176  			if ok != tt.wantOk {
   177  				t.Errorf("HTTPFormat.SpanContextFromRequest() got ok = %v, want %v", ok, tt.wantOk)
   178  			}
   179  			if !reflect.DeepEqual(sc, tt.wantSc) {
   180  				t.Errorf("HTTPFormat.SpanContextFromRequest() got span context = %v, want %v", sc, tt.wantSc)
   181  			}
   182  		})
   183  	}
   184  }
   185  
   186  func TestHTTPFormat_ToRequest(t *testing.T) {
   187  	tests := []struct {
   188  		name        string
   189  		sc          trace.SpanContext
   190  		wantHeaders map[string]string
   191  	}{
   192  		{
   193  			name: "valid traceID, header ID, sampled=1",
   194  			sc: trace.SpanContext{
   195  				TraceID:      trace.TraceID{70, 58, 195, 92, 159, 100, 19, 173, 72, 72, 90, 57, 83, 187, 97, 36},
   196  				SpanID:       trace.SpanID{0, 32, 0, 0, 0, 0, 0, 1},
   197  				TraceOptions: trace.TraceOptions(1),
   198  			},
   199  			wantHeaders: map[string]string{
   200  				"X-B3-TraceId": "463ac35c9f6413ad48485a3953bb6124",
   201  				"X-B3-SpanId":  "0020000000000001",
   202  				"X-B3-Sampled": "1",
   203  			},
   204  		},
   205  		{
   206  			name: "valid traceID, header ID, sampled=0",
   207  			sc: trace.SpanContext{
   208  				TraceID:      trace.TraceID{70, 58, 195, 92, 159, 100, 19, 173, 72, 72, 90, 57, 83, 187, 97, 36},
   209  				SpanID:       trace.SpanID{0, 32, 0, 0, 0, 0, 0, 1},
   210  				TraceOptions: trace.TraceOptions(0),
   211  			},
   212  			wantHeaders: map[string]string{
   213  				"X-B3-TraceId": "463ac35c9f6413ad48485a3953bb6124",
   214  				"X-B3-SpanId":  "0020000000000001",
   215  				"X-B3-Sampled": "0",
   216  			},
   217  		},
   218  	}
   219  	for _, tt := range tests {
   220  		t.Run(tt.name, func(t *testing.T) {
   221  			f := &HTTPFormat{}
   222  			req, _ := http.NewRequest("GET", "http://example.com", nil)
   223  			f.SpanContextToRequest(tt.sc, req)
   224  
   225  			for k, v := range tt.wantHeaders {
   226  				if got, want := req.Header.Get(k), v; got != want {
   227  					t.Errorf("req.Header.Get(%q) = %q; want %q", k, got, want)
   228  				}
   229  			}
   230  		})
   231  	}
   232  }
   233
View as plain text