mdclog_test.go

   1 /*
   2  *  Copyright (c) 2019 AT&T Intellectual Property.
   3  *  Copyright (c) 2018-2019 Nokia.
   4  *
   5  *  Licensed under the Apache License, Version 2.0 (the "License");
   6  *  you may not use this file except in compliance with the License.
   7  *  You may obtain a copy of the License at
   8  *
   9  *     http://www.apache.org/licenses/LICENSE-2.0
  10  *
  11  *  Unless required by applicable law or agreed to in writing, software
  12  *  distributed under the License is distributed on an "AS IS" BASIS,
  13  *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14  *  See the License for the specific language governing permissions and
  15  *  limitations under the License.
  16  */
  17
  18 package golog
  19
  20 import (
  21         "bytes"
  22         "encoding/json"
  23         "testing"
  24
  25         "github.com/stretchr/testify/assert"
  26 )
  27
  28 // getTestLogger returns a logger instance where
  29 // the output is directed to a byte buffer instead
  30 // of stdout
  31 func getTestLogger(t *testing.T) (*MdcLogger, *bytes.Buffer) {
  32         logbuffer := new(bytes.Buffer)
  33         logger, err := initLogger("foo", logbuffer)
  34         assert.Nil(t, err)
  35         return logger, logbuffer
  36 }
  37
  38 func TestLogInitDoesNotReturnAnError(t *testing.T) {
  39         _, err := InitLogger("foo")
  40         assert.Nil(t, err, "create failed")
  41 }
  42
  43 func TestDebugFunctionLogsCorrectString(t *testing.T) {
  44         logger, logbuffer := getTestLogger(t)
  45         logger.Debug("test debug")
  46         logstr := logbuffer.String()
  47         assert.Contains(t, logstr, "crit\":\"DEBUG\",\"id\":\"foo\",\"mdc\":{},\"msg\":\"test debug\"}\n")
  48 }
  49
  50 func TestInfoFunctionLogsCorrectString(t *testing.T) {
  51         logger, logbuffer := getTestLogger(t)
  52         logger.Info("test info")
  53         logstr := logbuffer.String()
  54         assert.Contains(t, logstr, "crit\":\"INFO\",\"id\":\"foo\",\"mdc\":{},\"msg\":\"test info\"}\n")
  55 }
  56
  57 func TestWarningLogsCorrectString(t *testing.T) {
  58         logger, logbuffer := getTestLogger(t)
  59         logger.Warning("test warn")
  60         logstr := logbuffer.String()
  61         assert.Contains(t, logstr, "crit\":\"WARNING\",\"id\":\"foo\",\"mdc\":{},\"msg\":\"test warn\"}\n")
  62 }
  63
  64 func TestErrorFunctionLogsCorrectString(t *testing.T) {
  65         logger, logbuffer := getTestLogger(t)
  66         logger.Error("test err")
  67         logstr := logbuffer.String()
  68         assert.Contains(t, logstr, "crit\":\"ERROR\",\"id\":\"foo\",\"mdc\":{},\"msg\":\"test err\"}\n")
  69 }
  70
  71 func TestLogFunctionLogsCorrectString(t *testing.T) {
  72         logger, logbuffer := getTestLogger(t)
  73         logger.Log(ERR, "test err")
  74         logstr := logbuffer.String()
  75         assert.Contains(t, logstr, "crit\":\"ERROR\",\"id\":\"foo\",\"mdc\":{},\"msg\":\"test err\"}\n")
  76 }
  77
  78 func TestFormatWithMdcReturnsJsonFormatedString(t *testing.T) {
  79         logger, _ := InitLogger("foo")
  80         logger.MdcAdd("foo", "bar")
  81         logstr, err := logger.formatLog(INFO, "test2")
  82         assert.Nil(t, err, "formatLog fails")
  83         v := make(map[string]interface{})
  84         err = json.Unmarshal(logstr, &v)
  85         assert.Equal(t, "INFO", v["crit"])
  86         assert.Equal(t, "test2", v["msg"])
  87         assert.Equal(t, "foo", v["id"])
  88         expectedmdc := map[string]interface{}{"foo": "bar"}
  89         assert.Equal(t, expectedmdc, v["mdc"])
  90 }
  91
  92 func TestMdcAddIsOk(t *testing.T) {
  93         logger, _ := InitLogger("foo")
  94         logger.MdcAdd("foo", "bar")
  95         val, ok := logger.MdcGet("foo")
  96         assert.True(t, ok)
  97         assert.Equal(t, "bar", val)
  98 }
  99
 100 func TestMdcRemoveWorks(t *testing.T) {
 101         logger, _ := InitLogger("foo")
 102         logger.MdcAdd("foo", "bar")
 103         val, ok := logger.MdcGet("foo")
 104         assert.True(t, ok)
 105         assert.Equal(t, "bar", val)
 106         logger.MdcRemove("foo")
 107         val, ok = logger.MdcGet("foo")
 108         assert.False(t, ok)
 109         assert.Empty(t, val)
 110 }
 111
 112 func TestRemoveNonExistentMdcDoesNotCrash(t *testing.T) {
 113         logger, _ := InitLogger("foo")
 114         logger.MdcRemove("foo")
 115 }
 116
 117 func TestMdcCleanRemovesAllMdcs(t *testing.T) {
 118         logger, _ := InitLogger("foo")
 119         logger.MdcAdd("foo1", "bar")
 120         logger.MdcAdd("foo2", "bar")
 121         logger.MdcAdd("foo3", "bar")
 122         logger.MdcClean()
 123         _, ok := logger.MdcGet("foo1")
 124         assert.False(t, ok)
 125         _, ok = logger.MdcGet("foo2")
 126         assert.False(t, ok)
 127         _, ok = logger.MdcGet("foo3")
 128         assert.False(t, ok)
 129 }
 130
 131 func TestLevelStringsGetterWorks(t *testing.T) {
 132         assert.Equal(t, "ERROR", levelString(ERR))
 133         assert.Equal(t, "WARNING", levelString(WARN))
 134         assert.Equal(t, "INFO", levelString(INFO))
 135         assert.Equal(t, "DEBUG", levelString(DEBUG))
 136 }
 137
 138 func TestDefaultLoggingLevelIsDebug(t *testing.T) {
 139         logger, _ := InitLogger("foo")
 140         assert.Equal(t, DEBUG, logger.LevelGet())
 141 }
 142
 143 func TestLevelGetReturnsWhatWasSet(t *testing.T) {
 144         logger, _ := InitLogger("foo")
 145         logger.LevelSet(ERR)
 146         assert.Equal(t, ERR, logger.LevelGet())
 147 }
 148
 149 func TestDebugLogIsNotWrittenIfCurrentLevelIsInfo(t *testing.T) {
 150         logger, logbuffer := getTestLogger(t)
 151         logger.LevelSet(INFO)
 152         logger.Debug("fooo")
 153         assert.Empty(t, logbuffer.String())
 154 }