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  * This source code is part of the near-RT RIC (RAN Intelligent Controller)
  18  * platform project (RICP).
  19  */
  20
  21 package golog
  22
  23 import (
  24         "bytes"
  25         "encoding/json"
  26         "io/ioutil"
  27         "os"
  28         "testing"
  29
  30         "github.com/stretchr/testify/assert"
  31 )
  32
  33 // getTestLogger returns a logger instance where
  34 // the output is directed to a byte buffer instead
  35 // of stdout
  36 func getTestLogger(t *testing.T) (*MdcLogger, *bytes.Buffer) {
  37         logbuffer := new(bytes.Buffer)
  38         logger, err := initLogger("foo", logbuffer)
  39         assert.Nil(t, err)
  40         return logger, logbuffer
  41 }
  42
  43 func TestLogInitDoesNotReturnAnError(t *testing.T) {
  44         _, err := InitLogger("foo")
  45         assert.Nil(t, err, "create failed")
  46 }
  47
  48 func TestDebugFunctionLogsCorrectString(t *testing.T) {
  49         logger, logbuffer := getTestLogger(t)
  50         logger.Debug("test debug")
  51         logstr := logbuffer.String()
  52         assert.Contains(t, logstr, "crit\":\"DEBUG\",\"id\":\"foo\",\"mdc\":{},\"msg\":\"test debug\"}\n")
  53 }
  54
  55 func TestInfoFunctionLogsCorrectString(t *testing.T) {
  56         logger, logbuffer := getTestLogger(t)
  57         logger.Info("test info")
  58         logstr := logbuffer.String()
  59         assert.Contains(t, logstr, "crit\":\"INFO\",\"id\":\"foo\",\"mdc\":{},\"msg\":\"test info\"}\n")
  60 }
  61
  62 func TestWarningLogsCorrectString(t *testing.T) {
  63         logger, logbuffer := getTestLogger(t)
  64         logger.Warning("test warn")
  65         logstr := logbuffer.String()
  66         assert.Contains(t, logstr, "crit\":\"WARNING\",\"id\":\"foo\",\"mdc\":{},\"msg\":\"test warn\"}\n")
  67 }
  68
  69 func TestErrorFunctionLogsCorrectString(t *testing.T) {
  70         logger, logbuffer := getTestLogger(t)
  71         logger.Error("test err")
  72         logstr := logbuffer.String()
  73         assert.Contains(t, logstr, "crit\":\"ERROR\",\"id\":\"foo\",\"mdc\":{},\"msg\":\"test err\"}\n")
  74 }
  75
  76 func TestLogFunctionLogsCorrectString(t *testing.T) {
  77         logger, logbuffer := getTestLogger(t)
  78         logger.Log(ERR, "test err")
  79         logstr := logbuffer.String()
  80         assert.Contains(t, logstr, "crit\":\"ERROR\",\"id\":\"foo\",\"mdc\":{},\"msg\":\"test err\"}\n")
  81 }
  82
  83 func TestFormatWithMdcReturnsJsonFormatedString(t *testing.T) {
  84         logger, _ := InitLogger("foo")
  85         logger.MdcAdd("foo", "bar")
  86         logstr, err := logger.formatLog(INFO, "test2")
  87         assert.Nil(t, err, "formatLog fails")
  88         v := make(map[string]interface{})
  89         err = json.Unmarshal(logstr, &v)
  90         assert.Equal(t, "INFO", v["crit"])
  91         assert.Equal(t, "test2", v["msg"])
  92         assert.Equal(t, "foo", v["id"])
  93         expectedmdc := map[string]interface{}{"foo": "bar"}
  94         assert.Equal(t, expectedmdc, v["mdc"])
  95 }
  96
  97 func TestMdcAddIsOk(t *testing.T) {
  98         logger, _ := InitLogger("foo")
  99         logger.MdcAdd("foo", "bar")
 100         val, ok := logger.MdcGet("foo")
 101         assert.True(t, ok)
 102         assert.Equal(t, "bar", val)
 103 }
 104
 105 func TestMdcRemoveWorks(t *testing.T) {
 106         logger, _ := InitLogger("foo")
 107         logger.MdcAdd("foo", "bar")
 108         val, ok := logger.MdcGet("foo")
 109         assert.True(t, ok)
 110         assert.Equal(t, "bar", val)
 111         logger.MdcRemove("foo")
 112         val, ok = logger.MdcGet("foo")
 113         assert.False(t, ok)
 114         assert.Empty(t, val)
 115 }
 116
 117 func TestRemoveNonExistentMdcDoesNotCrash(t *testing.T) {
 118         logger, _ := InitLogger("foo")
 119         logger.MdcRemove("foo")
 120 }
 121
 122 func TestMdcCleanRemovesAllMdcs(t *testing.T) {
 123         logger, _ := InitLogger("foo")
 124         logger.MdcAdd("foo1", "bar")
 125         logger.MdcAdd("foo2", "bar")
 126         logger.MdcAdd("foo3", "bar")
 127         logger.MdcClean()
 128         _, ok := logger.MdcGet("foo1")
 129         assert.False(t, ok)
 130         _, ok = logger.MdcGet("foo2")
 131         assert.False(t, ok)
 132         _, ok = logger.MdcGet("foo3")
 133         assert.False(t, ok)
 134 }
 135
 136 func TestLevelStringsGetterWorks(t *testing.T) {
 137         assert.Equal(t, "ERROR", levelString(ERR))
 138         assert.Equal(t, "WARNING", levelString(WARN))
 139         assert.Equal(t, "INFO", levelString(INFO))
 140         assert.Equal(t, "DEBUG", levelString(DEBUG))
 141 }
 142
 143 func TestDefaultLoggingLevelIsDebug(t *testing.T) {
 144         logger, _ := InitLogger("foo")
 145         assert.Equal(t, DEBUG, logger.LevelGet())
 146 }
 147
 148 func TestLevelGetReturnsWhatWasSet(t *testing.T) {
 149         logger, _ := InitLogger("foo")
 150         logger.LevelSet(ERR)
 151         assert.Equal(t, ERR, logger.LevelGet())
 152 }
 153
 154 func TestDebugLogIsNotWrittenIfCurrentLevelIsInfo(t *testing.T) {
 155         logger, logbuffer := getTestLogger(t)
 156         logger.LevelSet(INFO)
 157         logger.Debug("fooo")
 158         assert.Empty(t, logbuffer.String())
 159 }
 160
 161 func TestLogFormatWithMdcArray(t *testing.T) {
 162         logger, _ := InitLogger("app")
 163         logFileMonitor := 0
 164         logger.Mdclog_format_initialize(logFileMonitor)
 165         logstr, err := logger.formatLog(INFO, "test")
 166         assert.Nil(t, err, "formatLog fails")
 167         v := make(map[string]interface{})
 168         err = json.Unmarshal(logstr, &v)
 169         assert.Equal(t, "INFO", v["crit"])
 170         assert.Equal(t, "test", v["msg"])
 171         assert.Equal(t, "app", v["id"])
 172         _, ok := logger.MdcGet("SYSTEM_NAME")
 173         assert.True(t, ok)
 174         _, ok = logger.MdcGet("HOST_NAME")
 175         assert.True(t, ok)
 176         _, ok = logger.MdcGet("SERVICE_NAME")
 177         assert.True(t, ok)
 178         _, ok = logger.MdcGet("CONTAINER_NAME")
 179         assert.True(t, ok)
 180         _, ok = logger.MdcGet("POD_NAME")
 181         assert.True(t, ok)
 182 }
 183
 184 func TestLogLevelConfigFileParse(t *testing.T) {
 185         logger, _ := InitLogger("app")
 186         d1 := []byte("log-level:WARN\n\n")
 187         err := ioutil.WriteFile("/tmp/log-file", d1, 0644)
 188         assert.Nil(t, err, "Failed to create tmp log-file")
 189         os.Setenv("CONFIG_MAP_NAME", "/tmp/log-file")
 190         logFileMonitor := 1
 191         logger.Mdclog_format_initialize(logFileMonitor)
 192         assert.Equal(t, WARN, logger.LevelGet())
 193         _, ok := logger.MdcGet("PID")
 194         assert.True(t, ok)
 195         logger.Mdclog_format_initialize(logFileMonitor)
 196 }