github.com/Tyktechnologies/tyk@v2.9.5+incompatible/gateway/log_helpers_test.go (about)

     1  package gateway
     2  
     3  import (
     4  	"net/http/httptest"
     5  	"testing"
     6  
     7  	"github.com/sirupsen/logrus"
     8  
     9  	"github.com/TykTechnologies/tyk/config"
    10  )
    11  
    12  func TestGetLogEntryForRequest(t *testing.T) {
    13  	defer ResetTestConfig()
    14  
    15  	testReq := httptest.NewRequest("GET", "http://tyk.io/test", nil)
    16  	testReq.RemoteAddr = "127.0.0.1:80"
    17  	testData := []struct {
    18  		EnableKeyLogging bool
    19  		Key              string
    20  		Data             map[string]interface{}
    21  		Result           *logrus.Entry
    22  	}{
    23  		// enable_key_logging is set, key passed, no additional data fields
    24  		{
    25  			EnableKeyLogging: true,
    26  			Key:              "abc",
    27  			Data:             nil,
    28  			Result: logrus.WithFields(logrus.Fields{
    29  				"path":   "/test",
    30  				"origin": "127.0.0.1",
    31  				"key":    "abc",
    32  			}),
    33  		},
    34  		// enable_key_logging is set, key is not passed, no additional data fields
    35  		{
    36  			EnableKeyLogging: true,
    37  			Key:              "",
    38  			Data:             nil,
    39  			Result: logrus.WithFields(logrus.Fields{
    40  				"path":   "/test",
    41  				"origin": "127.0.0.1",
    42  			}),
    43  		},
    44  		// enable_key_logging is set, key passed, additional data fields are passed
    45  		{
    46  			EnableKeyLogging: true,
    47  			Key:              "abc",
    48  			Data:             map[string]interface{}{"a": 1, "b": "test"},
    49  			Result: logrus.WithFields(logrus.Fields{
    50  				"path":   "/test",
    51  				"origin": "127.0.0.1",
    52  				"key":    "abc",
    53  				"a":      1,
    54  				"b":      "test",
    55  			}),
    56  		},
    57  		// enable_key_logging is set, key is not passed, additional data fields are passed
    58  		{
    59  			EnableKeyLogging: true,
    60  			Key:              "",
    61  			Data:             map[string]interface{}{"a": 1, "b": "test"},
    62  			Result: logrus.WithFields(logrus.Fields{
    63  				"path":   "/test",
    64  				"origin": "127.0.0.1",
    65  				"a":      1,
    66  				"b":      "test",
    67  			}),
    68  		},
    69  		// enable_key_logging is not set, key passed, no additional data field
    70  		{
    71  			EnableKeyLogging: false,
    72  			Key:              "abc",
    73  			Data:             nil,
    74  			Result: logrus.WithFields(logrus.Fields{
    75  				"path":   "/test",
    76  				"origin": "127.0.0.1",
    77  				"key":    obfuscateKey("abs"),
    78  			}),
    79  		},
    80  		// enable_key_logging is not set, key is not passed, no additional data field
    81  		{
    82  			EnableKeyLogging: false,
    83  			Key:              "",
    84  			Data:             nil,
    85  			Result: logrus.WithFields(logrus.Fields{
    86  				"path":   "/test",
    87  				"origin": "127.0.0.1",
    88  			}),
    89  		},
    90  		// enable_key_logging is not set, key passed, additional data fields are passed
    91  		{
    92  			EnableKeyLogging: false,
    93  			Key:              "abc",
    94  			Data:             map[string]interface{}{"a": 1, "b": "test"},
    95  			Result: logrus.WithFields(logrus.Fields{
    96  				"path":   "/test",
    97  				"origin": "127.0.0.1",
    98  				"a":      1,
    99  				"b":      "test",
   100  				"key":    obfuscateKey("abc"),
   101  			}),
   102  		},
   103  		// enable_key_logging is not set, key is not passed, additional data fields are passed
   104  		{
   105  			EnableKeyLogging: false,
   106  			Key:              "",
   107  			Data:             map[string]interface{}{"a": 1, "b": "test"},
   108  			Result: logrus.WithFields(logrus.Fields{
   109  				"path":   "/test",
   110  				"origin": "127.0.0.1",
   111  				"a":      1,
   112  				"b":      "test",
   113  			}),
   114  		},
   115  	}
   116  	globalConf := config.Global()
   117  	for _, test := range testData {
   118  		globalConf.EnableKeyLogging = test.EnableKeyLogging
   119  		config.SetGlobal(globalConf)
   120  		logEntry := getLogEntryForRequest(nil, testReq, test.Key, test.Data)
   121  		if logEntry.Data["path"] != test.Result.Data["path"] {
   122  			t.Error("Expected 'path':", test.Result.Data["path"], "Got:", logEntry.Data["path"])
   123  		}
   124  		if logEntry.Data["origin"] != test.Result.Data["origin"] {
   125  			t.Error("Expected 'origin':", test.Result.Data["origin"], "Got:", logEntry.Data["origin"])
   126  		}
   127  		if logEntry.Data["key"] != test.Result.Data["key"] {
   128  			t.Error("Expected 'key':", test.Result.Data["key"], "Got:", logEntry.Data["key"])
   129  		}
   130  		if test.Data != nil {
   131  			for key, val := range test.Data {
   132  				if logEntry.Data[key] != val {
   133  					t.Error("Expected data key:", key, "with value:", val, "Got:", logEntry.Data[key])
   134  				}
   135  			}
   136  		}
   137  	}
   138  }