github.com/akamai/AkamaiOPEN-edgegrid-golang/v8@v8.1.0/pkg/session/session_test.go (about)

     1  package session
     2  
     3  import (
     4  	"context"
     5  	"net/http"
     6  	"runtime"
     7  	"strings"
     8  	"testing"
     9  
    10  	"github.com/akamai/AkamaiOPEN-edgegrid-golang/v8/pkg/edgegrid"
    11  	"github.com/apex/log"
    12  	"github.com/apex/log/handlers/discard"
    13  	"github.com/stretchr/testify/require"
    14  	"github.com/tj/assert"
    15  )
    16  
    17  func TestNew(t *testing.T) {
    18  	tests := map[string]struct {
    19  		client      *http.Client
    20  		log         log.Interface
    21  		userAgent   string
    22  		httpTracing bool
    23  		expected    *session
    24  	}{
    25  		"no options provided, return default session": {
    26  			expected: &session{
    27  				client:    http.DefaultClient,
    28  				signer:    &edgegrid.Config{},
    29  				log:       log.Log,
    30  				trace:     false,
    31  				userAgent: "Akamai-Open-Edgegrid-golang/8.0.0 golang/" + strings.TrimPrefix(runtime.Version(), "go"),
    32  			},
    33  		},
    34  		"with options provided": {
    35  			client: &http.Client{
    36  				Timeout: 500,
    37  			},
    38  			log:         log.Log,
    39  			userAgent:   "test user agent",
    40  			httpTracing: true,
    41  			expected: &session{
    42  				client: &http.Client{
    43  					Timeout: 500,
    44  				},
    45  				signer:    &edgegrid.Config{},
    46  				log:       log.Log,
    47  				trace:     true,
    48  				userAgent: "test user agent",
    49  			},
    50  		},
    51  	}
    52  
    53  	for name, test := range tests {
    54  		t.Run(name, func(t *testing.T) {
    55  			cfg := &edgegrid.Config{}
    56  			options := []Option{WithSigner(cfg)}
    57  			if test.client != nil {
    58  				options = append(options, WithClient(test.client))
    59  			}
    60  			if test.log != nil {
    61  				options = append(options, WithLog(test.log))
    62  			}
    63  			if test.userAgent != "" {
    64  				options = append(options, WithUserAgent(test.userAgent))
    65  			}
    66  			if test.httpTracing {
    67  				options = append(options, WithHTTPTracing(test.httpTracing))
    68  			}
    69  			res, err := New(options...)
    70  			require.NoError(t, err)
    71  			assert.Equal(t, test.expected, res)
    72  		})
    73  	}
    74  }
    75  
    76  func TestSession_Log(t *testing.T) {
    77  	tests := map[string]struct {
    78  		ctx           context.Context
    79  		sessionLogger log.Interface
    80  		expected      *log.Logger
    81  	}{
    82  		"logger found in context, omit logger from session": {
    83  			ctx: ContextWithOptions(context.Background(), WithContextLog(&log.Logger{
    84  				Handler: discard.New(),
    85  				Level:   1,
    86  			})),
    87  			sessionLogger: &log.Logger{
    88  				Handler: discard.New(),
    89  				Level:   2,
    90  			},
    91  			expected: &log.Logger{
    92  				Handler: discard.New(),
    93  				Level:   1,
    94  			},
    95  		},
    96  		"logger not found in context, pick logger from session": {
    97  			ctx: context.Background(),
    98  			sessionLogger: &log.Logger{
    99  				Handler: discard.New(),
   100  				Level:   2,
   101  			},
   102  			expected: &log.Logger{
   103  				Handler: discard.New(),
   104  				Level:   2,
   105  			},
   106  		},
   107  		"logger not found in context or session": {
   108  			ctx:           context.Background(),
   109  			sessionLogger: nil,
   110  			expected: &log.Logger{
   111  				Handler: discard.New(),
   112  			},
   113  		},
   114  	}
   115  
   116  	for name, test := range tests {
   117  		t.Run(name, func(t *testing.T) {
   118  			s := session{log: test.sessionLogger}
   119  			res := s.Log(test.ctx)
   120  			assert.Equal(t, test.expected, res)
   121  		})
   122  	}
   123  }