[RICPLT-2734] E2Mgr: Automation
[ric-plt/e2mgr.git] / E2Manager / 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 }