golib/logger/interface_test.go

/*
 * MIT License
 *
 * Copyright (c) 2025 Nicolas JUHEL
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in all
 * copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
 *
 *
 */

package logger_test

import (
	"context"
	"time"

	liblog "github.com/nabbar/golib/logger"
	logcfg "github.com/nabbar/golib/logger/config"
	logfld "github.com/nabbar/golib/logger/fields"
	loglvl "github.com/nabbar/golib/logger/level"
	libsem "github.com/nabbar/golib/semaphore"
	. "github.com/onsi/ginkgo/v2"
	. "github.com/onsi/gomega"
)

var _ = Describe("Logger", func() {
	Context("Create New Logger with Default Config", func() {
		It("Must succeed", func() {
			log := liblog.New(GetContext())
			defer func() {
				Expect(log.Close()).ToNot(HaveOccurred())
			}()
			log.SetLevel(loglvl.DebugLevel)
			err := log.SetOptions(&logcfg.Options{
				Stdout: &logcfg.OptionsStd{
					DisableStandard: true,
				},
			})
			Expect(err).ToNot(HaveOccurred())
			log.LogDetails(loglvl.InfoLevel, "test logger", nil, nil, nil)
		})
	})
	Context("Create New Logger with Default Config and trace", func() {
		It("Must succeed", func() {
			log := liblog.New(GetContext())
			defer func() {
				Expect(log.Close()).ToNot(HaveOccurred())
			}()
			log.SetLevel(loglvl.DebugLevel)
			err := log.SetOptions(&logcfg.Options{
				Stdout: &logcfg.OptionsStd{
					DisableStandard: true,
					EnableTrace:     true,
				},
			})
			Expect(err).ToNot(HaveOccurred())
			log.LogDetails(loglvl.InfoLevel, "test logger with trace", nil, nil, nil)
		})
	})
	Context("Create New Logger with field", func() {
		It("Must succeed", func() {
			log := liblog.New(GetContext())
			defer func() {
				Expect(log.Close()).ToNot(HaveOccurred())
			}()
			log.SetLevel(loglvl.DebugLevel)
			err := log.SetOptions(&logcfg.Options{
				Stdout: &logcfg.OptionsStd{
					DisableStandard: true,
					EnableTrace:     true,
				},
			})
			log.SetFields(logfld.New(GetContext()).Add("test-field", "ok"))
			Expect(err).ToNot(HaveOccurred())
			log.LogDetails(loglvl.InfoLevel, "test logger with field", nil, nil, nil)
		})
	})
	Context("Create New Logger with file", func() {
		It("Must succeed", func() {
			fsp, err := GetTempFile()
			Expect(err).ToNot(HaveOccurred())

			log := liblog.New(GetContext())
			defer func() {
				Expect(log.Close()).ToNot(HaveOccurred())
			}()
			log.SetLevel(loglvl.DebugLevel)

			err = log.SetOptions(&logcfg.Options{
				Stdout: &logcfg.OptionsStd{
					DisableStandard: true,
					EnableTrace:     true,
				},
				LogFile: []logcfg.OptionsFile{
					{
						LogLevel:         nil,
						Filepath:         fsp,
						Create:           true,
						CreatePath:       true,
						DisableStack:     false,
						DisableTimestamp: false,
						EnableTrace:      true,
					},
				},
			})
			Expect(err).ToNot(HaveOccurred())

			log.SetFields(logfld.New(GetContext()).Add("test-field", "ok"))
			log.LogDetails(loglvl.InfoLevel, "test logger with field", nil, nil, nil)
			// Wait for logs to be written to file
			time.Sleep(200 * time.Millisecond)
		})
	})
	Context("Create New Logger with file in multithreading mode", func() {
		It("Must succeed", func() {
			fsp, err := GetTempFile()
			Expect(err).ToNot(HaveOccurred())

			log := liblog.New(GetContext())
			defer func() {
				Expect(log.Close()).ToNot(HaveOccurred())
			}()
			log.SetLevel(loglvl.DebugLevel)

			err = log.SetOptions(&logcfg.Options{
				Stdout: &logcfg.OptionsStd{
					DisableStandard: true,
				},
				LogFile: []logcfg.OptionsFile{
					{
						LogLevel:         nil,
						Filepath:         fsp,
						Create:           true,
						CreatePath:       true,
						DisableStack:     false,
						DisableTimestamp: false,
						EnableTrace:      true,
					},
				},
			})
			Expect(err).ToNot(HaveOccurred())

			log.SetFields(logfld.New(GetContext()).Add("test-field", "ok"))
			log.LogDetails(loglvl.InfoLevel, "test logger with field", nil, nil, nil)

			var sub liblog.Logger
			sub, err = log.Clone()
			Expect(err).ToNot(HaveOccurred())

			go func(l liblog.Logger) {
				defer func() {
					Expect(l.Close()).ToNot(HaveOccurred())
				}()
				l.SetFields(logfld.New(GetContext()).Add("logger", "sub"))
				for i := 0; i < 10; i++ {
					l.Entry(loglvl.InfoLevel, "test multithreading logger").FieldAdd("id", i).Log()
				}
			}(sub)

			log.SetFields(logfld.New(GetContext()).Add("logger", "main"))
			sem := libsem.New(context.Background(), 0, false)
			defer sem.DeferMain()

			for i := 0; i < 25; i++ {
				Expect(sem.NewWorker()).ToNot(HaveOccurred())

				go func(id int) {
					defer sem.DeferWorker()
					ent := log.Entry(loglvl.InfoLevel, "test multithreading logger")
					ent.FieldAdd("id", id)
					ent.Log()
				}(i)
			}

			Expect(sem.WaitAll()).ToNot(HaveOccurred())
			// Wait for all logs to be written to file
			time.Sleep(300 * time.Millisecond)
		})
	})
})