github.com/livekit/protocol@v1.39.3/logger/zaputil/deferrer_test.go (about)

     1  // Copyright 2023 LiveKit, Inc.
     2  //
     3  // Licensed under the Apache License, Version 2.0 (the "License");
     4  // you may not use this file except in compliance with the License.
     5  // You may obtain a copy of the License at
     6  //
     7  //     http://www.apache.org/licenses/LICENSE-2.0
     8  //
     9  // Unless required by applicable law or agreed to in writing, software
    10  // distributed under the License is distributed on an "AS IS" BASIS,
    11  // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    12  // See the License for the specific language governing permissions and
    13  // limitations under the License.
    14  
    15  package zaputil
    16  
    17  import (
    18  	"testing"
    19  
    20  	"github.com/stretchr/testify/require"
    21  	"go.uber.org/zap"
    22  	"go.uber.org/zap/zapcore"
    23  
    24  	"github.com/livekit/protocol/logger/testutil"
    25  )
    26  
    27  func TestDeferredLogger(t *testing.T) {
    28  	t.Run("logs are deferred until logger resolves", func(t *testing.T) {
    29  		c := &testCore{Core: zap.NewExample().Core()}
    30  		d := &Deferrer{}
    31  		dc := NewDeferredValueCore(c, d)
    32  		s := zap.New(dc).Sugar()
    33  
    34  		s.Infow("test")
    35  		require.Equal(t, 0, c.WriteCount())
    36  
    37  		s.With("a", "1").Infow("test")
    38  		require.Equal(t, 0, c.WriteCount())
    39  
    40  		d.Resolve("b", "2")
    41  		require.Equal(t, 2, c.WriteCount())
    42  
    43  		s.With("c", "3").Infow("test")
    44  		require.Equal(t, 3, c.WriteCount())
    45  	})
    46  
    47  	type testLog struct {
    48  		A, B string
    49  	}
    50  
    51  	t.Run("resolved values can be overwritten", func(t *testing.T) {
    52  		ws := &testutil.BufferedWriteSyncer{}
    53  		we := NewWriteEnabler(ws, zapcore.DebugLevel)
    54  		enc := zapcore.NewJSONEncoder(zap.NewProductionEncoderConfig())
    55  		c := NewEncoderCore(enc, we)
    56  		d := &Deferrer{}
    57  		dc := NewDeferredValueCore(c, d)
    58  		s := zap.New(dc).Sugar()
    59  
    60  		cases := []testLog{
    61  			{"foo", "bar"},
    62  			{"baz", "qux"},
    63  		}
    64  		for _, c := range cases {
    65  			d.Resolve("a", c.A, "b", c.B)
    66  			s.Infow("test")
    67  			s.Sync()
    68  
    69  			var log testLog
    70  			require.NoError(t, ws.Unmarshal(&log))
    71  			ws.Reset()
    72  
    73  			require.Equal(t, c.A, log.A)
    74  			require.Equal(t, c.B, log.B)
    75  		}
    76  	})
    77  
    78  	t.Run("resolved values merge with previous resolutions", func(t *testing.T) {
    79  		ws := &testutil.BufferedWriteSyncer{}
    80  		we := NewWriteEnabler(ws, zapcore.DebugLevel)
    81  		enc := zapcore.NewJSONEncoder(zap.NewProductionEncoderConfig())
    82  		c := NewEncoderCore(enc, we)
    83  		d := &Deferrer{}
    84  		dc := NewDeferredValueCore(c, d)
    85  		s := zap.New(dc).Sugar()
    86  
    87  		d.Resolve("a", "foo")
    88  		d.Resolve("b", "bar")
    89  		s.Infow("test")
    90  		s.Sync()
    91  
    92  		var log testLog
    93  		require.NoError(t, ws.Unmarshal(&log))
    94  		ws.Reset()
    95  
    96  		require.Equal(t, "foo", log.A)
    97  		require.Equal(t, "bar", log.B)
    98  	})
    99  
   100  	t.Run("re-resolve", func(t *testing.T) {
   101  		ws := &testutil.BufferedWriteSyncer{}
   102  		we := NewWriteEnabler(ws, zapcore.DebugLevel)
   103  		enc := zapcore.NewJSONEncoder(zap.NewProductionEncoderConfig())
   104  		c := NewEncoderCore(enc, we)
   105  		d := &Deferrer{}
   106  		dc := NewDeferredValueCore(c, d)
   107  		s := zap.New(dc).Sugar()
   108  
   109  		d.Resolve("a", "foo")
   110  		d.Resolve("b", "bar")
   111  		s.Infow("test")
   112  		s.Sync()
   113  
   114  		var log testLog
   115  		require.NoError(t, ws.Unmarshal(&log))
   116  		ws.Reset()
   117  
   118  		require.Equal(t, "foo", log.A)
   119  		require.Equal(t, "bar", log.B)
   120  
   121  		d.Reset()
   122  		d.Resolve("a", "car")
   123  		d.Resolve("b", "dog")
   124  		s.Infow("test")
   125  		s.Sync()
   126  
   127  		require.NoError(t, ws.Unmarshal(&log))
   128  		ws.Reset()
   129  
   130  		require.Equal(t, "car", log.A)
   131  		require.Equal(t, "dog", log.B)
   132  	})
   133  }