github.com/go-kit/log@v0.2.1/sync_test.go (about)

     1  package log_test
     2  
     3  import (
     4  	"bytes"
     5  	"io"
     6  	"os"
     7  	"testing"
     8  
     9  	"github.com/go-kit/log"
    10  )
    11  
    12  func TestSwapLogger(t *testing.T) {
    13  	t.Parallel()
    14  	var logger log.SwapLogger
    15  
    16  	// Zero value does not panic or error.
    17  	err := logger.Log("k", "v")
    18  	if got, want := err, error(nil); got != want {
    19  		t.Errorf("got %v, want %v", got, want)
    20  	}
    21  
    22  	buf := &bytes.Buffer{}
    23  	json := log.NewJSONLogger(buf)
    24  	logger.Swap(json)
    25  
    26  	if err := logger.Log("k", "v"); err != nil {
    27  		t.Error(err)
    28  	}
    29  	if got, want := buf.String(), `{"k":"v"}`+"\n"; got != want {
    30  		t.Errorf("got %v, want %v", got, want)
    31  	}
    32  
    33  	buf.Reset()
    34  	prefix := log.NewLogfmtLogger(buf)
    35  	logger.Swap(prefix)
    36  
    37  	if err := logger.Log("k", "v"); err != nil {
    38  		t.Error(err)
    39  	}
    40  	if got, want := buf.String(), "k=v\n"; got != want {
    41  		t.Errorf("got %v, want %v", got, want)
    42  	}
    43  
    44  	buf.Reset()
    45  	logger.Swap(nil)
    46  
    47  	if err := logger.Log("k", "v"); err != nil {
    48  		t.Error(err)
    49  	}
    50  	if got, want := buf.String(), ""; got != want {
    51  		t.Errorf("got %v, want %v", got, want)
    52  	}
    53  }
    54  
    55  func TestSwapLoggerConcurrency(t *testing.T) {
    56  	t.Parallel()
    57  	testConcurrency(t, &log.SwapLogger{}, 10000)
    58  }
    59  
    60  func TestSyncLoggerConcurrency(t *testing.T) {
    61  	var w io.Writer //lint:ignore S1021 I prefer this
    62  	w = &bytes.Buffer{}
    63  	logger := log.NewLogfmtLogger(w)
    64  	logger = log.NewSyncLogger(logger)
    65  	testConcurrency(t, logger, 10000)
    66  }
    67  
    68  func TestSyncWriterConcurrency(t *testing.T) {
    69  	var w io.Writer
    70  	w = &bytes.Buffer{}
    71  	w = log.NewSyncWriter(w)
    72  	testConcurrency(t, log.NewLogfmtLogger(w), 10000)
    73  }
    74  
    75  func TestSyncWriterFd(t *testing.T) {
    76  	_, ok := log.NewSyncWriter(os.Stdout).(interface {
    77  		Fd() uintptr
    78  	})
    79  
    80  	if !ok {
    81  		t.Error("NewSyncWriter does not pass through Fd method")
    82  	}
    83  }
    84  
    85  func TestSyncLoggerPanic(t *testing.T) {
    86  	var logger log.Logger
    87  	logger = log.LoggerFunc(func(...interface{}) error { panic("!") })
    88  	logger = log.NewSyncLogger(logger)
    89  
    90  	f := func() {
    91  		defer func() {
    92  			if x := recover(); x != nil {
    93  				t.Log(x)
    94  			}
    95  		}()
    96  		logger.Log("hello", "world")
    97  	}
    98  
    99  	f()
   100  	f() // without defer Unlock, this one can deadlock
   101  }