github.com/ssgreg/logf@v1.4.1/logger_test.go (about)

     1  package logf
     2  
     3  import (
     4  	"testing"
     5  	"time"
     6  
     7  	"github.com/stretchr/testify/assert"
     8  	"github.com/stretchr/testify/require"
     9  )
    10  
    11  func TestLoggerNew(t *testing.T) {
    12  	w := &testEntryWriter{}
    13  	logger := NewLogger(LevelError, w)
    14  
    15  	assert.Equal(t, 0, logger.callerSkip)
    16  	assert.Equal(t, false, logger.addCaller)
    17  	assert.True(t, logger.id > 0)
    18  	assert.Empty(t, logger.fields)
    19  	assert.Empty(t, logger.name)
    20  	assert.Equal(t, w, logger.w)
    21  }
    22  
    23  func TestLoggerCallerNotSpecifiedByDefault(t *testing.T) {
    24  	w := &testEntryWriter{}
    25  	logger := NewLogger(LevelError, w)
    26  
    27  	logger.Error("")
    28  	assert.False(t, w.Entry.Caller.Specified)
    29  }
    30  
    31  func TestLoggerCallerSpecified(t *testing.T) {
    32  	w := &testEntryWriter{}
    33  	logger := NewLogger(LevelError, w).WithCaller()
    34  
    35  	logger.Error("")
    36  	assert.True(t, w.Entry.Caller.Specified)
    37  	assert.Equal(t, "logf/logger_test.go", w.Entry.Caller.FileWithPackage())
    38  }
    39  
    40  func TestLoggerCallerSpecifiedWithSkip(t *testing.T) {
    41  	w := &testEntryWriter{}
    42  	logger := NewLogger(LevelError, w).WithCaller().WithCallerSkip(1)
    43  
    44  	logger.Error("")
    45  	assert.True(t, w.Entry.Caller.Specified)
    46  	assert.Equal(t, "testing/testing.go", w.Entry.Caller.FileWithPackage())
    47  }
    48  
    49  func TestLoggerNoNameByDefault(t *testing.T) {
    50  	w := &testEntryWriter{}
    51  	logger := NewLogger(LevelError, w)
    52  
    53  	logger.Error("")
    54  	assert.Empty(t, w.Entry.LoggerName)
    55  }
    56  
    57  func TestLoggerEmptyName(t *testing.T) {
    58  	w := &testEntryWriter{}
    59  	logger := NewLogger(LevelError, w).WithName("")
    60  
    61  	logger.Error("")
    62  	assert.Empty(t, w.Entry.LoggerName)
    63  }
    64  
    65  func TestLoggerName(t *testing.T) {
    66  	w := &testEntryWriter{}
    67  
    68  	// Set a name for the logger.
    69  	logger := NewLogger(LevelError, w).WithName("1")
    70  	logger.Error("")
    71  	assert.Equal(t, "1", w.Entry.LoggerName)
    72  
    73  	// Set a nested name for the logger.
    74  	logger = logger.WithName("2")
    75  	logger.Error("")
    76  	assert.Equal(t, "1.2", w.Entry.LoggerName)
    77  }
    78  
    79  func TestLoggerWithLevel(t *testing.T) {
    80  	w := &testEntryWriter{}
    81  
    82  	// Set a name for the logger.
    83  	logger := NewLogger(LevelInfo, w).WithLevel(LevelError)
    84  
    85  	logger.Info("")
    86  	assert.Nil(t, w.Entry)
    87  
    88  	logger.Error("")
    89  	assert.NotNil(t, w.Entry)
    90  }
    91  
    92  func TestLoggerAtLevel(t *testing.T) {
    93  	w := &testEntryWriter{}
    94  	logger := NewLogger(LevelError, w)
    95  
    96  	// Expected the callback should be called with the same severity level.
    97  	called := false
    98  	logger.AtLevel(LevelError, func(log LogFunc) {
    99  		called = true
   100  		assert.NotEmpty(t, log)
   101  		log("at-level")
   102  	})
   103  	assert.Equal(t, "at-level", w.Entry.Text)
   104  	assert.True(t, called)
   105  
   106  	// Expected the callback should NOT be called with DEBUG severity level.
   107  	called = false
   108  	logger.AtLevel(LevelDebug, func(log LogFunc) {
   109  		called = true
   110  	})
   111  	assert.False(t, called)
   112  }
   113  
   114  func TestLoggerNoFieldsByDefault(t *testing.T) {
   115  	w := &testEntryWriter{}
   116  
   117  	logger := NewLogger(LevelError, w)
   118  	logger.Error("")
   119  	assert.Empty(t, w.Entry.DerivedFields)
   120  }
   121  
   122  func TestLoggerFields(t *testing.T) {
   123  	w := &testEntryWriter{}
   124  
   125  	// Add one Field.
   126  	logger := NewLogger(LevelError, w).With(String("first", "v"), String("second", "v"))
   127  	logger.Error("")
   128  	assert.Equal(t, 2, len(w.Entry.DerivedFields))
   129  
   130  	// Add second Field.
   131  	logger = logger.With(String("third", "v"))
   132  	logger.Error("")
   133  	assert.Equal(t, 3, len(w.Entry.DerivedFields))
   134  
   135  	// Check order. First field should go first.
   136  	assert.Equal(t, "first", w.Entry.DerivedFields[0].Key)
   137  	assert.Equal(t, "second", w.Entry.DerivedFields[1].Key)
   138  	assert.Equal(t, "third", w.Entry.DerivedFields[2].Key)
   139  }
   140  
   141  func TestLoggerWithFieldsCallSnapshotter(t *testing.T) {
   142  	w := &testEntryWriter{}
   143  	ts := testSnapshotter{}
   144  
   145  	NewLogger(LevelError, w).With(Any("snapshotter", &ts))
   146  	assert.True(t, ts.Called)
   147  }
   148  
   149  func TestLoggerID(t *testing.T) {
   150  	w := &testEntryWriter{}
   151  	logger := NewLogger(LevelError, w)
   152  
   153  	logger.Error("")
   154  	assert.Equal(t, logger.id, w.Entry.LoggerID)
   155  }
   156  
   157  func TestLoggerLeveledLog(t *testing.T) {
   158  	w := &testEntryWriter{}
   159  	logger := NewLogger(LevelDebug, w)
   160  
   161  	cases := []struct {
   162  		Level Level
   163  		Fn    func(string, ...Field)
   164  	}{
   165  		{LevelError, logger.Error},
   166  		{LevelWarn, logger.Warn},
   167  		{LevelInfo, logger.Info},
   168  		{LevelDebug, logger.Debug},
   169  	}
   170  
   171  	for _, c := range cases {
   172  		t.Run(c.Level.String(), func(t *testing.T) {
   173  			ts := testSnapshotter{}
   174  			c.Fn(c.Level.String(), Any("snapshotter", &ts))
   175  
   176  			assert.Equal(t, c.Level.String(), w.Entry.Text)
   177  			assert.Equal(t, 1, len(w.Entry.Fields))
   178  			assert.Equal(t, c.Level, w.Entry.Level)
   179  			assert.WithinDuration(t, time.Now(), w.Entry.Time, time.Second*2)
   180  			assert.True(t, ts.Called)
   181  		})
   182  	}
   183  }
   184  
   185  func TestLoggerChecker(t *testing.T) {
   186  	w := &testEntryWriter{}
   187  	logger := NewLogger(testLevelCheckerReturningFalse{}, w)
   188  
   189  	logger.Error("")
   190  	assert.Nil(t, w.Entry)
   191  
   192  	logger.Warn("")
   193  	assert.Nil(t, w.Entry)
   194  
   195  	logger.Info("")
   196  	assert.Nil(t, w.Entry)
   197  
   198  	logger.Debug("")
   199  	assert.Nil(t, w.Entry)
   200  }
   201  
   202  func TestLoggerDisabled(t *testing.T) {
   203  	logger := DisabledLogger()
   204  	assert.Equal(t, 0, logger.callerSkip)
   205  	assert.Equal(t, false, logger.addCaller)
   206  	assert.True(t, logger.id > 0)
   207  	assert.Empty(t, logger.fields)
   208  	assert.Empty(t, logger.name)
   209  	assert.Empty(t, logger.w)
   210  
   211  	loggerWithCallerSkip := logger.WithCallerSkip(1)
   212  	assert.Equal(t, 1, loggerWithCallerSkip.callerSkip)
   213  
   214  	loggerWithCaller := logger.WithCaller()
   215  	assert.Equal(t, true, loggerWithCaller.addCaller)
   216  
   217  	loggerWithName := logger.WithName("name")
   218  	assert.Equal(t, "name", loggerWithName.name)
   219  
   220  	loggerWithFields := logger.With(String("k", "v"))
   221  	assert.NotEmpty(t, loggerWithFields.fields)
   222  
   223  	// Check function not panic.
   224  	logger.Debug("")
   225  	logger.Info("")
   226  	logger.Warn("")
   227  	logger.Error("")
   228  	logger.AtLevel(LevelError, func(LogFunc) { require.FailNow(t, "can't be here") })
   229  }
   230  
   231  func TestUnbufferedWriter(t *testing.T) {
   232  	a := &testAppender{}
   233  	w := NewUnbufferedEntryWriter(a)
   234  	logger := NewLogger(LevelDebug, w)
   235  
   236  	// Check function not panic.
   237  	logger.Debug("debug")
   238  	logger.Info("info")
   239  	logger.Warn("warn")
   240  	logger.Error("error")
   241  	logger.AtLevel(LevelError, func(log LogFunc) {
   242  		log("at-level-error")
   243  	})
   244  
   245  	require.Equal(t, 5, len(a.Entries))
   246  
   247  	assert.Equal(t, "debug", a.Entries[0].Text)
   248  	assert.Equal(t, "info", a.Entries[1].Text)
   249  	assert.Equal(t, "warn", a.Entries[2].Text)
   250  	assert.Equal(t, "error", a.Entries[3].Text)
   251  	assert.Equal(t, "at-level-error", a.Entries[4].Text)
   252  
   253  	assert.Equal(t, LevelDebug, a.Entries[0].Level)
   254  	assert.Equal(t, LevelInfo, a.Entries[1].Level)
   255  	assert.Equal(t, LevelWarn, a.Entries[2].Level)
   256  	assert.Equal(t, LevelError, a.Entries[3].Level)
   257  	assert.Equal(t, LevelError, a.Entries[4].Level)
   258  }