Adding more unit test cases including (#8)

* noop test
 * gRPC reporter test
 * tracer parameter test
 * and so on

Makefile

@@ -7,7 +7,7 @@ GRPC_PATH := $(GO2SKY_GO)/reporter/grpc
 
 .PHONY: test
 test:
-	go test -v -race -cover ./...
+	go test -v -race -cover `go list ./... | grep -v github.com/tetratelabs/go2sky/reporter/grpc`
 
 .PHONY: proto-gen
 proto-gen:

noop_test.go

@@ -18,12 +18,15 @@ import (
 	"context"
 	"sync"
 	"testing"
+	"time"
+
+	"github.com/tetratelabs/go2sky/reporter/grpc/common"
 )
 
 type createFunc func() (Span, context.Context, error)
 
 func TestCreateNoopSpan(t *testing.T) {
-	tracer, _ := NewTracer("")
+	tracer, _ := NewTracer("noop")
 	tests := []struct {
 		name string
 		n    createFunc
@@ -31,13 +34,17 @@ func TestCreateNoopSpan(t *testing.T) {
 		{
 			"Entry",
 			func() (Span, context.Context, error) {
-				return tracer.CreateEntrySpan(context.Background(), "", nil)
+				return tracer.CreateEntrySpan(context.Background(), "entry", func() (s string, e error) {
+					return "", nil
+				})
 			},
 		},
 		{
 			"Exit",
 			func() (s Span, c context.Context, err error) {
-				s, err = tracer.CreateExitSpan(context.Background(), "", "", nil)
+				s, err = tracer.CreateExitSpan(context.Background(), "exit", "localhost:8080", func(header string) error {
+					return nil
+				})
 				return
 			},
 		},
@@ -64,14 +71,18 @@ func TestNoopSpanFromBegin(t *testing.T) {
 	r := &registerReporter{
 		wg: wg,
 	}
-	tracer, _ := NewTracer("", WithReporter(r))
-	span, ctx, _ := tracer.CreateEntrySpan(context.Background(), "", nil)
+	tracer, _ := NewTracer("service", WithReporter(r))
+	span, ctx, _ := tracer.CreateEntrySpan(context.Background(), "entry", func() (s string, e error) {
+		return "", nil
+	})
 	if _, ok := span.(*NoopSpan); !ok {
 		t.Error("Should create noop span")
 	}
 	wg.Done()
 	tracer.WaitUntilRegister()
-	exitSpan, _ := tracer.CreateExitSpan(ctx, "", "", nil)
+	exitSpan, _ := tracer.CreateExitSpan(ctx, "exit", "localhost:8080", func(header string) error {
+		return nil
+	})
 	if _, ok := exitSpan.(*NoopSpan); !ok {
 		t.Error("Should create noop span")
 	}
@@ -93,3 +104,13 @@ func (r *registerReporter) Register(service string, instance string) (int32, int
 	r.wg.Wait()
 	return 0, 0, nil
 }
+
+func TestNoopMethod(t *testing.T) {
+	n := NoopSpan{}
+	n.SetOperationName("aa")
+	n.SetPeer("localhost:1111")
+	n.SetSpanLayer(common.SpanLayer_Database)
+	n.Tag("key", "value")
+	n.Log(time.Now(), "key", "value")
+	n.Error(time.Now(), "key", "value")
+}

reporter/grpc.go

@@ -231,22 +231,24 @@ func (r *gRPCReporter) Send(spans []go2sky.ReportedSpan) {
 	}
 	b, err := proto.Marshal(segmentObject)
 	if err != nil {
-		log.Printf("marshal segment object err %v", err)
+		r.logger.Printf("marshal segment object err %v", err)
 		return
 	}
 	segment.Segment = b
 	select {
 	case r.sendCh <- segment:
 	default:
-		log.Printf("reach max send buffer")
+		r.logger.Printf("reach max send buffer")
 	}
 }
 
 func (r *gRPCReporter) Close() {
 	close(r.sendCh)
-	err := r.conn.Close()
-	if err != nil {
-		r.logger.Print(err)
+	if r.conn != nil {
+		err := r.conn.Close()
+		if err != nil {
+			r.logger.Print(err)
+		}
 	}
 }
 

reporter/grpc_test.go

@@ -15,26 +15,81 @@
 package reporter
 
 import (
+	"context"
 	"fmt"
 	"log"
 	"math/rand"
 	"os"
+	"strings"
 	"testing"
 
 	"github.com/golang/mock/gomock"
 
+	"github.com/tetratelabs/go2sky"
 	"github.com/tetratelabs/go2sky/reporter/grpc/common"
 	"github.com/tetratelabs/go2sky/reporter/grpc/register"
 	"github.com/tetratelabs/go2sky/reporter/grpc/register/mock_register"
 )
 
+const header string = "1-MTU1NTY0NDg4Mjk2Nzg2ODAwMC4wLjU5NDYzNzUyMDYzMzg3NDkwODc=" +
+	"-NS4xNTU1NjQ0ODgyOTY3ODg5MDAwLjM3NzUyMjE1NzQ0Nzk0NjM3NTg=" +
+	"-1-2-3-I2NvbS5oZWxsby5IZWxsb1dvcmxk-Iy9yZXN0L2Fh-Iy9nYXRld2F5L2Nj"
+
 func Test_gRPCReporter_Register(t *testing.T) {
+	serviceName, serviceID, instanceName, instanceID, reporter := createMockReporter(t)
+	aServiceID, aInstanceID, err := reporter.Register(serviceName, instanceName)
+	if err != nil || serviceID != aServiceID || instanceID != aInstanceID {
+		t.Errorf("register service and instance error")
+	}
+}
+
+func Test_e2e(t *testing.T) {
+	serviceName, _, instance, _, reporter := createMockReporter(t)
+	reporter.sendCh = make(chan *common.UpstreamSegment, 10)
+	tracer, err := go2sky.NewTracer(serviceName, go2sky.WithReporter(reporter), go2sky.WithInstance(instance))
+	if err != nil {
+		t.Error(err)
+	}
+	tracer.WaitUntilRegister()
+	entrySpan, ctx, err := tracer.CreateEntrySpan(context.Background(), "/rest/api", func() (string, error) {
+		return header, nil
+	})
+	if err != nil {
+		t.Error(err)
+	}
+	exitSpan, err := tracer.CreateExitSpan(ctx, "/foo/bar", "foo.svc:8787", func(head string) error {
+		if head == "" {
+			t.Fail()
+		}
+		if len(strings.Split(head, "-")) != 9 {
+			t.Fail()
+		}
+		return nil
+	})
+	if err != nil {
+		t.Error(err)
+	}
+	exitSpan.End()
+	entrySpan.End()
+	for s := range reporter.sendCh {
+		reporter.Close()
+		if len(s.GlobalTraceIds) != 1 && len(s.GlobalTraceIds[0].IdParts) != 3 {
+			t.Error("trace id format is incorrect")
+		}
+		if s.Segment == nil {
+			t.Error("null segment")
+		}
+	}
+}
+
+func createMockReporter(t *testing.T) (string, int32, string, int32, *gRPCReporter) {
 	ctrl := gomock.NewController(t)
 	mockRegisterClient := mock_register.NewMockRegisterClient(ctrl)
 	reporter := &gRPCReporter{
 		registerClient: mockRegisterClient,
 		logger:         log.New(os.Stderr, "go2sky", log.LstdFlags),
 	}
+
 	serviceID := rand.Int31()
 	serviceName := fmt.Sprintf("service-%d", serviceID)
 	mockRegisterClient.EXPECT().DoServiceRegister(
@@ -53,8 +108,5 @@ func Test_gRPCReporter_Register(t *testing.T) {
 		Value: instanceID,
 		Key:   instanceName,
 	}}}, nil)
-	aServiceID, aInstanceID, err := reporter.Register(serviceName, instanceName)
-	if err != nil || serviceID != aServiceID || instanceID != aInstanceID {
-		t.Errorf("register service and instance error")
-	}
+	return serviceName, serviceID, instanceName, instanceID, reporter
 }

segment.go

@@ -86,7 +86,7 @@ func (s *segmentSpanImpl) End() {
 	}()
 }
 
-// For Span
+// For Reported Span
 
 func (s *segmentSpanImpl) Context() *SegmentContext {
 	return &s.SegmentContext

segment_test.go

@@ -30,8 +30,8 @@ func TestSyncSegment(t *testing.T) {
 	tracer, _ := NewTracer("segmentTest", WithReporter(&mr))
 	tracer.WaitUntilRegister()
 	ctx := context.Background()
-	span, ctx, _ := tracer.CreateEntrySpan(ctx, "", MockExtractor)
-	eSpan, _ := tracer.CreateExitSpan(ctx, "", "", MockInjector)
+	span, ctx, _ := tracer.CreateEntrySpan(ctx, "entry", MockExtractor)
+	eSpan, _ := tracer.CreateExitSpan(ctx, "exit", "localhost:8080", MockInjector)
 	eSpan.End()
 	span.End()
 	wg.Wait()
@@ -51,14 +51,14 @@ func TestAsyncSingleSegment(t *testing.T) {
 	tracer, _ := NewTracer("segmentTest", WithReporter(&mr))
 	tracer.WaitUntilRegister()
 	ctx := context.Background()
-	span, ctx, _ := tracer.CreateEntrySpan(ctx, "", MockExtractor)
+	span, ctx, _ := tracer.CreateEntrySpan(ctx, "entry", MockExtractor)
 	go func() {
-		eSpan, _ := tracer.CreateExitSpan(ctx, "", "", MockInjector)
+		eSpan, _ := tracer.CreateExitSpan(ctx, "exit", "localhost:8080", MockInjector)
 		eSpan.End()
 		exitWg.Done()
 	}()
 	go func() {
-		eSpan, _ := tracer.CreateExitSpan(ctx, "", "", MockInjector)
+		eSpan, _ := tracer.CreateExitSpan(ctx, "exit", "localhost:8080", MockInjector)
 		eSpan.End()
 		exitWg.Done()
 	}()
@@ -79,19 +79,19 @@ func TestAsyncMultipleSegments(t *testing.T) {
 	tracer, _ := NewTracer("segmentTest", WithReporter(&mr))
 	tracer.WaitUntilRegister()
 	ctx := context.Background()
-	span, ctx, _ := tracer.CreateEntrySpan(ctx, "", MockExtractor)
+	span, ctx, _ := tracer.CreateEntrySpan(ctx, "entry", MockExtractor)
 	span.End()
 	reportWg.Wait()
 	reportWg.Add(2)
 	go func() {
 		oSpan, subCtx, _ := tracer.CreateLocalSpan(ctx)
-		eSpan, _ := tracer.CreateExitSpan(subCtx, "", "", MockInjector)
+		eSpan, _ := tracer.CreateExitSpan(subCtx, "exit", "localhost:8080", MockInjector)
 		eSpan.End()
 		oSpan.End()
 	}()
 	go func() {
 		oSpan, subCtx, _ := tracer.CreateLocalSpan(ctx)
-		eSpan, _ := tracer.CreateExitSpan(subCtx, "", "", MockInjector)
+		eSpan, _ := tracer.CreateExitSpan(subCtx, "exit", "localhost:8080", MockInjector)
 		eSpan.End()
 		oSpan.End()
 	}()

span_test.go

+// Copyright 2019 Tetrate Labs
+//
+// 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 go2sky
+
+import (
+	"math"
+	"testing"
+	"time"
+
+	"github.com/tetratelabs/go2sky/reporter/grpc/common"
+)
+
+func Test_defaultSpan_SetOperationName(t *testing.T) {
+	type args struct {
+		name string
+	}
+	tests := []struct {
+		name string
+		args args
+	}{
+		{
+			"set operation name",
+			struct{ name string }{name: "invoke method"},
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			ds := &defaultSpan{}
+			ds.SetOperationName(tt.args.name)
+			if ds.operationName != tt.args.name {
+				t.Error("operation name is different")
+			}
+		})
+	}
+}
+
+func Test_defaultSpan_SetPeer(t *testing.T) {
+	type args struct {
+		name string
+	}
+	tests := []struct {
+		name string
+		args args
+	}{
+		{
+			"set peer",
+			struct{ name string }{name: "localhost:9999"},
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			ds := &defaultSpan{}
+			ds.SetPeer(tt.args.name)
+			if ds.peer != tt.args.name {
+				t.Error("peer is different")
+			}
+		})
+	}
+}
+
+func Test_defaultSpan_SetSpanLayer(t *testing.T) {
+	type args struct {
+		layer common.SpanLayer
+	}
+	tests := []struct {
+		name string
+		args args
+	}{
+		{
+			"Set SpanLayer_Unknown",
+			struct{ layer common.SpanLayer }{layer: common.SpanLayer_Unknown},
+		},
+		{
+			"Set SpanLayer_Database",
+			struct{ layer common.SpanLayer }{layer: common.SpanLayer_Database},
+		},
+		{
+			"Set SpanLayer_RPCFramework",
+			struct{ layer common.SpanLayer }{layer: common.SpanLayer_RPCFramework},
+		},
+		{
+			"Set SpanLayer_Http",
+			struct{ layer common.SpanLayer }{layer: common.SpanLayer_Http},
+		},
+		{
+			"Set SpanLayer_MQ",
+			struct{ layer common.SpanLayer }{layer: common.SpanLayer_MQ},
+		},
+		{
+			"Set SpanLayer_Cache",
+			struct{ layer common.SpanLayer }{layer: common.SpanLayer_Cache},
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			ds := &defaultSpan{}
+			ds.SetSpanLayer(tt.args.layer)
+			if ds.layer != tt.args.layer {
+				t.Error("span layer is different")
+			}
+		})
+	}
+}
+
+func Test_defaultSpan_Tag(t *testing.T) {
+	type args struct {
+		key   string
+		value string
+	}
+	tests := []struct {
+		name string
+		args []*args
+	}{
+		{
+			"set null",
+			[]*args{{}},
+		},
+		{
+			"set tag",
+			[]*args{{key: "name", value: "value"}, {key: "name1", value: "value1"}},
+		},
+		{
+			"set duplicated tag",
+			[]*args{{key: "name", value: "value"}, {key: "name", value: "value"}},
+		},
+		{
+			"set invalid tag",
+			[]*args{{key: "name"}, {value: "value"}},
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			ds := &defaultSpan{}
+			for _, a := range tt.args {
+				ds.Tag(a.key, a.value)
+			}
+			if len(ds.tags) != len(tt.args) {
+				t.Error("tags are not set property")
+			}
+		})
+	}
+}
+
+func Test_defaultSpan_Log(t *testing.T) {
+	tests := []struct {
+		name string
+		ll   []string
+	}{
+		{
+			"set null logs",
+			[]string{},
+		},
+		{
+			"set logs",
+			[]string{"name", "value", "name1", "value1"},
+		},
+		{
+			"set duplicated logs",
+			[]string{"name", "value", "name1", "value1"},
+		},
+		{
+			"set invalid logs",
+			[]string{"name", "value", "name1"},
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			ds := &defaultSpan{}
+			ds.Log(time.Now(), tt.ll...)
+			if len(ds.logs) != 1 {
+				t.Error("logs are not set property")
+			}
+			for _, l := range ds.logs {
+				if len(l.Data) != int(math.Ceil(float64(len(tt.ll))/2)) {
+					t.Error("logs are not set property")
+				}
+			}
+		})
+	}
+}
+
+func Test_defaultSpan_Error(t *testing.T) {
+	tests := []struct {
+		name string
+		ll   []string
+	}{
+		{
+			"set errors",
+			[]string{"name", "value", "name1", "value1"},
+		},
+		{
+			"set duplicated errors",
+			[]string{"name", "value", "name1", "value1"},
+		},
+		{
+			"set invalid errors",
+			[]string{"name", "value", "name1"},
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			ds := &defaultSpan{}
+			ds.Error(time.Now(), tt.ll...)
+			if !ds.isError {
+				t.Error("errors are not set property")
+			}
+			if len(ds.logs) != 1 {
+				t.Error("errors are not set property")
+			}
+			for _, l := range ds.logs {
+				if len(l.Data) != int(math.Ceil(float64(len(tt.ll))/2)) {
+					t.Error("errors are not set property")
+				}
+			}
+		})
+	}
+}

trace.go

@@ -21,10 +21,13 @@ import (
 	"time"
 
 	"github.com/google/uuid"
+
 	"github.com/pkg/errors"
 	"github.com/tetratelabs/go2sky/propagation"
 )
 
+var errParameter = errors.New("parameter are nil")
+
 // Tracer is go2sky tracer implementation.
 type Tracer struct {
 	service  string
@@ -43,6 +46,9 @@ type TracerOption func(t *Tracer)
 
 // NewTracer return a new go2sky Tracer
 func NewTracer(service string, opts ...TracerOption) (tracer *Tracer, err error) {
+	if service == "" {
+		return nil, errParameter
+	}
 	t := &Tracer{
 		service:    service,
 		initFlag:   0,
@@ -52,14 +58,14 @@ func NewTracer(service string, opts ...TracerOption) (tracer *Tracer, err error)
 	for _, opt := range opts {
 		opt(t)
 	}
-	if t.instance == "" {
-		id, err := uuid.NewUUID()
-		if err != nil {
-			return nil, err
-		}
-		t.instance = id.String()
-	}
 	if t.reporter != nil {
+		if t.instance == "" {
+			id, err := uuid.NewUUID()
+			if err != nil {
+				return nil, err
+			}
+			t.instance = id.String()
+		}
 		t.wg = &sync.WaitGroup{}
 		t.wg.Add(1)
 		go func() {
@@ -89,6 +95,9 @@ func (t *Tracer) WaitUntilRegister() {
 
 // CreateEntrySpan creates and starts an entry span for incoming request
 func (t *Tracer) CreateEntrySpan(ctx context.Context, operationName string, extractor propagation.Extractor) (s Span, nCtx context.Context, err error) {
+	if ctx == nil || operationName == "" || extractor == nil {
+		return nil, nil, errParameter
+	}
 	if s, nCtx = t.createNoop(ctx); s != nil {
 		return
 	}
@@ -133,6 +142,9 @@ func (t *Tracer) CreateEntrySpan(ctx context.Context, operationName string, extr
 
 // CreateLocalSpan creates and starts a span for local usage
 func (t *Tracer) CreateLocalSpan(ctx context.Context, opts ...SpanOption) (s Span, c context.Context, err error) {
+	if ctx == nil {
+		return nil, nil, errParameter
+	}
 	if s, _ = t.createNoop(ctx); s != nil {
 		return
 	}
@@ -150,6 +162,9 @@ func (t *Tracer) CreateLocalSpan(ctx context.Context, opts ...SpanOption) (s Spa
 
 // CreateExitSpan creates and starts an exit span for client
 func (t *Tracer) CreateExitSpan(ctx context.Context, operationName string, peer string, injector propagation.Injector) (Span, error) {
+	if ctx == nil || operationName == "" || peer == "" || injector == nil {
+		return nil, errParameter
+	}
 	if s, _ := t.createNoop(ctx); s != nil {
 		return s, nil
 	}

trace_opts.go

@@ -20,3 +20,10 @@ func WithReporter(reporter Reporter) TracerOption {
 		t.reporter = reporter
 	}
 }
+
+// WithInstance setup instance identify
+func WithInstance(instance string) TracerOption {
+	return func(t *Tracer) {
+		t.instance = instance
+	}
+}

trace_propagation_test.go

@@ -28,7 +28,7 @@ const header string = "1-MTU1NTY0NDg4Mjk2Nzg2ODAwMC4wLjU5NDYzNzUyMDYzMzg3NDkwODc
 func TestTracer_EntryAndExit(t *testing.T) {
 	wg := &sync.WaitGroup{}
 	wg.Add(2)
-	tracer, err := NewTracer("", WithReporter(&NoopReporter{wg: wg}))
+	tracer, err := NewTracer("service", WithReporter(&NoopReporter{wg: wg}))
 	if err != nil {
 		t.Error(err)
 	}
@@ -60,7 +60,7 @@ func TestTracer_Entry(t *testing.T) {
 	wg := &sync.WaitGroup{}
 	wg.Add(1)
 	reporter := &NoopReporter{wg: wg}
-	tracer, err := NewTracer("", WithReporter(reporter))
+	tracer, err := NewTracer("service", WithReporter(reporter))
 	if err != nil {
 		t.Error(err)
 	}
@@ -86,7 +86,7 @@ func TestTracer_Entry(t *testing.T) {
 func TestTracer_EntryAndExitInTrace(t *testing.T) {
 	wg := &sync.WaitGroup{}
 	wg.Add(2)
-	tracer, err := NewTracer("", WithReporter(&NoopReporter{wg: wg}))
+	tracer, err := NewTracer("service", WithReporter(&NoopReporter{wg: wg}))
 	if err != nil {
 		t.Error(err)
 	}

trace_test.go

@@ -16,10 +16,12 @@ package go2sky
 
 import (
 	"context"
-	"errors"
 	"reflect"
 	"sync"
 	"testing"
+
+	"github.com/pkg/errors"
+	"github.com/tetratelabs/go2sky/propagation"
 )
 
 var (
@@ -27,7 +29,7 @@ var (
 )
 
 func TestTracerInit(t *testing.T) {
-	_, err := NewTracer("", WithReporter(&mockRegisterReporter{
+	_, err := NewTracer("service", WithReporter(&mockRegisterReporter{
 		success: true,
 	}))
 	if err != nil {
@@ -39,7 +41,7 @@ func TestTracer_CreateLocalSpan(t *testing.T) {
 	reporter := &mockRegisterReporter{
 		success: true,
 	}
-	tracer, _ := NewTracer("", WithReporter(reporter))
+	tracer, _ := NewTracer("service", WithReporter(reporter))
 	tracer.WaitUntilRegister()
 	span, ctx, err := tracer.CreateLocalSpan(context.Background())
 	if err != nil {
@@ -59,7 +61,7 @@ func TestTracer_CreateLocalSpanAsync(t *testing.T) {
 	reporter := &mockRegisterReporter{
 		success: true,
 	}
-	tracer, _ := NewTracer("", WithReporter(reporter))
+	tracer, _ := NewTracer("service", WithReporter(reporter))
 	tracer.WaitUntilRegister()
 	span, ctx, err := tracer.CreateLocalSpan(context.Background())
 	if err != nil {
@@ -127,3 +129,232 @@ func (r *mockRegisterReporter) Register(service string, instance string) (int32,
 func (r *mockRegisterReporter) wait() {
 	r.wg.Wait()
 }
+
+func TestNewTracer(t *testing.T) {
+	type args struct {
+		service string
+		opts    []TracerOption
+	}
+	tests := []struct {
+		name       string
+		args       args
+		wantTracer *Tracer
+		wantErr    bool
+	}{
+		{
+			"null service name",
+			struct {
+				service string
+				opts    []TracerOption
+			}{service: "", opts: nil},
+			nil,
+			true,
+		},
+		{
+			"without reporter",
+			struct {
+				service string
+				opts    []TracerOption
+			}{service: "test", opts: nil},
+			&Tracer{service: "test"},
+			false,
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			gotTracer, err := NewTracer(tt.args.service, tt.args.opts...)
+			if (err != nil) != tt.wantErr {
+				t.Errorf("NewTracer() error = %v, wantErr %v", err, tt.wantErr)
+				return
+			}
+			if !reflect.DeepEqual(gotTracer, tt.wantTracer) {
+				t.Errorf("NewTracer() = %v, want %v", gotTracer, tt.wantTracer)
+			}
+		})
+	}
+}
+
+func TestTracer_CreateEntrySpan_Parameter(t *testing.T) {
+	type args struct {
+		ctx           context.Context
+		operationName string
+		extractor     propagation.Extractor
+	}
+	tests := []struct {
+		name    string
+		args    args
+		wantErr bool
+	}{
+		{
+			"context is nil",
+			struct {
+				ctx           context.Context
+				operationName string
+				extractor     propagation.Extractor
+			}{ctx: nil, operationName: "query type", extractor: func() (s string, e error) {
+				return "", nil
+			}},
+			true,
+		},
+		{
+			"operationName is nil",
+			struct {
+				ctx           context.Context
+				operationName string
+				extractor     propagation.Extractor
+			}{ctx: context.Background(), operationName: "", extractor: func() (s string, e error) {
+				return "", nil
+			}},
+			true,
+		},
+		{
+			"extractor is nil",
+			struct {
+				ctx           context.Context
+				operationName string
+				extractor     propagation.Extractor
+			}{ctx: context.Background(), operationName: "query type", extractor: nil},
+			true,
+		},
+		{
+			"normal",
+			struct {
+				ctx           context.Context
+				operationName string
+				extractor     propagation.Extractor
+			}{ctx: context.Background(), operationName: "query type", extractor: func() (s string, e error) {
+				return "", nil
+			}},
+			false,
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			tracer := &Tracer{}
+			_, _, err := tracer.CreateEntrySpan(tt.args.ctx, tt.args.operationName, tt.args.extractor)
+			if (err != nil) != tt.wantErr {
+				t.Errorf("Tracer.CreateEntrySpan() error = %v, wantErr %v", err, tt.wantErr)
+				return
+			}
+		})
+	}
+}
+
+func TestTracer_CreateLocalSpan_Parameter(t *testing.T) {
+	type args struct {
+		ctx context.Context
+	}
+	tests := []struct {
+		name    string
+		args    args
+		wantErr bool
+	}{
+		{
+			"context is nil",
+			struct {
+				ctx context.Context
+			}{ctx: nil},
+			true,
+		},
+		{
+			"normal",
+			struct {
+				ctx context.Context
+			}{ctx: context.Background()},
+			false,
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			tracer := &Tracer{}
+			_, _, err := tracer.CreateLocalSpan(tt.args.ctx)
+			if (err != nil) != tt.wantErr {
+				t.Errorf("Tracer.CreateLocalSpan() error = %v, wantErr %v", err, tt.wantErr)
+				return
+			}
+		})
+	}
+}
+
+func TestTracer_CreateExitSpan_Parameter(t *testing.T) {
+	type args struct {
+		ctx           context.Context
+		operationName string
+		peer          string
+		injector      propagation.Injector
+	}
+	tests := []struct {
+		name    string
+		args    args
+		wantErr bool
+	}{
+		{
+			"context is nil",
+			struct {
+				ctx           context.Context
+				operationName string
+				peer          string
+				injector      propagation.Injector
+			}{ctx: nil, operationName: "query type", peer: "localhost:8080", injector: func(header string) error {
+				return nil
+			}},
+			true,
+		},
+		{
+			"operationName is nil",
+			struct {
+				ctx           context.Context
+				operationName string
+				peer          string
+				injector      propagation.Injector
+			}{ctx: context.Background(), operationName: "", peer: "localhost:8080", injector: func(header string) error {
+				return nil
+			}},
+			true,
+		},
+		{
+			"peer is nil",
+			struct {
+				ctx           context.Context
+				operationName string
+				peer          string
+				injector      propagation.Injector
+			}{ctx: context.Background(), operationName: "query type", peer: "", injector: func(header string) error {
+				return nil
+			}},
+			true,
+		},
+		{
+			"injector is nil",
+			struct {
+				ctx           context.Context
+				operationName string
+				peer          string
+				injector      propagation.Injector
+			}{ctx: context.Background(), operationName: "", peer: "localhost:8080", injector: nil},
+			true,
+		},
+		{
+			"normal",
+			struct {
+				ctx           context.Context
+				operationName string
+				peer          string
+				injector      propagation.Injector
+			}{ctx: context.Background(), operationName: "query type", peer: "localhost:8080", injector: func(header string) error {
+				return nil
+			}},
+			false,
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			tracer := &Tracer{}
+			_, err := tracer.CreateExitSpan(tt.args.ctx, tt.args.operationName, tt.args.peer, tt.args.injector)
+			if (err != nil) != tt.wantErr {
+				t.Errorf("Tracer.CreateExitSpan() error = %v, wantErr %v", err, tt.wantErr)
+				return
+			}
+		})
+	}
+}