| // |
| // Copyright 2019 AT&T Intellectual Property |
| // Copyright 2019 Nokia |
| // |
| // Licensed under the Apache License, Version 2.0 (the "License"); |
| // you may not use this file except in compliance with the License. |
| // You may obtain a copy of the License at |
| // |
| // http://www.apache.org/licenses/LICENSE-2.0 |
| // |
| // Unless required by applicable law or agreed to in writing, software |
| // distributed under the License is distributed on an "AS IS" BASIS, |
| // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| // See the License for the specific language governing permissions and |
| // limitations under the License. |
| // |
| |
| package logger |
| |
| import ( |
| "bytes" |
| "github.com/stretchr/testify/assert" |
| "go.uber.org/zap" |
| "go.uber.org/zap/zapcore" |
| "io" |
| "os" |
| "testing" |
| ) |
| |
| func TestInitDebugLoggerSuccess(t *testing.T) { |
| log, err := InitLogger(DebugLevel) |
| assert.Nil(t, err) |
| assert.NotNil(t, log) |
| assert.True(t, log.Logger.Core().Enabled(zap.DebugLevel)) |
| } |
| |
| func TestInitInfoLoggerSuccess(t *testing.T) { |
| log, err := InitLogger(InfoLevel) |
| assert.Nil(t, err) |
| assert.NotNil(t, log) |
| assert.True(t, log.Logger.Core().Enabled(zap.InfoLevel)) |
| } |
| |
| func TestInitInfoLoggerFailure(t *testing.T) { |
| log, err := InitLogger(99) |
| assert.NotNil(t, err) |
| assert.Nil(t, log) |
| } |
| |
| func TestSyncSuccess(t *testing.T){ |
| logFile, err := os.Create("./loggerTest.txt") |
| if err != nil{ |
| t.Errorf("logger_test.TestSyncSuccess - failed to create file, error: %s", err) |
| } |
| old := os.Stdout |
| os.Stdout = logFile |
| log, err := InitLogger(DebugLevel) |
| if err != nil { |
| t.Errorf("logger_test.TestSyncSuccess - failed to initialize logger, error: %s", err) |
| } |
| err = log.Sync() |
| assert.Nil(t, err) |
| |
| os.Stdout = old |
| logFile, err = os.Open("./loggerTest.txt") |
| if err != nil{ |
| t.Errorf("logger_test.TestSyncSuccess - failed to open file, error: %s", err) |
| } |
| var buf bytes.Buffer |
| _, err = io.Copy(&buf, logFile) |
| if err != nil { |
| t.Errorf("logger_test.TestSyncSuccess - failed to copy bytes, error: %s", err) |
| } |
| debugRecord,_ :=buf.ReadString('\n') |
| errorRecord,_ :=buf.ReadString('\n') |
| |
| assert.NotEmpty(t, debugRecord) |
| assert.Empty(t, errorRecord) |
| err = os.Remove("./loggerTest.txt") |
| if err != nil { |
| t.Errorf("logger_test.TestSyncSuccess - failed to remove file, error: %s", err) |
| } |
| |
| } |
| |
| func TestSyncFailure(t *testing.T){ |
| log, err := InitLogger(DebugLevel) |
| err = log.Sync() |
| assert.NotNil(t, err) |
| } |
| |
| func TestDebugEnabledFalse(t *testing.T){ |
| entryNum, log := countRecords(InfoLevel, t) |
| assert.False(t, log.DebugEnabled()) |
| assert.Equal(t,3, entryNum) |
| } |
| |
| func TestDebugEnabledTrue(t *testing.T){ |
| entryNum, log := countRecords(DebugLevel, t) |
| assert.True(t, log.DebugEnabled()) |
| assert.Equal(t,4, entryNum) |
| } |
| |
| func TestDPanicfDebugLevel(t *testing.T){ |
| assert.True(t,validateRecordExists(DebugLevel, zap.DPanicLevel, t)) |
| } |
| |
| func TestDPanicfInfoLevel(t *testing.T){ |
| assert.True(t,validateRecordExists(InfoLevel, zap.DPanicLevel, t)) |
| } |
| |
| func TestErrorfDebugLevel(t *testing.T) { |
| assert.True(t,validateRecordExists(DebugLevel, zap.ErrorLevel, t)) |
| } |
| |
| func TestErrorfInfoLevel(t *testing.T) { |
| assert.True(t,validateRecordExists(InfoLevel, zap.ErrorLevel, t)) |
| } |
| |
| func TestInfofDebugLevel(t *testing.T) { |
| assert.True(t,validateRecordExists(DebugLevel, zap.InfoLevel, t)) |
| } |
| |
| func TestInfofInfoLevel(t *testing.T) { |
| assert.True(t,validateRecordExists(InfoLevel, zap.InfoLevel, t)) |
| } |
| |
| func TestDebugfDebugLevel(t *testing.T) { |
| assert.True(t,validateRecordExists(DebugLevel, zap.DebugLevel, t)) |
| } |
| |
| func TestDebugfInfoLevel(t *testing.T) { |
| assert.False(t,validateRecordExists(InfoLevel, zap.DebugLevel, t)) |
| } |
| |
| func TestInfofFatalLevel(t *testing.T) { |
| assert.False(t,validateRecordExists(FatalLevel, zap.InfoLevel, t)) |
| } |
| |
| func TestDebugfFatalLevel(t *testing.T) { |
| assert.False(t,validateRecordExists(FatalLevel, zap.DebugLevel, t)) |
| } |
| |
| func TestLogLevelTokenToLevel(t *testing.T) { |
| level, ok := LogLevelTokenToLevel("deBug") |
| assert.True(t, ok) |
| assert.True(t, level == DebugLevel) |
| |
| level, ok = LogLevelTokenToLevel("infO") |
| assert.True(t, ok) |
| assert.True(t, level == InfoLevel) |
| |
| level, ok = LogLevelTokenToLevel("Warn") |
| assert.True(t, ok) |
| assert.True(t, level == WarnLevel) |
| |
| level, ok = LogLevelTokenToLevel("eRror") |
| assert.True(t, ok) |
| assert.True(t, level == ErrorLevel) |
| |
| level, ok = LogLevelTokenToLevel("Dpanic ") |
| assert.True(t, ok) |
| assert.True(t, level == DPanicLevel) |
| |
| level, ok = LogLevelTokenToLevel(" panic ") |
| assert.True(t, ok) |
| assert.True(t, level == PanicLevel) |
| |
| level, ok = LogLevelTokenToLevel("fatal") |
| assert.True(t, ok) |
| assert.True(t, level == FatalLevel) |
| |
| level, ok = LogLevelTokenToLevel("zzz") |
| assert.False(t, ok) |
| assert.True(t, level > FatalLevel) |
| |
| } |
| func countRecords(logLevel LogLevel, t *testing.T) (int, *Logger){ |
| old := os.Stdout |
| r, w, _ :=os.Pipe() |
| os.Stdout = w |
| log, err := InitLogger(logLevel) |
| if err != nil { |
| t.Errorf("logger_test.TestSyncFailure - failed to initialize logger, error: %s", err) |
| } |
| log.Infof("%v, %v, %v", 1, "abc", 0.1) |
| log.Debugf("%v, %v, %v", 1, "abc", 0.1) |
| log.Errorf("%v, %v, %v", 1, "abc", 0.1) |
| log.DPanicf("%v, %v, %v", 1, "abc", 0.1) |
| err = w.Close() |
| if err != nil { |
| t.Errorf("logger_test.TestSyncFailure - failed to close writer, error: %s", err) |
| } |
| os.Stdout = old |
| var buf bytes.Buffer |
| _, err = io.Copy(&buf, r) |
| if err != nil { |
| t.Errorf("logger_test.TestSyncFailure - failed to copy bytes, error: %s", err) |
| } |
| entryNum := 0 |
| s,_:= buf.ReadString('\n') |
| for len(s) > 0{ |
| entryNum +=1 |
| s,_= buf.ReadString('\n') |
| } |
| return entryNum, log |
| } |
| |
| func validateRecordExists(logLevel LogLevel, recordLevel zapcore.Level, t *testing.T) bool { |
| old := os.Stdout |
| r, w, _ :=os.Pipe() |
| os.Stdout = w |
| log, err := InitLogger(logLevel) |
| if err != nil { |
| t.Errorf("logger_test.TestSyncFailure - failed to initialize logger, error: %s", err) |
| } |
| switch recordLevel{ |
| case zap.DebugLevel: |
| log.Debugf("%v, %v, %v", 1, "abc", 0.1) |
| case zap.InfoLevel: |
| log.Infof("%v, %v, %v", 1, "abc", 0.1) |
| case zap.ErrorLevel: |
| log.Errorf("%v, %v, %v", 1, "abc", 0.1) |
| case zap.DPanicLevel: |
| log.DPanicf("%v, %v, %v", 1, "abc", 0.1) |
| } |
| err = w.Close() |
| if err != nil { |
| t.Errorf("logger_test.TestSyncFailure - failed to close writer, error: %s", err) |
| } |
| os.Stdout = old |
| var buf bytes.Buffer |
| _, err = io.Copy(&buf, r) |
| if err != nil { |
| t.Errorf("logger_test.TestSyncFailure - failed to copy bytes, error: %s", err) |
| } |
| entryNum := 0 |
| s,_:= buf.ReadString('\n') |
| for len(s) > 0{ |
| entryNum +=1 |
| s,_= buf.ReadString('\n') |
| } |
| return entryNum == 1 |
| } |