github.com/hechain20/hechain@v0.0.0-20220316014945-b544036ba106/common/flogging/logging_test.go (about)

     1  /*
     2  Copyright hechain. All Rights Reserved.
     3  
     4  SPDX-License-Identifier: Apache-2.0
     5  */
     6  
     7  package flogging_test
     8  
     9  import (
    10  	"bytes"
    11  	"errors"
    12  	"fmt"
    13  	"os"
    14  	"testing"
    15  
    16  	"github.com/hechain20/hechain/common/flogging"
    17  	"github.com/hechain20/hechain/common/flogging/mock"
    18  	"github.com/stretchr/testify/require"
    19  	"go.uber.org/zap/zapcore"
    20  )
    21  
    22  func TestNew(t *testing.T) {
    23  	logging, err := flogging.New(flogging.Config{})
    24  	require.NoError(t, err)
    25  	require.Equal(t, zapcore.InfoLevel, logging.DefaultLevel())
    26  
    27  	_, err = flogging.New(flogging.Config{
    28  		LogSpec: "::=borken=::",
    29  	})
    30  	require.EqualError(t, err, "invalid logging specification '::=borken=::': bad segment '=borken='")
    31  }
    32  
    33  func TestNewWithEnvironment(t *testing.T) {
    34  	oldSpec, set := os.LookupEnv("FABRIC_LOGGING_SPEC")
    35  	if set {
    36  		defer os.Setenv("FABRIC_LOGGING_SPEC", oldSpec)
    37  	}
    38  
    39  	os.Setenv("FABRIC_LOGGING_SPEC", "fatal")
    40  	logging, err := flogging.New(flogging.Config{})
    41  	require.NoError(t, err)
    42  	require.Equal(t, zapcore.FatalLevel, logging.DefaultLevel())
    43  
    44  	os.Unsetenv("FABRIC_LOGGING_SPEC")
    45  	logging, err = flogging.New(flogging.Config{})
    46  	require.NoError(t, err)
    47  	require.Equal(t, zapcore.InfoLevel, logging.DefaultLevel())
    48  }
    49  
    50  //go:generate counterfeiter -o mock/write_syncer.go -fake-name WriteSyncer . writeSyncer
    51  type writeSyncer interface {
    52  	zapcore.WriteSyncer
    53  }
    54  
    55  func TestLoggingSetWriter(t *testing.T) {
    56  	ws := &mock.WriteSyncer{}
    57  
    58  	w := &bytes.Buffer{}
    59  	logging, err := flogging.New(flogging.Config{
    60  		Writer: w,
    61  	})
    62  	require.NoError(t, err)
    63  
    64  	old := logging.SetWriter(ws)
    65  	logging.SetWriter(w)
    66  	original := logging.SetWriter(ws)
    67  
    68  	require.Exactly(t, old, original)
    69  	_, err = logging.Write([]byte("hello"))
    70  	require.NoError(t, err)
    71  	require.Equal(t, 1, ws.WriteCallCount())
    72  	require.Equal(t, []byte("hello"), ws.WriteArgsForCall(0))
    73  
    74  	err = logging.Sync()
    75  	require.NoError(t, err)
    76  
    77  	ws.SyncReturns(errors.New("welp"))
    78  	err = logging.Sync()
    79  	require.EqualError(t, err, "welp")
    80  }
    81  
    82  func TestNamedLogger(t *testing.T) {
    83  	defer flogging.Reset()
    84  	buf := &bytes.Buffer{}
    85  	flogging.Global.SetWriter(buf)
    86  
    87  	t.Run("logger and named (child) logger with different levels", func(t *testing.T) {
    88  		defer buf.Reset()
    89  		logger := flogging.MustGetLogger("eugene")
    90  		logger2 := logger.Named("george")
    91  		flogging.ActivateSpec("eugene=info:eugene.george=error")
    92  
    93  		logger.Info("from eugene")
    94  		logger2.Info("from george")
    95  		require.Contains(t, buf.String(), "from eugene")
    96  		require.NotContains(t, buf.String(), "from george")
    97  	})
    98  
    99  	t.Run("named logger where parent logger isn't enabled", func(t *testing.T) {
   100  		logger := flogging.MustGetLogger("foo")
   101  		logger2 := logger.Named("bar")
   102  		flogging.ActivateSpec("foo=fatal:foo.bar=error")
   103  		logger.Error("from foo")
   104  		logger2.Error("from bar")
   105  		require.NotContains(t, buf.String(), "from foo")
   106  		require.Contains(t, buf.String(), "from bar")
   107  	})
   108  }
   109  
   110  func TestInvalidLoggerName(t *testing.T) {
   111  	names := []string{"test*", ".test", "test.", ".", ""}
   112  	for _, name := range names {
   113  		t.Run(name, func(t *testing.T) {
   114  			msg := fmt.Sprintf("invalid logger name: %s", name)
   115  			require.PanicsWithValue(t, msg, func() { flogging.MustGetLogger(name) })
   116  		})
   117  	}
   118  }
   119  
   120  func TestCheck(t *testing.T) {
   121  	l := &flogging.Logging{}
   122  	observer := &mock.Observer{}
   123  	e := zapcore.Entry{}
   124  
   125  	// set observer
   126  	l.SetObserver(observer)
   127  	l.Check(e, nil)
   128  	require.Equal(t, 1, observer.CheckCallCount())
   129  	e, ce := observer.CheckArgsForCall(0)
   130  	require.Equal(t, e, zapcore.Entry{})
   131  	require.Nil(t, ce)
   132  
   133  	l.WriteEntry(e, nil)
   134  	require.Equal(t, 1, observer.WriteEntryCallCount())
   135  	e, f := observer.WriteEntryArgsForCall(0)
   136  	require.Equal(t, e, zapcore.Entry{})
   137  	require.Nil(t, f)
   138  
   139  	//	remove observer
   140  	l.SetObserver(nil)
   141  	l.Check(zapcore.Entry{}, nil)
   142  	require.Equal(t, 1, observer.CheckCallCount())
   143  }
   144  
   145  func TestLoggerCoreCheck(t *testing.T) {
   146  	logging, err := flogging.New(flogging.Config{})
   147  	require.NoError(t, err)
   148  
   149  	logger := logging.ZapLogger("foo")
   150  
   151  	err = logging.ActivateSpec("info")
   152  	require.NoError(t, err)
   153  	require.False(t, logger.Core().Enabled(zapcore.DebugLevel), "debug should not be enabled at info level")
   154  
   155  	err = logging.ActivateSpec("debug")
   156  	require.NoError(t, err)
   157  	require.True(t, logger.Core().Enabled(zapcore.DebugLevel), "debug should now be enabled at debug level")
   158  }