github.com/craicoverflow/tyk@v2.9.6-rc3+incompatible/config/opentracing_custom_env_loader_test.go (about)

     1  package config
     2  
     3  import (
     4  	"fmt"
     5  	"os"
     6  	"reflect"
     7  	"testing"
     8  
     9  	jaeger "github.com/uber/jaeger-client-go/config"
    10  )
    11  
    12  func TestLoadZipkin(t *testing.T) {
    13  	base := ZipkinConfig{
    14  		Reporter: Reporter{
    15  			URL:        "repoturl",
    16  			BatchSize:  10,
    17  			MaxBacklog: 20,
    18  		},
    19  		Sampler: Sampler{
    20  			Name: "boundary",
    21  			Rate: 10.1,
    22  			Salt: 10,
    23  			Mod:  12,
    24  		},
    25  	}
    26  	sample := []struct {
    27  		env   string
    28  		value string
    29  	}{
    30  		{"TYK_GW_TRACER_OPTIONS_REPORTER_URL", base.Reporter.URL},
    31  		{"TYK_GW_TRACER_OPTIONS_REPORTER_BATCHSIZE", fmt.Sprint(base.Reporter.BatchSize)},
    32  		{"TYK_GW_TRACER_OPTIONS_REPORTER_MAXBACKLOG", fmt.Sprint(base.Reporter.MaxBacklog)},
    33  		{"TYK_GW_TRACER_OPTIONS_SAMPLER_NAME", base.Sampler.Name},
    34  		{"TYK_GW_TRACER_OPTIONS_SAMPLER_SALT", fmt.Sprint(base.Sampler.Salt)},
    35  		{"TYK_GW_TRACER_OPTIONS_SAMPLER_MOD", fmt.Sprint(base.Sampler.Mod)},
    36  	}
    37  	for _, v := range sample {
    38  		err := os.Setenv(v.env, v.value)
    39  		if err != nil {
    40  			t.Fatal(err)
    41  		}
    42  	}
    43  	defer func() {
    44  		for _, v := range sample {
    45  			os.Unsetenv(v.env)
    46  		}
    47  	}()
    48  	t.Run("Returns nil when it is not zipkin config", func(t *testing.T) {
    49  		conf := &Config{}
    50  		err := loadZipkin(envPrefix, conf)
    51  		if err != nil {
    52  			t.Fatal(err)
    53  		}
    54  		if conf.Tracer.Options != nil {
    55  			t.Error("expected options to be nil")
    56  		}
    57  	})
    58  	t.Run("handles nil options", func(t *testing.T) {
    59  		conf := &Config{Tracer: Tracer{Name: "zipkin"}}
    60  		err := loadZipkin(envPrefix, conf)
    61  		if err != nil {
    62  			t.Fatal(err)
    63  		}
    64  		if conf.Tracer.Options != nil {
    65  			t.Error("expected options to be nil")
    66  		}
    67  	})
    68  
    69  	t.Run("loads env vars", func(t *testing.T) {
    70  		o := make(map[string]interface{})
    71  		err := DecodeJSON(&o, base)
    72  		if err != nil {
    73  			t.Fatal(err)
    74  		}
    75  		conf := &Config{Tracer: Tracer{Name: "zipkin", Options: o}}
    76  		err = loadZipkin(envPrefix, conf)
    77  		if err != nil {
    78  			t.Fatal(err)
    79  		}
    80  		var got ZipkinConfig
    81  		err = DecodeJSON(&got, conf.Tracer.Options)
    82  		if err != nil {
    83  			t.Fatal(err)
    84  		}
    85  		if !reflect.DeepEqual(base, got) {
    86  			t.Errorf("expected %#v got %#v", base, got)
    87  		}
    88  	})
    89  }
    90  func TestLoadJaeger(t *testing.T) {
    91  	base := &jaeger.Configuration{ServiceName: "jaeger-test-service"}
    92  	sample := []struct {
    93  		env   string
    94  		value string
    95  	}{
    96  		{"TYK_GW_TRACER_OPTIONS_SERVICENAME", base.ServiceName},
    97  	}
    98  	for _, v := range sample {
    99  		err := os.Setenv(v.env, v.value)
   100  		if err != nil {
   101  			t.Fatal(err)
   102  		}
   103  	}
   104  	defer func() {
   105  		for _, v := range sample {
   106  			os.Unsetenv(v.env)
   107  		}
   108  	}()
   109  	t.Run("Returns nil when it is not jaeger config", func(t *testing.T) {
   110  		conf := &Config{}
   111  		err := loadJaeger(envPrefix, conf)
   112  		if err != nil {
   113  			t.Fatal(err)
   114  		}
   115  		if conf.Tracer.Options != nil {
   116  			t.Error("expected options to be nil")
   117  		}
   118  	})
   119  	t.Run("Handles nil options", func(t *testing.T) {
   120  		conf := &Config{Tracer: Tracer{Name: "jaeger"}}
   121  		err := loadJaeger(envPrefix, conf)
   122  		if err != nil {
   123  			t.Fatal(err)
   124  		}
   125  		if conf.Tracer.Options != nil {
   126  			t.Error("expected options to be nil")
   127  		}
   128  	})
   129  
   130  	t.Run("Loads env vars", func(t *testing.T) {
   131  		o := make(map[string]interface{})
   132  		err := DecodeJSON(&o, base)
   133  		if err != nil {
   134  			t.Fatal(err)
   135  		}
   136  		conf := &Config{Tracer: Tracer{Name: "jaeger", Options: o}}
   137  		err = loadJaeger(envPrefix, conf)
   138  		if err != nil {
   139  			t.Fatal(err)
   140  		}
   141  		var got jaeger.Configuration
   142  		err = DecodeJSON(&got, conf.Tracer.Options)
   143  		if err != nil {
   144  			t.Fatal(err)
   145  		}
   146  		if base.ServiceName != got.ServiceName {
   147  			t.Errorf("expected %#v got %#v", base.ServiceName, got.ServiceName)
   148  		}
   149  	})
   150  }