Refactor logger tests and remove unused code

Author: ShocOne

logger/zaplogger_logger_test.go

@@ -11,10 +11,6 @@ import (
 	"go.uber.org/zap/zapcore"
 )
 
-// osExit is a variable that holds a reference to os.Exit function.
-// It allows overriding os.Exit in tests to prevent exiting the test runner.
-var osExit = os.Exit
-
 // TestDefaultLogger_SetLevel tests the SetLevel method of defaultLogger
 func TestDefaultLogger_SetLevel(t *testing.T) {
 	logger := zap.NewNop()
@@ -64,151 +60,6 @@ func TestDefaultLogger_GetLogLevel(t *testing.T) {
 	}
 }
 
-/*
-// TestDefaultLogger_Debug verifies that the Debug method of the defaultLogger struct correctly
-// invokes the underlying zap.Logger's Debug method when the log level is set to allow Debug messages.
-// The test uses a mockLogger to simulate the zap.Logger behavior, allowing verification of method calls
-// without actual logging output. This ensures that the Debug method adheres to the expected behavior
-// based on the current log level setting, providing confidence in the logging logic's correctness.
-func TestDefaultLogger_Debug(t *testing.T) {
-	mockLogger := NewMockLogger()
-	dLogger := &defaultLogger{logger: mockLogger.Logger, logLevel: LogLevelDebug}
-
-	expectedMessage := "test message"
-	mockLogger.On("Debug", expectedMessage, mock.Anything).Once()
-
-	dLogger.Debug(expectedMessage)
-
-	mockLogger.AssertExpectations(t)
-}
-
-// TestDefaultLogger_Info verifies the Info method of the defaultLogger struct.
-// It ensures that Info logs messages at the Info level when the logger's level allows for it.
-// The test uses a mockLogger to intercept and verify the call to the underlying zap.Logger's Info method.
-func TestDefaultLogger_Info(t *testing.T) {
-	mockLogger := NewMockLogger()
-	dLogger := &defaultLogger{logger: mockLogger.Logger, logLevel: LogLevelInfo}
-
-	expectedMessage := "info message"
-	mockLogger.On("Info", expectedMessage, mock.Anything).Once()
-
-	dLogger.Info(expectedMessage)
-
-	mockLogger.AssertExpectations(t)
-}
-
-// TestDefaultLogger_Warn verifies the Warn method of the defaultLogger struct.
-// This test checks that Warn correctly logs messages at the Warn level based on the logger's current level.
-// The behavior is validated using a mockLogger to capture and assert the call to the zap.Logger's Warn method.
-func TestDefaultLogger_Warn(t *testing.T) {
-	mockLogger := NewMockLogger()
-	dLogger := &defaultLogger{logger: mockLogger.Logger, logLevel: LogLevelWarn}
-
-	expectedMessage := "warn message"
-	mockLogger.On("Warn", expectedMessage, mock.Anything).Once()
-
-	dLogger.Warn(expectedMessage)
-
-	mockLogger.AssertExpectations(t)
-}
-
-// TestDefaultLogger_Error checks the functionality of the Error method in the defaultLogger struct.
-// It ensures that Error logs messages at the Error level and returns an error as expected.
-// The test utilizes a mockLogger to track and affirm the invocation of zap.Logger's Error method.
-func TestDefaultLogger_Error(t *testing.T) {
-	mockLogger := NewMockLogger()
-	dLogger := &defaultLogger{logger: mockLogger.Logger, logLevel: LogLevelError}
-
-	expectedErrorMsg := "error message"
-	// Mock the Error method to return nil, indicating no error
-	mockLogger.On("Error", expectedErrorMsg, mock.Anything).Once().Return(fmt.Errorf("error message"))
-
-	err := dLogger.Error(expectedErrorMsg)
-
-	assert.NoError(t, err) // Check that the error returned is nil
-	mockLogger.AssertExpectations(t)
-}
-
-// TestDefaultLogger_Panic ensures the Panic method of the defaultLogger behaves correctly.
-// This test verifies that Panic logs messages at the Panic level and triggers a panic as expected.
-// Due to the nature of panic, this test needs to recover from the panic to verify the behavior.
-func TestDefaultLogger_Panic(t *testing.T) {
-	mockLogger := NewMockLogger()
-	dLogger := &defaultLogger{logger: mockLogger.Logger, logLevel: LogLevelPanic}
-
-	expectedMessage := "panic message"
-	mockLogger.On("Panic", expectedMessage, mock.Anything).Once()
-
-	// Assert that calling Panic method triggers a panic
-	assert.Panics(t, func() { dLogger.Panic(expectedMessage) }, "The Panic method should trigger a panic")
-
-	mockLogger.AssertExpectations(t)
-}
-
-
-// TestDefaultLogger_Fatal verifies the Fatal method of the defaultLogger struct.
-// It ensures that Fatal logs messages at the Fatal level and exits the application with a non-zero status code.
-// The test utilizes a mockLogger to capture and assert the call to the zap.Logger's Fatal method.
-func TestDefaultLogger_Fatal(t *testing.T) {
-	mockLogger := NewMockLogger()
-	dLogger := &defaultLogger{logger: mockLogger.Logger, logLevel: LogLevelFatal}
-
-	expectedFatalMsg := "fatal message"
-	// Use mock.Anything for fields argument to avoid strict matching issues
-	mockLogger.On("Fatal", expectedFatalMsg, mock.Anything).Once()
-
-	// Replace os.Exit temporarily to capture exit status
-	oldExit := osExit
-	var exitStatus int
-	osExit = func(code int) {
-		exitStatus = code
-	}
-	// Ensure the original os.Exit is restored after this test
-	defer func() { osExit = oldExit }()
-
-	// Execute the Fatal method, which is expected to call os.Exit
-	dLogger.Fatal(expectedFatalMsg)
-
-	// Verify the exit status is set as expected
-	assert.Equal(t, 1, exitStatus, "Expected non-zero exit status")
-
-	// Confirm that the mock logger's expectations are met
-	mockLogger.AssertExpectations(t)
-}
-*/
-// Debug mocks the Debug method of the Logger interface
-func (m *MockLogger) Debug(msg string, fields ...zapcore.Field) {
-	m.Called(msg, fields)
-}
-
-// Info mocks the Info method of the Logger interface
-func (m *MockLogger) Info(msg string, fields ...zapcore.Field) {
-	m.Called(msg, fields)
-}
-
-// Warn mocks the Warn method of the Logger interface
-func (m *MockLogger) Warn(msg string, fields ...zapcore.Field) {
-	m.Called(msg, fields)
-}
-
-// Error mocks the Error method of the Logger interface
-func (m *MockLogger) Error(msg string, fields ...zapcore.Field) error {
-	args := m.Called(msg, fields)
-	return args.Error(0)
-}
-
-// With mocks the With method of the Logger interface
-func (m *MockLogger) With(fields ...zapcore.Field) Logger {
-	args := m.Called(fields)
-	return args.Get(0).(Logger)
-}
-
-// GetLogLevel mocks the GetLogLevel method of the Logger interface
-func (m *MockLogger) GetLogLevel() LogLevel {
-	args := m.Called()
-	return args.Get(0).(LogLevel)
-}
-
 // TestGetLoggerBasedOnEnv tests the GetLoggerBasedOnEnv function for different environment settings
 func TestGetLoggerBasedOnEnv(t *testing.T) {
 	tests := []struct {