RSM/logger/logger_test.go

   1 //
   2 // Copyright 2019 AT&T Intellectual Property
   3 // Copyright 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 logger
  19
  20 import (
  21         "bytes"
  22         "github.com/stretchr/testify/assert"
  23         "go.uber.org/zap"
  24         "go.uber.org/zap/zapcore"
  25         "io"
  26         "os"
  27         "testing"
  28 )
  29
  30 func TestInitDebugLoggerSuccess(t *testing.T) {
  31         log, err := InitLogger(DebugLevel)
  32         assert.Nil(t, err)
  33         assert.NotNil(t, log)
  34         assert.True(t, log.Logger.Core().Enabled(zap.DebugLevel))
  35 }
  36
  37 func TestInitInfoLoggerSuccess(t *testing.T) {
  38         log, err := InitLogger(InfoLevel)
  39         assert.Nil(t, err)
  40         assert.NotNil(t, log)
  41         assert.True(t, log.Logger.Core().Enabled(zap.InfoLevel))
  42 }
  43
  44 func TestInitWarnLoggerSuccess(t *testing.T) {
  45         log, err := InitLogger(WarnLevel)
  46         assert.Nil(t, err)
  47         assert.NotNil(t, log)
  48         assert.True(t, log.Logger.Core().Enabled(zap.WarnLevel))
  49 }
  50
  51 func TestInitErrorLoggerSuccess(t *testing.T) {
  52         log, err := InitLogger(ErrorLevel)
  53         assert.Nil(t, err)
  54         assert.NotNil(t, log)
  55         assert.True(t, log.Logger.Core().Enabled(zap.ErrorLevel))
  56 }
  57
  58 func TestInitDPanicLoggerSuccess(t *testing.T) {
  59         log, err := InitLogger(DPanicLevel)
  60         assert.Nil(t, err)
  61         assert.NotNil(t, log)
  62         assert.True(t, log.Logger.Core().Enabled(zap.DPanicLevel))
  63 }
  64
  65 func TestInitPanicLoggerSuccess(t *testing.T) {
  66         log, err := InitLogger(PanicLevel)
  67         assert.Nil(t, err)
  68         assert.NotNil(t, log)
  69         assert.True(t, log.Logger.Core().Enabled(zap.PanicLevel))
  70 }
  71
  72 func TestInitInfoLoggerFailure(t *testing.T) {
  73         log, err := InitLogger(99)
  74         assert.NotNil(t, err)
  75         assert.Nil(t, log)
  76 }
  77
  78 func TestSyncSuccess(t *testing.T){
  79         logFile, err := os.Create("./loggerTest.txt")
  80         if err != nil{
  81                 t.Errorf("logger_test.TestSyncSuccess - failed to create file, error: %s", err)
  82         }
  83         old := os.Stdout
  84         os.Stdout = logFile
  85         log, err := InitLogger(DebugLevel)
  86         if err != nil {
  87                 t.Errorf("logger_test.TestSyncSuccess - failed to initialize logger, error: %s", err)
  88         }
  89         err = log.Sync()
  90         assert.Nil(t, err)
  91
  92         os.Stdout = old
  93         logFile, err = os.Open("./loggerTest.txt")
  94         if err != nil{
  95                 t.Errorf("logger_test.TestSyncSuccess - failed to open file, error: %s", err)
  96         }
  97         var buf bytes.Buffer
  98         _, err = io.Copy(&buf, logFile)
  99         if err != nil {
 100                 t.Errorf("logger_test.TestSyncSuccess - failed to copy bytes, error: %s", err)
 101         }
 102         debugRecord,_ :=buf.ReadString('\n')
 103         errorRecord,_ :=buf.ReadString('\n')
 104
 105         assert.NotEmpty(t, debugRecord)
 106         assert.Empty(t, errorRecord)
 107         err = os.Remove("./loggerTest.txt")
 108         if err != nil {
 109                 t.Errorf("logger_test.TestSyncSuccess - failed to remove file, error: %s", err)
 110         }
 111
 112 }
 113
 114 func TestSyncFailure(t *testing.T){
 115         log, err := InitLogger(DebugLevel)
 116         err = log.Sync()
 117         assert.NotNil(t, err)
 118 }
 119
 120 func TestDebugEnabledFalse(t *testing.T){
 121         entryNum, log := countRecords(InfoLevel, t)
 122         assert.False(t, log.DebugEnabled())
 123         assert.Equal(t,3, entryNum)
 124 }
 125
 126 func TestDebugEnabledTrue(t *testing.T){
 127         entryNum, log := countRecords(DebugLevel, t)
 128         assert.True(t, log.DebugEnabled())
 129         assert.Equal(t,4, entryNum)
 130 }
 131
 132 func TestDPanicfDebugLevel(t *testing.T){
 133         assert.True(t,validateRecordExists(DebugLevel, zap.DPanicLevel, t))
 134 }
 135
 136 func TestDPanicfInfoLevel(t *testing.T){
 137         assert.True(t,validateRecordExists(InfoLevel, zap.DPanicLevel, t))
 138 }
 139
 140 func TestErrorfDebugLevel(t *testing.T)  {
 141         assert.True(t,validateRecordExists(DebugLevel, zap.ErrorLevel, t))
 142 }
 143
 144 func TestErrorfInfoLevel(t *testing.T)  {
 145         assert.True(t,validateRecordExists(InfoLevel, zap.ErrorLevel, t))
 146 }
 147
 148 func TestInfofDebugLevel(t *testing.T)  {
 149         assert.True(t,validateRecordExists(DebugLevel, zap.InfoLevel, t))
 150 }
 151
 152 func TestInfofInfoLevel(t *testing.T)  {
 153         assert.True(t,validateRecordExists(InfoLevel, zap.InfoLevel, t))
 154 }
 155
 156 func TestDebugfDebugLevel(t *testing.T)  {
 157         assert.True(t,validateRecordExists(DebugLevel, zap.DebugLevel, t))
 158 }
 159
 160 func TestDebugfInfoLevel(t *testing.T)  {
 161         assert.False(t,validateRecordExists(InfoLevel, zap.DebugLevel, t))
 162 }
 163
 164 func TestInfofFatalLevel(t *testing.T)  {
 165         assert.False(t,validateRecordExists(FatalLevel, zap.InfoLevel, t))
 166 }
 167
 168 func TestDebugfFatalLevel(t *testing.T)  {
 169         assert.False(t,validateRecordExists(FatalLevel, zap.DebugLevel, t))
 170 }
 171
 172 func TestWarnfWarnLevel(t *testing.T)  {
 173         assert.True(t,validateRecordExists(WarnLevel, zap.WarnLevel, t))
 174 }
 175
 176 func TestWarnfDebugLevel(t *testing.T)  {
 177         assert.True(t,validateRecordExists(DebugLevel, zap.WarnLevel, t))
 178 }
 179
 180 func TestWarnfInfoLevel(t *testing.T)  {
 181         assert.True(t,validateRecordExists(InfoLevel, zap.WarnLevel, t))
 182 }
 183
 184 func TestWarnfFatalLevel(t *testing.T)  {
 185         assert.False(t,validateRecordExists(FatalLevel, zap.WarnLevel, t))
 186 }
 187
 188 func TestLogLevelTokenToLevel(t *testing.T) {
 189         level, ok := LogLevelTokenToLevel("deBug")
 190         assert.True(t, ok)
 191         assert.True(t, level == DebugLevel)
 192
 193         level, ok = LogLevelTokenToLevel("infO")
 194         assert.True(t, ok)
 195         assert.True(t, level == InfoLevel)
 196
 197         level, ok = LogLevelTokenToLevel("Warn")
 198         assert.True(t, ok)
 199         assert.True(t, level == WarnLevel)
 200
 201         level, ok = LogLevelTokenToLevel("eRror")
 202         assert.True(t, ok)
 203         assert.True(t, level == ErrorLevel)
 204
 205         level, ok = LogLevelTokenToLevel("Dpanic ")
 206         assert.True(t, ok)
 207         assert.True(t, level == DPanicLevel)
 208
 209         level, ok = LogLevelTokenToLevel("    panic ")
 210         assert.True(t, ok)
 211         assert.True(t, level == PanicLevel)
 212
 213         level, ok = LogLevelTokenToLevel("fatal")
 214         assert.True(t, ok)
 215         assert.True(t, level == FatalLevel)
 216
 217         level, ok = LogLevelTokenToLevel("zzz")
 218         assert.False(t, ok)
 219         assert.True(t, level > FatalLevel)
 220
 221 }
 222 func countRecords(logLevel LogLevel, t *testing.T) (int, *Logger){
 223         old := os.Stdout
 224         r, w, _ :=os.Pipe()
 225         os.Stdout = w
 226         log, err := InitLogger(logLevel)
 227         if err != nil {
 228                 t.Errorf("logger_test.TestSyncFailure - failed to initialize logger, error: %s", err)
 229         }
 230         log.Infof("%v, %v, %v", 1, "abc", 0.1)
 231         log.Debugf("%v, %v, %v", 1, "abc", 0.1)
 232         log.Errorf("%v, %v, %v", 1, "abc", 0.1)
 233         log.DPanicf("%v, %v, %v", 1, "abc", 0.1)
 234         err = w.Close()
 235         if err != nil {
 236                 t.Errorf("logger_test.TestSyncFailure - failed to close writer, error: %s", err)
 237         }
 238         os.Stdout = old
 239         var buf bytes.Buffer
 240         _, err = io.Copy(&buf, r)
 241         if err != nil {
 242                 t.Errorf("logger_test.TestSyncFailure - failed to copy bytes, error: %s", err)
 243         }
 244         entryNum := 0
 245         s,_:= buf.ReadString('\n')
 246         for len(s) > 0{
 247                 entryNum +=1
 248                 s,_= buf.ReadString('\n')
 249         }
 250         return entryNum, log
 251 }
 252
 253 func validateRecordExists(logLevel LogLevel, recordLevel zapcore.Level, t *testing.T) bool {
 254         old := os.Stdout
 255         r, w, _ :=os.Pipe()
 256         os.Stdout = w
 257         log, err := InitLogger(logLevel)
 258         if err != nil {
 259                 t.Errorf("logger_test.TestSyncFailure - failed to initialize logger, error: %s", err)
 260         }
 261         switch recordLevel{
 262         case  zap.DebugLevel:
 263                 log.Debugf("%v, %v, %v", 1, "abc", 0.1)
 264         case zap.InfoLevel:
 265                 log.Infof("%v, %v, %v", 1, "abc", 0.1)
 266         case zap.WarnLevel:
 267                 log.Warnf("%v, %v, %v", 1, "abc", 0.1)
 268         case zap.ErrorLevel:
 269                 log.Errorf("%v, %v, %v", 1, "abc", 0.1)
 270         case zap.DPanicLevel:
 271                 log.DPanicf("%v, %v, %v", 1, "abc", 0.1)
 272         }
 273         err = w.Close()
 274         if err != nil {
 275                 t.Errorf("logger_test.TestSyncFailure - failed to close writer, error: %s", err)
 276         }
 277         os.Stdout = old
 278         var buf bytes.Buffer
 279         _, err = io.Copy(&buf, r)
 280         if err != nil {
 281                 t.Errorf("logger_test.TestSyncFailure - failed to copy bytes, error: %s", err)
 282         }
 283         entryNum := 0
 284         s,_:= buf.ReadString('\n')
 285         for len(s) > 0{
 286                 entryNum +=1
 287                 s,_= buf.ReadString('\n')
 288         }
 289         return entryNum == 1
 290 }