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

     1  package logfc
     2  
     3  import (
     4  	"context"
     5  	"testing"
     6  
     7  	"github.com/ssgreg/logf"
     8  
     9  	"github.com/stretchr/testify/assert"
    10  )
    11  
    12  func TestNewAndGet(t *testing.T) {
    13  	ctx := context.Background()
    14  	logger := logf.NewDisabledLogger()
    15  
    16  	assert.Equal(t, logf.DisabledLogger(), Get(ctx))
    17  	assert.Equal(t, logger, Get(New(ctx, logger)))
    18  	assert.Equal(t, logger, MustGet(New(ctx, logger)))
    19  	assert.Panics(t, func() {
    20  		_ = MustGet(ctx)
    21  	})
    22  }
    23  
    24  func TestWith(t *testing.T) {
    25  	logger := logf.DisabledLogger()
    26  	ctx := New(context.Background(), logger)
    27  
    28  	assert.NotEqual(t, logger, Get(With(ctx, logf.Int("int", 42))))
    29  	assert.NotEqual(t, logger, Get(MustWith(ctx, logf.Int("int", 42))))
    30  }
    31  
    32  func TestWithName(t *testing.T) {
    33  	logger := logf.DisabledLogger()
    34  	ctx := New(context.Background(), logger)
    35  
    36  	assert.NotEqual(t, logger, Get(WithName(ctx, "n")))
    37  	assert.NotEqual(t, logger, Get(MustWithName(ctx, "n")))
    38  }
    39  
    40  func TestCaller(t *testing.T) {
    41  	logger := logf.DisabledLogger()
    42  	ctx := New(context.Background(), logger)
    43  
    44  	assert.NotEqual(t, logger, Get(WithCaller(ctx)))
    45  	assert.NotEqual(t, logger, Get(MustWithCaller(ctx)))
    46  }
    47  
    48  func TestCallerSkip(t *testing.T) {
    49  	logger := logf.DisabledLogger()
    50  	ctx := New(context.Background(), logger)
    51  
    52  	assert.NotEqual(t, logger, Get(WithCallerSkip(ctx, 1)))
    53  	assert.NotEqual(t, logger, Get(MustWithCallerSkip(ctx, 1)))
    54  }
    55  
    56  func TestAtLevel(t *testing.T) {
    57  	logger := logf.NewLogger(logf.LevelInfo, logf.NewUnbufferedEntryWriter(logf.NewDiscardAppender()))
    58  	ctx := New(context.Background(), logger)
    59  
    60  	called := false
    61  	AtLevel(ctx, logf.LevelInfo, func(logf.LogFunc) {
    62  		called = true
    63  	})
    64  
    65  	assert.Equal(t, true, called)
    66  }
    67  
    68  func TestMustAtLevel(t *testing.T) {
    69  	logger := logf.NewLogger(logf.LevelInfo, logf.NewUnbufferedEntryWriter(logf.NewDiscardAppender()))
    70  	ctx := New(context.Background(), logger)
    71  
    72  	called := false
    73  	MustAtLevel(ctx, logf.LevelInfo, func(logf.LogFunc) {
    74  		called = true
    75  	})
    76  
    77  	assert.Equal(t, true, called)
    78  }
    79  
    80  func TestLevels(t *testing.T) {
    81  	tests := []struct {
    82  		Name        string
    83  		Log         func(ctx context.Context, text string, fs ...logf.Field)
    84  		Level       logf.Level
    85  		ShouldPanic bool
    86  	}{
    87  		{
    88  			Name:        "Debug",
    89  			Log:         Debug,
    90  			Level:       logf.LevelDebug,
    91  			ShouldPanic: false,
    92  		},
    93  		{
    94  			Name:        "MustDebug",
    95  			Log:         MustDebug,
    96  			Level:       logf.LevelDebug,
    97  			ShouldPanic: true,
    98  		},
    99  		{
   100  			Name:        "Info",
   101  			Log:         Info,
   102  			Level:       logf.LevelInfo,
   103  			ShouldPanic: false,
   104  		},
   105  		{
   106  			Name:        "MustInfo",
   107  			Log:         MustInfo,
   108  			Level:       logf.LevelInfo,
   109  			ShouldPanic: true,
   110  		},
   111  		{
   112  			Name:        "Warn",
   113  			Log:         Warn,
   114  			Level:       logf.LevelWarn,
   115  			ShouldPanic: false,
   116  		},
   117  		{
   118  			Name:        "MustWarn",
   119  			Log:         MustWarn,
   120  			Level:       logf.LevelWarn,
   121  			ShouldPanic: true,
   122  		},
   123  		{
   124  			Name:        "Error",
   125  			Log:         Error,
   126  			Level:       logf.LevelError,
   127  			ShouldPanic: false,
   128  		},
   129  		{
   130  			Name:        "MustError",
   131  			Log:         MustError,
   132  			Level:       logf.LevelError,
   133  			ShouldPanic: true,
   134  		},
   135  	}
   136  	for _, test := range tests {
   137  		t.Run(test.Name, func(t *testing.T) {
   138  			if test.ShouldPanic {
   139  				assert.Panics(t, func() {
   140  					test.Log(context.Background(), "test")
   141  				})
   142  			} else {
   143  				assert.NotPanics(t, func() {
   144  					test.Log(context.Background(), "test")
   145  				})
   146  			}
   147  			text := "test text"
   148  			appender := mockAppender{}
   149  			logger := logf.NewLogger(logf.LevelDebug, logf.NewUnbufferedEntryWriter(&appender))
   150  			ctx := New(context.Background(), logger)
   151  			test.Log(ctx, text)
   152  			assert.Equal(t, 1, len(appender.entries))
   153  			assert.Equal(t, text, appender.entries[0].Text)
   154  			assert.Equal(t, test.Level, appender.entries[0].Level)
   155  		})
   156  	}
   157  }
   158  
   159  type mockAppender struct {
   160  	entries []logf.Entry
   161  }
   162  
   163  func (a *mockAppender) Append(entry logf.Entry) error {
   164  	a.entries = append(a.entries, entry)
   165  
   166  	return nil
   167  }
   168  
   169  func (a *mockAppender) Sync() (err error) {
   170  	return nil
   171  }
   172  
   173  func (a *mockAppender) Flush() error {
   174  	return nil
   175  }