github.com/xmidt-org/webpa-common@v1.11.9/logging/logginghttp/setLogger_test.go (about)

     1  package logginghttp
     2  
     3  import (
     4  	"context"
     5  	"net/http/httptest"
     6  	"testing"
     7  
     8  	"github.com/gorilla/mux"
     9  	"github.com/stretchr/testify/assert"
    10  	"github.com/stretchr/testify/require"
    11  	"github.com/xmidt-org/webpa-common/logging"
    12  )
    13  
    14  func TestRequestMethodKey(t *testing.T) {
    15  	assert := assert.New(t)
    16  	assert.Equal(requestMethodKey, RequestMethodKey())
    17  }
    18  
    19  func TestRequestURIKey(t *testing.T) {
    20  	assert := assert.New(t)
    21  	assert.Equal(requestURIKey, RequestURIKey())
    22  }
    23  
    24  func TestRemoteAddrKey(t *testing.T) {
    25  	assert := assert.New(t)
    26  	assert.Equal(remoteAddrKey, RemoteAddrKey())
    27  }
    28  
    29  func TestRequestInfo(t *testing.T) {
    30  	var (
    31  		assert  = assert.New(t)
    32  		require = require.New(t)
    33  		request = httptest.NewRequest("GET", "/test/foo/bar", nil)
    34  	)
    35  
    36  	request.RemoteAddr = "127.0.0.1:1234"
    37  
    38  	kv := RequestInfo(nil, request)
    39  	require.NotNil(kv)
    40  	require.Len(kv, 6)
    41  	assert.Equal(requestMethodKey, kv[0])
    42  	assert.Equal("GET", kv[1])
    43  	assert.Equal(requestURIKey, kv[2])
    44  	assert.Equal("/test/foo/bar", kv[3])
    45  	assert.Equal(remoteAddrKey, kv[4])
    46  	assert.Equal("127.0.0.1:1234", kv[5])
    47  }
    48  
    49  func testHeaderMissing(t *testing.T) {
    50  	var (
    51  		assert  = assert.New(t)
    52  		require = require.New(t)
    53  		request = httptest.NewRequest("GET", "/", nil)
    54  	)
    55  
    56  	kv := Header("X-Test", "key")(nil, request)
    57  	require.NotNil(kv)
    58  	require.Len(kv, 2)
    59  	assert.Equal("key", kv[0])
    60  	assert.Equal("", kv[1])
    61  }
    62  
    63  func testHeaderSingleValue(t *testing.T) {
    64  	var (
    65  		assert  = assert.New(t)
    66  		require = require.New(t)
    67  		request = httptest.NewRequest("GET", "/", nil)
    68  	)
    69  
    70  	request.Header.Set("X-Test", "value")
    71  	kv := Header("X-Test", "key")(nil, request)
    72  	require.NotNil(kv)
    73  	require.Len(kv, 2)
    74  	assert.Equal("key", kv[0])
    75  	assert.Equal("value", kv[1])
    76  }
    77  
    78  func testHeaderMultiValue(t *testing.T) {
    79  	var (
    80  		assert  = assert.New(t)
    81  		require = require.New(t)
    82  		request = httptest.NewRequest("GET", "/", nil)
    83  	)
    84  
    85  	request.Header.Add("X-Test", "value1")
    86  	request.Header.Add("X-Test", "value2")
    87  	kv := Header("X-Test", "key")(nil, request)
    88  	require.NotNil(kv)
    89  	require.Len(kv, 2)
    90  	assert.Equal("key", kv[0])
    91  	assert.Equal([]string{"value1", "value2"}, kv[1])
    92  }
    93  
    94  func TestHeader(t *testing.T) {
    95  	t.Run("Missing", testHeaderMissing)
    96  	t.Run("SingleValue", testHeaderSingleValue)
    97  	t.Run("MultiValue", testHeaderMultiValue)
    98  }
    99  
   100  func testPathVariableMissing(t *testing.T) {
   101  	var (
   102  		assert  = assert.New(t)
   103  		require = require.New(t)
   104  		request = httptest.NewRequest("GET", "/", nil)
   105  	)
   106  
   107  	kv := PathVariable("test", "key")(nil, request)
   108  	require.NotNil(kv)
   109  	require.Len(kv, 2)
   110  	assert.Equal("key", kv[0])
   111  	assert.Equal("", kv[1])
   112  }
   113  
   114  func testPathVariableValue(t *testing.T) {
   115  	var (
   116  		assert    = assert.New(t)
   117  		require   = require.New(t)
   118  		variables = map[string]string{
   119  			"test": "foobar",
   120  		}
   121  
   122  		request = mux.SetURLVars(
   123  			httptest.NewRequest("GET", "/", nil),
   124  			variables,
   125  		)
   126  	)
   127  
   128  	kv := PathVariable("test", "key")(nil, request)
   129  	require.NotNil(kv)
   130  	require.Len(kv, 2)
   131  	assert.Equal("key", kv[0])
   132  	assert.Equal("foobar", kv[1])
   133  }
   134  
   135  func TestPathVariable(t *testing.T) {
   136  	t.Run("Missing", testPathVariableMissing)
   137  	t.Run("Value", testPathVariableValue)
   138  }
   139  
   140  func testSetLoggerNilBase(t *testing.T) {
   141  	assert := assert.New(t)
   142  	assert.Panics(func() {
   143  		SetLogger(nil)
   144  	})
   145  }
   146  
   147  func testSetLoggerBaseOnly(t *testing.T) {
   148  	var (
   149  		assert = assert.New(t)
   150  
   151  		base    = logging.NewTestLogger(nil, t)
   152  		request = httptest.NewRequest("GET", "/", nil)
   153  		ctx     = SetLogger(base)(context.Background(), request)
   154  	)
   155  
   156  	assert.Equal(base, logging.GetLogger(ctx))
   157  }
   158  
   159  func testSetLoggerCustom(t *testing.T) {
   160  	var (
   161  		assert  = assert.New(t)
   162  		require = require.New(t)
   163  
   164  		variables = map[string]string{
   165  			"test": "path variable value",
   166  		}
   167  
   168  		request = mux.SetURLVars(
   169  			httptest.NewRequest("GET", "/test/uri", nil),
   170  			variables,
   171  		)
   172  
   173  		base = logging.NewCaptureLogger()
   174  	)
   175  
   176  	request.RemoteAddr = "10.0.0.1:7777"
   177  	request.Header.Set("X-Test", "header value")
   178  
   179  	logger := logging.GetLogger(
   180  		SetLogger(
   181  			base,
   182  			RequestInfo, Header("X-Test", "key1"), PathVariable("test", "key2"),
   183  		)(context.Background(), request),
   184  	)
   185  
   186  	require.NotEqual(base, logger)
   187  	logger.Log(logging.MessageKey(), "test message")
   188  
   189  	entry := <-base.Output()
   190  	assert.Equal("GET", entry[requestMethodKey])
   191  	assert.Equal("/test/uri", entry[requestURIKey])
   192  	assert.Equal("10.0.0.1:7777", entry[remoteAddrKey])
   193  	assert.Equal("header value", entry["key1"])
   194  	assert.Equal("path variable value", entry["key2"])
   195  	assert.Equal("test message", entry[logging.MessageKey()])
   196  }
   197  
   198  func TestSetLogger(t *testing.T) {
   199  	t.Run("NilBase", testSetLoggerNilBase)
   200  	t.Run("BaseOnly", testSetLoggerBaseOnly)
   201  	t.Run("Custom", testSetLoggerCustom)
   202  }