diff --git a/abci/client/socket_client_test.go b/abci/client/socket_client_test.go index a3469ddd1..ae060cead 100644 --- a/abci/client/socket_client_test.go +++ b/abci/client/socket_client_test.go @@ -23,7 +23,7 @@ func TestProperSyncCalls(t *testing.T) { defer cancel() app := slowApp{} - logger := log.TestingLogger() + logger := log.NewTestingLogger(t) _, c := setupClientServer(ctx, t, logger, app) diff --git a/abci/example/example_test.go b/abci/example/example_test.go index f32d9df7c..798fe3b0e 100644 --- a/abci/example/example_test.go +++ b/abci/example/example_test.go @@ -32,34 +32,38 @@ func init() { func TestKVStore(t *testing.T) { ctx, cancel := context.WithCancel(context.Background()) defer cancel() + logger := log.NewTestingLogger(t) - fmt.Println("### Testing KVStore") - testStream(ctx, t, kvstore.NewApplication()) + logger.Info("### Testing KVStore") + testStream(ctx, t, logger, kvstore.NewApplication()) } func TestBaseApp(t *testing.T) { ctx, cancel := context.WithCancel(context.Background()) defer cancel() - fmt.Println("### Testing BaseApp") - testStream(ctx, t, types.NewBaseApplication()) + logger := log.NewTestingLogger(t) + + logger.Info("### Testing BaseApp") + testStream(ctx, t, logger, types.NewBaseApplication()) } func TestGRPC(t *testing.T) { ctx, cancel := context.WithCancel(context.Background()) defer cancel() - fmt.Println("### Testing GRPC") - testGRPCSync(ctx, t, types.NewGRPCApplication(types.NewBaseApplication())) + logger := log.NewTestingLogger(t) + + logger.Info("### Testing GRPC") + testGRPCSync(ctx, t, logger, types.NewGRPCApplication(types.NewBaseApplication())) } -func testStream(ctx context.Context, t *testing.T, app types.Application) { +func testStream(ctx context.Context, t *testing.T, logger log.Logger, app types.Application) { t.Helper() const numDeliverTxs = 20000 socketFile := fmt.Sprintf("test-%08x.sock", rand.Int31n(1<<30)) defer os.Remove(socketFile) socket := fmt.Sprintf("unix://%v", socketFile) - logger := log.TestingLogger() // Start the listener server := abciserver.NewSocketServer(logger.With("module", "abci-server"), socket, app) t.Cleanup(server.Wait) @@ -67,7 +71,7 @@ func testStream(ctx context.Context, t *testing.T, app types.Application) { require.NoError(t, err) // Connect to the socket - client := abciclient.NewSocketClient(log.TestingLogger().With("module", "abci-client"), socket, false) + client := abciclient.NewSocketClient(logger.With("module", "abci-client"), socket, false) t.Cleanup(client.Wait) err = client.Start(ctx) @@ -127,12 +131,12 @@ func dialerFunc(ctx context.Context, addr string) (net.Conn, error) { return tmnet.Connect(addr) } -func testGRPCSync(ctx context.Context, t *testing.T, app types.ABCIApplicationServer) { +func testGRPCSync(ctx context.Context, t *testing.T, logger log.Logger, app types.ABCIApplicationServer) { numDeliverTxs := 2000 socketFile := fmt.Sprintf("/tmp/test-%08x.sock", rand.Int31n(1<<30)) defer os.Remove(socketFile) socket := fmt.Sprintf("unix://%v", socketFile) - logger := log.TestingLogger() + // Start the listener server := abciserver.NewGRPCServer(logger.With("module", "abci-server"), socket, app) diff --git a/abci/example/kvstore/kvstore_test.go b/abci/example/kvstore/kvstore_test.go index 664e628b0..f3640f731 100644 --- a/abci/example/kvstore/kvstore_test.go +++ b/abci/example/kvstore/kvstore_test.go @@ -289,7 +289,7 @@ func makeGRPCClientServer( func TestClientServer(t *testing.T) { ctx, cancel := context.WithCancel(context.Background()) defer cancel() - logger := log.TestingLogger() + logger := log.NewTestingLogger(t) // set up socket app kvstore := NewApplication() diff --git a/abci/tests/client_server_test.go b/abci/tests/client_server_test.go index 2dfa68c63..2581714e8 100644 --- a/abci/tests/client_server_test.go +++ b/abci/tests/client_server_test.go @@ -21,7 +21,7 @@ func TestClientServerNoAddrPrefix(t *testing.T) { transport = "socket" ) app := kvstore.NewApplication() - logger := log.TestingLogger() + logger := log.NewTestingLogger(t) server, err := abciserver.NewServer(logger, addr, transport, app) assert.NoError(t, err, "expected no error on NewServer") diff --git a/libs/events/event_cache_test.go b/libs/events/event_cache_test.go index 358e53a7b..fb36fa674 100644 --- a/libs/events/event_cache_test.go +++ b/libs/events/event_cache_test.go @@ -13,7 +13,8 @@ func TestEventCache_Flush(t *testing.T) { ctx, cancel := context.WithCancel(context.Background()) defer cancel() - evsw := NewEventSwitch(log.TestingLogger()) + logger := log.NewTestingLogger(t) + evsw := NewEventSwitch(logger) err := evsw.Start(ctx) require.NoError(t, err) diff --git a/libs/events/events_test.go b/libs/events/events_test.go index 288303acc..6d0c8b4e7 100644 --- a/libs/events/events_test.go +++ b/libs/events/events_test.go @@ -19,7 +19,9 @@ func TestAddListenerForEventFireOnce(t *testing.T) { ctx, cancel := context.WithCancel(context.Background()) defer cancel() - evsw := NewEventSwitch(log.TestingLogger()) + logger := log.NewTestingLogger(t) + + evsw := NewEventSwitch(logger) require.NoError(t, evsw.Start(ctx)) t.Cleanup(evsw.Wait) @@ -48,7 +50,9 @@ func TestAddListenerForEventFireMany(t *testing.T) { ctx, cancel := context.WithCancel(context.Background()) defer cancel() - evsw := NewEventSwitch(log.TestingLogger()) + logger := log.NewTestingLogger(t) + + evsw := NewEventSwitch(logger) require.NoError(t, evsw.Start(ctx)) t.Cleanup(evsw.Wait) @@ -84,7 +88,9 @@ func TestAddListenerForDifferentEvents(t *testing.T) { ctx, cancel := context.WithCancel(context.Background()) defer cancel() - evsw := NewEventSwitch(log.TestingLogger()) + logger := log.NewTestingLogger(t) + + evsw := NewEventSwitch(logger) require.NoError(t, evsw.Start(ctx)) t.Cleanup(evsw.Wait) @@ -146,7 +152,8 @@ func TestAddDifferentListenerForDifferentEvents(t *testing.T) { ctx, cancel := context.WithCancel(context.Background()) defer cancel() - evsw := NewEventSwitch(log.TestingLogger()) + logger := log.NewTestingLogger(t) + evsw := NewEventSwitch(logger) require.NoError(t, evsw.Start(ctx)) t.Cleanup(evsw.Wait) @@ -236,7 +243,9 @@ func TestAddAndRemoveListenerConcurrency(t *testing.T) { ctx, cancel := context.WithCancel(context.Background()) defer cancel() - evsw := NewEventSwitch(log.TestingLogger()) + logger := log.NewTestingLogger(t) + + evsw := NewEventSwitch(logger) require.NoError(t, evsw.Start(ctx)) t.Cleanup(evsw.Wait) @@ -285,7 +294,8 @@ func TestAddAndRemoveListener(t *testing.T) { ctx, cancel := context.WithCancel(context.Background()) defer cancel() - evsw := NewEventSwitch(log.TestingLogger()) + logger := log.NewTestingLogger(t) + evsw := NewEventSwitch(logger) require.NoError(t, evsw.Start(ctx)) t.Cleanup(evsw.Wait) @@ -341,7 +351,10 @@ func TestAddAndRemoveListener(t *testing.T) { func TestRemoveListener(t *testing.T) { ctx, cancel := context.WithCancel(context.Background()) defer cancel() - evsw := NewEventSwitch(log.TestingLogger()) + + logger := log.NewTestingLogger(t) + + evsw := NewEventSwitch(logger) require.NoError(t, evsw.Start(ctx)) t.Cleanup(evsw.Wait) @@ -398,7 +411,9 @@ func TestRemoveListener(t *testing.T) { func TestRemoveListenersAsync(t *testing.T) { ctx, cancel := context.WithCancel(context.Background()) defer cancel() - evsw := NewEventSwitch(log.TestingLogger()) + logger := log.NewTestingLogger(t) + + evsw := NewEventSwitch(logger) require.NoError(t, evsw.Start(ctx)) t.Cleanup(evsw.Wait) diff --git a/libs/service/service_test.go b/libs/service/service_test.go index 254491cae..fcc727fcc 100644 --- a/libs/service/service_test.go +++ b/libs/service/service_test.go @@ -22,8 +22,10 @@ func TestBaseServiceWait(t *testing.T) { ctx, cancel := context.WithCancel(context.Background()) defer cancel() + logger := log.NewTestingLogger(t) + ts := &testService{} - ts.BaseService = *NewBaseService(log.TestingLogger(), "TestService", ts) + ts.BaseService = *NewBaseService(logger, "TestService", ts) err := ts.Start(ctx) require.NoError(t, err) diff --git a/light/client_benchmark_test.go b/light/client_benchmark_test.go index 04ea6d1fc..ff0d51fee 100644 --- a/light/client_benchmark_test.go +++ b/light/client_benchmark_test.go @@ -65,6 +65,8 @@ func BenchmarkSequence(b *testing.B) { benchmarkFullNode := newProviderBenchmarkImpl(headers, vals) genesisBlock, _ := benchmarkFullNode.LightBlock(context.Background(), 1) + logger := log.NewTestingLogger(b) + c, err := light.NewClient( context.Background(), chainID, @@ -76,7 +78,7 @@ func BenchmarkSequence(b *testing.B) { benchmarkFullNode, []provider.Provider{benchmarkFullNode}, dbs.New(dbm.NewMemDB()), - light.Logger(log.TestingLogger()), + light.Logger(logger), light.SequentialVerification(), ) if err != nil { @@ -97,6 +99,8 @@ func BenchmarkBisection(b *testing.B) { benchmarkFullNode := newProviderBenchmarkImpl(headers, vals) genesisBlock, _ := benchmarkFullNode.LightBlock(context.Background(), 1) + logger := log.NewTestingLogger(b) + c, err := light.NewClient( context.Background(), chainID, @@ -108,7 +112,7 @@ func BenchmarkBisection(b *testing.B) { benchmarkFullNode, []provider.Provider{benchmarkFullNode}, dbs.New(dbm.NewMemDB()), - light.Logger(log.TestingLogger()), + light.Logger(logger), ) if err != nil { b.Fatal(err) @@ -124,12 +128,17 @@ func BenchmarkBisection(b *testing.B) { } func BenchmarkBackwards(b *testing.B) { + ctx, cancel := context.WithCancel(context.Background()) + defer cancel() + headers, vals, _ := genLightBlocksWithKeys(chainID, 1000, 100, 1, bTime) benchmarkFullNode := newProviderBenchmarkImpl(headers, vals) - trustedBlock, _ := benchmarkFullNode.LightBlock(context.Background(), 0) + trustedBlock, _ := benchmarkFullNode.LightBlock(ctx, 0) + + logger := log.NewTestingLogger(b) c, err := light.NewClient( - context.Background(), + ctx, chainID, light.TrustOptions{ Period: 24 * time.Hour, @@ -139,7 +148,7 @@ func BenchmarkBackwards(b *testing.B) { benchmarkFullNode, []provider.Provider{benchmarkFullNode}, dbs.New(dbm.NewMemDB()), - light.Logger(log.TestingLogger()), + light.Logger(logger), ) if err != nil { b.Fatal(err) @@ -147,7 +156,7 @@ func BenchmarkBackwards(b *testing.B) { b.ResetTimer() for n := 0; n < b.N; n++ { - _, err = c.VerifyLightBlockAtHeight(context.Background(), 1, bTime) + _, err = c.VerifyLightBlockAtHeight(ctx, 1, bTime) if err != nil { b.Fatal(err) } diff --git a/light/client_test.go b/light/client_test.go index 5b97d3394..5b6fe5518 100644 --- a/light/client_test.go +++ b/light/client_test.go @@ -209,6 +209,8 @@ func TestClient_SequentialVerification(t *testing.T) { for _, tc := range testCases { testCase := tc t.Run(testCase.name, func(t *testing.T) { + logger := log.NewTestingLogger(t) + mockNode := mockNodeFromHeadersAndVals(testCase.otherHeaders, testCase.vals) mockNode.On("LightBlock", mock.Anything, mock.Anything).Return(nil, provider.ErrLightBlockNotFound) c, err := light.NewClient( @@ -219,7 +221,7 @@ func TestClient_SequentialVerification(t *testing.T) { []provider.Provider{mockNode}, dbs.New(dbm.NewMemDB()), light.SequentialVerification(), - light.Logger(log.TestingLogger()), + light.Logger(logger), ) if testCase.initErr { @@ -329,6 +331,8 @@ func TestClient_SkippingVerification(t *testing.T) { for _, tc := range testCases { tc := tc t.Run(tc.name, func(t *testing.T) { + logger := log.NewTestingLogger(t) + mockNode := mockNodeFromHeadersAndVals(tc.otherHeaders, tc.vals) mockNode.On("LightBlock", mock.Anything, mock.Anything).Return(nil, provider.ErrLightBlockNotFound) c, err := light.NewClient( @@ -339,7 +343,7 @@ func TestClient_SkippingVerification(t *testing.T) { []provider.Provider{mockNode}, dbs.New(dbm.NewMemDB()), light.SkippingVerification(light.DefaultTrustLevel), - light.Logger(log.TestingLogger()), + light.Logger(logger), ) if tc.initErr { require.Error(t, err) @@ -436,6 +440,8 @@ func TestClientBisectionBetweenTrustedHeaders(t *testing.T) { } func TestClient_Cleanup(t *testing.T) { + logger := log.NewTestingLogger(t) + mockFullNode := &provider_mocks.Provider{} mockFullNode.On("LightBlock", mock.Anything, int64(1)).Return(l1, nil) c, err := light.NewClient( @@ -445,7 +451,7 @@ func TestClient_Cleanup(t *testing.T) { mockFullNode, []provider.Provider{mockFullNode}, dbs.New(dbm.NewMemDB()), - light.Logger(log.TestingLogger()), + light.Logger(logger), ) require.NoError(t, err) _, err = c.TrustedLightBlock(1) @@ -465,6 +471,8 @@ func TestClient_Cleanup(t *testing.T) { func TestClientRestoresTrustedHeaderAfterStartup(t *testing.T) { // 1. options.Hash == trustedHeader.Hash t.Run("hashes should match", func(t *testing.T) { + logger := log.NewTestingLogger(t) + mockNode := &provider_mocks.Provider{} trustedStore := dbs.New(dbm.NewMemDB()) err := trustedStore.SaveLightBlock(l1) @@ -477,7 +485,7 @@ func TestClientRestoresTrustedHeaderAfterStartup(t *testing.T) { mockNode, []provider.Provider{mockNode}, trustedStore, - light.Logger(log.TestingLogger()), + light.Logger(logger), ) require.NoError(t, err) @@ -495,6 +503,8 @@ func TestClientRestoresTrustedHeaderAfterStartup(t *testing.T) { err := trustedStore.SaveLightBlock(l1) require.NoError(t, err) + logger := log.NewTestingLogger(t) + // header1 != h1 header1 := keys.GenSignedHeader(chainID, 1, bTime.Add(1*time.Hour), nil, vals, vals, hash("app_hash"), hash("cons_hash"), hash("results_hash"), 0, len(keys)) @@ -511,7 +521,7 @@ func TestClientRestoresTrustedHeaderAfterStartup(t *testing.T) { mockNode, []provider.Provider{mockNode}, trustedStore, - light.Logger(log.TestingLogger()), + light.Logger(logger), ) require.NoError(t, err) @@ -531,6 +541,9 @@ func TestClient_Update(t *testing.T) { mockFullNode.On("LightBlock", mock.Anything, int64(0)).Return(l3, nil) mockFullNode.On("LightBlock", mock.Anything, int64(1)).Return(l1, nil) mockFullNode.On("LightBlock", mock.Anything, int64(3)).Return(l3, nil) + + logger := log.NewTestingLogger(t) + c, err := light.NewClient( ctx, chainID, @@ -538,7 +551,7 @@ func TestClient_Update(t *testing.T) { mockFullNode, []provider.Provider{mockFullNode}, dbs.New(dbm.NewMemDB()), - light.Logger(log.TestingLogger()), + light.Logger(logger), ) require.NoError(t, err) @@ -553,6 +566,8 @@ func TestClient_Update(t *testing.T) { } func TestClient_Concurrency(t *testing.T) { + logger := log.NewTestingLogger(t) + mockFullNode := &provider_mocks.Provider{} mockFullNode.On("LightBlock", mock.Anything, int64(2)).Return(l2, nil) mockFullNode.On("LightBlock", mock.Anything, int64(1)).Return(l1, nil) @@ -563,7 +578,7 @@ func TestClient_Concurrency(t *testing.T) { mockFullNode, []provider.Provider{mockFullNode}, dbs.New(dbm.NewMemDB()), - light.Logger(log.TestingLogger()), + light.Logger(logger), ) require.NoError(t, err) @@ -602,6 +617,8 @@ func TestClient_AddProviders(t *testing.T) { 1: h1, 2: h2, }, valSet) + logger := log.NewTestingLogger(t) + c, err := light.NewClient( ctx, chainID, @@ -609,7 +626,7 @@ func TestClient_AddProviders(t *testing.T) { mockFullNode, []provider.Provider{mockFullNode}, dbs.New(dbm.NewMemDB()), - light.Logger(log.TestingLogger()), + light.Logger(logger), ) require.NoError(t, err) @@ -638,6 +655,9 @@ func TestClientReplacesPrimaryWithWitnessIfPrimaryIsUnavailable(t *testing.T) { mockDeadNode := &provider_mocks.Provider{} mockDeadNode.On("LightBlock", mock.Anything, mock.Anything).Return(nil, provider.ErrNoResponse) + + logger := log.NewTestingLogger(t) + c, err := light.NewClient( ctx, chainID, @@ -645,7 +665,7 @@ func TestClientReplacesPrimaryWithWitnessIfPrimaryIsUnavailable(t *testing.T) { mockDeadNode, []provider.Provider{mockDeadNode, mockFullNode}, dbs.New(dbm.NewMemDB()), - light.Logger(log.TestingLogger()), + light.Logger(logger), ) require.NoError(t, err) @@ -666,6 +686,8 @@ func TestClientReplacesPrimaryWithWitnessIfPrimaryDoesntHaveBlock(t *testing.T) mockFullNode := &provider_mocks.Provider{} mockFullNode.On("LightBlock", mock.Anything, mock.Anything).Return(l1, nil) + logger := log.NewTestingLogger(t) + mockDeadNode := &provider_mocks.Provider{} mockDeadNode.On("LightBlock", mock.Anything, mock.Anything).Return(nil, provider.ErrLightBlockNotFound) c, err := light.NewClient( @@ -675,7 +697,7 @@ func TestClientReplacesPrimaryWithWitnessIfPrimaryDoesntHaveBlock(t *testing.T) mockDeadNode, []provider.Provider{mockDeadNode, mockFullNode}, dbs.New(dbm.NewMemDB()), - light.Logger(log.TestingLogger()), + light.Logger(logger), ) require.NoError(t, err) _, err = c.Update(ctx, bTime.Add(2*time.Hour)) @@ -689,6 +711,8 @@ func TestClientReplacesPrimaryWithWitnessIfPrimaryDoesntHaveBlock(t *testing.T) } func TestClient_BackwardsVerification(t *testing.T) { + logger := log.NewTestingLogger(t) + { headers, vals, _ := genLightBlocksWithKeys(chainID, 9, 3, 0, bTime) delete(headers, 1) @@ -709,7 +733,7 @@ func TestClient_BackwardsVerification(t *testing.T) { mockLargeFullNode, []provider.Provider{mockLargeFullNode}, dbs.New(dbm.NewMemDB()), - light.Logger(log.TestingLogger()), + light.Logger(logger), ) require.NoError(t, err) @@ -768,7 +792,7 @@ func TestClient_BackwardsVerification(t *testing.T) { mockNode, []provider.Provider{mockNode}, dbs.New(dbm.NewMemDB()), - light.Logger(log.TestingLogger()), + light.Logger(logger), ) require.NoError(t, err) @@ -802,6 +826,8 @@ func TestClient_NewClientFromTrustedStore(t *testing.T) { } func TestClientRemovesWitnessIfItSendsUsIncorrectHeader(t *testing.T) { + logger := log.NewTestingLogger(t) + // different headers hash then primary plus less than 1/3 signed (no fork) headers1 := map[int64]*types.SignedHeader{ 1: h1, @@ -840,7 +866,7 @@ func TestClientRemovesWitnessIfItSendsUsIncorrectHeader(t *testing.T) { mockFullNode, []provider.Provider{mockBadNode1, mockBadNode2}, dbs.New(dbm.NewMemDB()), - light.Logger(log.TestingLogger()), + light.Logger(logger), ) // witness should have behaved properly -> no error require.NoError(t, err) @@ -865,6 +891,8 @@ func TestClientRemovesWitnessIfItSendsUsIncorrectHeader(t *testing.T) { } func TestClient_TrustedValidatorSet(t *testing.T) { + logger := log.NewTestingLogger(t) + differentVals, _ := factory.RandValidatorSet(10, 100) mockBadValSetNode := mockNodeFromHeadersAndVals( map[int64]*types.SignedHeader{ @@ -896,7 +924,7 @@ func TestClient_TrustedValidatorSet(t *testing.T) { mockFullNode, []provider.Provider{mockBadValSetNode, mockFullNode}, dbs.New(dbm.NewMemDB()), - light.Logger(log.TestingLogger()), + light.Logger(logger), ) require.NoError(t, err) assert.Equal(t, 2, len(c.Witnesses())) @@ -921,6 +949,8 @@ func TestClientPrunesHeadersAndValidatorSets(t *testing.T) { 0: vals, }) + logger := log.NewTestingLogger(t) + c, err := light.NewClient( ctx, chainID, @@ -928,7 +958,7 @@ func TestClientPrunesHeadersAndValidatorSets(t *testing.T) { mockFullNode, []provider.Provider{mockFullNode}, dbs.New(dbm.NewMemDB()), - light.Logger(log.TestingLogger()), + light.Logger(logger), light.PruningSize(1), ) require.NoError(t, err) diff --git a/light/detector_test.go b/light/detector_test.go index 0bf96ace6..93ba508f4 100644 --- a/light/detector_test.go +++ b/light/detector_test.go @@ -20,6 +20,8 @@ import ( ) func TestLightClientAttackEvidence_Lunatic(t *testing.T) { + logger := log.NewTestingLogger(t) + // primary performs a lunatic attack var ( latestHeight = int64(3) @@ -88,7 +90,7 @@ func TestLightClientAttackEvidence_Lunatic(t *testing.T) { mockPrimary, []provider.Provider{mockWitness}, dbs.New(dbm.NewMemDB()), - light.Logger(log.TestingLogger()), + light.Logger(logger), ) require.NoError(t, err) @@ -131,6 +133,8 @@ func TestLightClientAttackEvidence_Equivocation(t *testing.T) { for _, tc := range cases { testCase := tc t.Run(testCase.name, func(t *testing.T) { + logger := log.NewTestingLogger(t) + // primary performs an equivocation attack var ( valSize = 5 @@ -199,7 +203,7 @@ func TestLightClientAttackEvidence_Equivocation(t *testing.T) { mockPrimary, []provider.Provider{mockWitness}, dbs.New(dbm.NewMemDB()), - light.Logger(log.TestingLogger()), + light.Logger(logger), testCase.lightOption, ) require.NoError(t, err) @@ -228,6 +232,8 @@ func TestLightClientAttackEvidence_ForwardLunatic(t *testing.T) { primaryValidators = make(map[int64]*types.ValidatorSet, forgedHeight) ) + logger := log.NewTestingLogger(t) + witnessHeaders, witnessValidators, chainKeys := genLightBlocksWithKeys(chainID, latestHeight, valSize, 2, bTime) for _, unusedHeader := range []int64{3, 5, 6, 8} { delete(witnessHeaders, unusedHeader) @@ -298,7 +304,7 @@ func TestLightClientAttackEvidence_ForwardLunatic(t *testing.T) { mockPrimary, []provider.Provider{mockWitness, accomplice}, dbs.New(dbm.NewMemDB()), - light.Logger(log.TestingLogger()), + light.Logger(logger), light.MaxClockDrift(1*time.Second), light.MaxBlockLag(1*time.Second), ) @@ -358,7 +364,7 @@ func TestLightClientAttackEvidence_ForwardLunatic(t *testing.T) { mockPrimary, []provider.Provider{mockLaggingWitness, accomplice}, dbs.New(dbm.NewMemDB()), - light.Logger(log.TestingLogger()), + light.Logger(logger), light.MaxClockDrift(1*time.Second), light.MaxBlockLag(1*time.Second), ) @@ -381,6 +387,8 @@ func TestClientDivergentTraces1(t *testing.T) { headers, vals, _ = genLightBlocksWithKeys(chainID, 1, 5, 2, bTime) mockWitness := mockNodeFromHeadersAndVals(headers, vals) + logger := log.NewTestingLogger(t) + _, err = light.NewClient( ctx, chainID, @@ -392,7 +400,7 @@ func TestClientDivergentTraces1(t *testing.T) { mockPrimary, []provider.Provider{mockWitness}, dbs.New(dbm.NewMemDB()), - light.Logger(log.TestingLogger()), + light.Logger(logger), ) require.Error(t, err) assert.Contains(t, err.Error(), "does not match primary") @@ -403,6 +411,8 @@ func TestClientDivergentTraces1(t *testing.T) { // 2. Two out of three nodes don't respond but the third has a header that matches // => verification should be successful and all the witnesses should remain func TestClientDivergentTraces2(t *testing.T) { + logger := log.NewTestingLogger(t) + headers, vals, _ := genLightBlocksWithKeys(chainID, 2, 5, 2, bTime) mockPrimaryNode := mockNodeFromHeadersAndVals(headers, vals) mockDeadNode := &provider_mocks.Provider{} @@ -420,7 +430,7 @@ func TestClientDivergentTraces2(t *testing.T) { mockPrimaryNode, []provider.Provider{mockDeadNode, mockDeadNode, mockPrimaryNode}, dbs.New(dbm.NewMemDB()), - light.Logger(log.TestingLogger()), + light.Logger(logger), ) require.NoError(t, err) @@ -435,6 +445,8 @@ func TestClientDivergentTraces2(t *testing.T) { // => creation should succeed, but the verification should fail //nolint: dupl func TestClientDivergentTraces3(t *testing.T) { + logger := log.NewTestingLogger(t) + // primaryHeaders, primaryVals, _ := genLightBlocksWithKeys(chainID, 2, 5, 2, bTime) mockPrimary := mockNodeFromHeadersAndVals(primaryHeaders, primaryVals) @@ -458,7 +470,7 @@ func TestClientDivergentTraces3(t *testing.T) { mockPrimary, []provider.Provider{mockWitness}, dbs.New(dbm.NewMemDB()), - light.Logger(log.TestingLogger()), + light.Logger(logger), ) require.NoError(t, err) @@ -473,6 +485,8 @@ func TestClientDivergentTraces3(t *testing.T) { // It should be ignored //nolint: dupl func TestClientDivergentTraces4(t *testing.T) { + logger := log.NewTestingLogger(t) + // primaryHeaders, primaryVals, _ := genLightBlocksWithKeys(chainID, 2, 5, 2, bTime) mockPrimary := mockNodeFromHeadersAndVals(primaryHeaders, primaryVals) @@ -496,7 +510,7 @@ func TestClientDivergentTraces4(t *testing.T) { mockPrimary, []provider.Provider{mockWitness}, dbs.New(dbm.NewMemDB()), - light.Logger(log.TestingLogger()), + light.Logger(logger), ) require.NoError(t, err) diff --git a/light/example_test.go b/light/example_test.go index 1291670e2..e0fe09fb0 100644 --- a/light/example_test.go +++ b/light/example_test.go @@ -26,7 +26,10 @@ func ExampleClient() { stdlog.Fatal(err) } - logger := log.TestingLogger() + logger, err := log.NewDefaultLogger(log.LogFormatPlain, log.LogLevelInfo, false) + if err != nil { + stdlog.Fatal(err) + } // Start a test application app := kvstore.NewApplication() diff --git a/light/light_test.go b/light/light_test.go index d88891fe9..49a69ae47 100644 --- a/light/light_test.go +++ b/light/light_test.go @@ -31,6 +31,8 @@ func TestClientIntegration_Update(t *testing.T) { conf, err := rpctest.CreateConfig(t.Name()) require.NoError(t, err) + logger := log.NewTestingLogger(t) + // Start a test application app := kvstore.NewApplication() _, closer, err := rpctest.StartTendermint(ctx, conf, app, rpctest.SuppressStdout) @@ -67,7 +69,7 @@ func TestClientIntegration_Update(t *testing.T) { primary, []provider.Provider{primary}, // NOTE: primary should not be used here dbs.New(db), - light.Logger(log.TestingLogger()), + light.Logger(logger), ) require.NoError(t, err) @@ -92,6 +94,8 @@ func TestClientIntegration_VerifyLightBlockAtHeight(t *testing.T) { conf, err := rpctest.CreateConfig(t.Name()) require.NoError(t, err) + logger := log.NewTestingLogger(t) + // Start a test application app := kvstore.NewApplication() @@ -125,7 +129,7 @@ func TestClientIntegration_VerifyLightBlockAtHeight(t *testing.T) { primary, []provider.Provider{primary}, // NOTE: primary should not be used here dbs.New(db), - light.Logger(log.TestingLogger()), + light.Logger(logger), ) require.NoError(t, err) diff --git a/node/node_test.go b/node/node_test.go index 7e4bd8119..9a6750b61 100644 --- a/node/node_test.go +++ b/node/node_test.go @@ -46,8 +46,9 @@ func TestNodeStartStop(t *testing.T) { ctx, bcancel := context.WithCancel(context.Background()) defer bcancel() + logger := log.NewTestingLogger(t) // create & start node - ns, err := newDefaultNode(ctx, cfg, log.TestingLogger()) + ns, err := newDefaultNode(ctx, cfg, logger) require.NoError(t, err) n, ok := ns.(*nodeImpl) @@ -110,8 +111,10 @@ func TestNodeDelayedStart(t *testing.T) { ctx, cancel := context.WithCancel(context.Background()) defer cancel() + logger := log.NewTestingLogger(t) + // create & start node - n := getTestNode(ctx, t, cfg, log.TestingLogger()) + n := getTestNode(ctx, t, cfg, logger) n.GenesisDoc().GenesisTime = now.Add(2 * time.Second) require.NoError(t, n.Start(ctx)) @@ -128,8 +131,10 @@ func TestNodeSetAppVersion(t *testing.T) { ctx, cancel := context.WithCancel(context.Background()) defer cancel() + logger := log.NewTestingLogger(t) + // create node - n := getTestNode(ctx, t, cfg, log.TestingLogger()) + n := getTestNode(ctx, t, cfg, logger) // default config uses the kvstore app appVersion := kvstore.ProtocolVersion @@ -149,16 +154,15 @@ func TestNodeSetPrivValTCP(t *testing.T) { ctx, cancel := context.WithCancel(context.Background()) defer cancel() + logger := log.NewTestingLogger(t) + cfg, err := config.ResetTestRoot("node_priv_val_tcp_test") require.NoError(t, err) defer os.RemoveAll(cfg.RootDir) cfg.PrivValidator.ListenAddr = addr dialer := privval.DialTCPFn(addr, 100*time.Millisecond, ed25519.GenPrivKey()) - dialerEndpoint := privval.NewSignerDialerEndpoint( - log.TestingLogger(), - dialer, - ) + dialerEndpoint := privval.NewSignerDialerEndpoint(logger, dialer) privval.SignerDialerEndpointTimeoutReadWrite(100 * time.Millisecond)(dialerEndpoint) signerServer := privval.NewSignerServer( @@ -175,7 +179,7 @@ func TestNodeSetPrivValTCP(t *testing.T) { }() defer signerServer.Stop() //nolint:errcheck // ignore for tests - n := getTestNode(ctx, t, cfg, log.TestingLogger()) + n := getTestNode(ctx, t, cfg, logger) assert.IsType(t, &privval.RetrySignerClient{}, n.PrivValidator()) } @@ -190,7 +194,10 @@ func TestPrivValidatorListenAddrNoProtocol(t *testing.T) { require.NoError(t, err) defer os.RemoveAll(cfg.RootDir) cfg.PrivValidator.ListenAddr = addrNoPrefix - n, err := newDefaultNode(ctx, cfg, log.TestingLogger()) + + logger := log.NewTestingLogger(t) + + n, err := newDefaultNode(ctx, cfg, logger) assert.Error(t, err) @@ -212,11 +219,11 @@ func TestNodeSetPrivValIPC(t *testing.T) { defer os.RemoveAll(cfg.RootDir) cfg.PrivValidator.ListenAddr = "unix://" + tmpfile + logger := log.NewTestingLogger(t) + dialer := privval.DialUnixFn(tmpfile) - dialerEndpoint := privval.NewSignerDialerEndpoint( - log.TestingLogger(), - dialer, - ) + dialerEndpoint := privval.NewSignerDialerEndpoint(logger, dialer) + privval.SignerDialerEndpointTimeoutReadWrite(100 * time.Millisecond)(dialerEndpoint) pvsc := privval.NewSignerServer( @@ -230,7 +237,7 @@ func TestNodeSetPrivValIPC(t *testing.T) { require.NoError(t, err) }() defer pvsc.Stop() //nolint:errcheck // ignore for tests - n := getTestNode(ctx, t, cfg, log.TestingLogger()) + n := getTestNode(ctx, t, cfg, logger) assert.IsType(t, &privval.RetrySignerClient{}, n.PrivValidator()) } @@ -253,13 +260,13 @@ func TestCreateProposalBlock(t *testing.T) { require.NoError(t, err) defer os.RemoveAll(cfg.RootDir) + logger := log.NewTestingLogger(t) + cc := abciclient.NewLocalCreator(kvstore.NewApplication()) - proxyApp := proxy.NewAppConns(cc, log.TestingLogger(), proxy.NopMetrics()) + proxyApp := proxy.NewAppConns(cc, logger, proxy.NopMetrics()) err = proxyApp.Start(ctx) require.Nil(t, err) - logger := log.TestingLogger() - const height int64 = 1 state, stateDB, privVals := state(t, 1, height) stateStore := sm.NewStore(stateDB) @@ -348,13 +355,14 @@ func TestMaxTxsProposalBlockSize(t *testing.T) { require.NoError(t, err) defer os.RemoveAll(cfg.RootDir) + + logger := log.NewTestingLogger(t) + cc := abciclient.NewLocalCreator(kvstore.NewApplication()) - proxyApp := proxy.NewAppConns(cc, log.TestingLogger(), proxy.NopMetrics()) + proxyApp := proxy.NewAppConns(cc, logger, proxy.NopMetrics()) err = proxyApp.Start(ctx) require.Nil(t, err) - logger := log.TestingLogger() - const height int64 = 1 state, stateDB, _ := state(t, 1, height) stateStore := sm.NewStore(stateDB) @@ -413,13 +421,14 @@ func TestMaxProposalBlockSize(t *testing.T) { cfg, err := config.ResetTestRoot("node_create_proposal") require.NoError(t, err) defer os.RemoveAll(cfg.RootDir) + + logger := log.NewTestingLogger(t) + cc := abciclient.NewLocalCreator(kvstore.NewApplication()) - proxyApp := proxy.NewAppConns(cc, log.TestingLogger(), proxy.NopMetrics()) + proxyApp := proxy.NewAppConns(cc, logger, proxy.NopMetrics()) err = proxyApp.Start(ctx) require.Nil(t, err) - logger := log.TestingLogger() - state, stateDB, _ := state(t, types.MaxVotesCount, int64(1)) stateStore := sm.NewStore(stateDB) blockStore := store.NewBlockStore(dbm.NewMemDB()) @@ -534,12 +543,14 @@ func TestNodeNewSeedNode(t *testing.T) { nodeKey, err := types.LoadOrGenNodeKey(cfg.NodeKeyFile()) require.NoError(t, err) + logger := log.NewTestingLogger(t) + ns, err := makeSeedNode(ctx, cfg, config.DefaultDBProvider, nodeKey, defaultGenesisDocProviderFunc(cfg), - log.TestingLogger(), + logger, ) t.Cleanup(ns.Wait) @@ -566,7 +577,8 @@ func TestNodeSetEventSink(t *testing.T) { ctx, cancel := context.WithCancel(context.Background()) defer cancel() - logger := log.TestingLogger() + logger := log.NewTestingLogger(t) + setupTest := func(t *testing.T, conf *config.Config) []indexer.EventSink { eventBus := eventbus.NewDefault(logger.With("module", "events")) require.NoError(t, eventBus.Start(ctx)) diff --git a/privval/grpc/client_test.go b/privval/grpc/client_test.go index 1d48b2660..86bf4bb2b 100644 --- a/privval/grpc/client_test.go +++ b/privval/grpc/client_test.go @@ -46,7 +46,7 @@ func TestSignerClient_GetPubKey(t *testing.T) { defer cancel() mockPV := types.NewMockPV() - logger := log.TestingLogger() + logger := log.NewTestingLogger(t) srv, dialer := dialer(t, mockPV, logger) defer srv.Stop() @@ -70,7 +70,7 @@ func TestSignerClient_SignVote(t *testing.T) { defer cancel() mockPV := types.NewMockPV() - logger := log.TestingLogger() + logger := log.NewTestingLogger(t) srv, dialer := dialer(t, mockPV, logger) defer srv.Stop() @@ -125,7 +125,7 @@ func TestSignerClient_SignProposal(t *testing.T) { defer cancel() mockPV := types.NewMockPV() - logger := log.TestingLogger() + logger := log.NewTestingLogger(t) srv, dialer := dialer(t, mockPV, logger) defer srv.Stop() diff --git a/privval/grpc/server_test.go b/privval/grpc/server_test.go index 9fec9f2fd..78e9c79ed 100644 --- a/privval/grpc/server_test.go +++ b/privval/grpc/server_test.go @@ -34,14 +34,18 @@ func TestGetPubKey(t *testing.T) { for _, tc := range testCases { tc := tc t.Run(tc.name, func(t *testing.T) { - s := tmgrpc.NewSignerServer(ChainID, tc.pv, log.TestingLogger()) + ctx, cancel := context.WithCancel(context.Background()) + defer cancel() + logger := log.NewTestingLogger(t) + + s := tmgrpc.NewSignerServer(ChainID, tc.pv, logger) req := &privvalproto.PubKeyRequest{ChainId: ChainID} - resp, err := s.GetPubKey(context.Background(), req) + resp, err := s.GetPubKey(ctx, req) if tc.err { require.Error(t, err) } else { - pk, err := tc.pv.GetPubKey(context.Background()) + pk, err := tc.pv.GetPubKey(ctx) require.NoError(t, err) assert.Equal(t, resp.PubKey.GetEd25519(), pk.Bytes()) } @@ -105,16 +109,20 @@ func TestSignVote(t *testing.T) { for _, tc := range testCases { tc := tc t.Run(tc.name, func(t *testing.T) { - s := tmgrpc.NewSignerServer(ChainID, tc.pv, log.TestingLogger()) + ctx, cancel := context.WithCancel(context.Background()) + defer cancel() + logger := log.NewTestingLogger(t) + + s := tmgrpc.NewSignerServer(ChainID, tc.pv, logger) req := &privvalproto.SignVoteRequest{ChainId: ChainID, Vote: tc.have.ToProto()} - resp, err := s.SignVote(context.Background(), req) + resp, err := s.SignVote(ctx, req) if tc.err { require.Error(t, err) } else { pbVote := tc.want.ToProto() - require.NoError(t, tc.pv.SignVote(context.Background(), ChainID, pbVote)) + require.NoError(t, tc.pv.SignVote(ctx, ChainID, pbVote)) assert.Equal(t, pbVote.Signature, resp.Vote.Signature) } @@ -172,15 +180,19 @@ func TestSignProposal(t *testing.T) { for _, tc := range testCases { tc := tc t.Run(tc.name, func(t *testing.T) { - s := tmgrpc.NewSignerServer(ChainID, tc.pv, log.TestingLogger()) + ctx, cancel := context.WithCancel(context.Background()) + defer cancel() + logger := log.NewTestingLogger(t) + + s := tmgrpc.NewSignerServer(ChainID, tc.pv, logger) req := &privvalproto.SignProposalRequest{ChainId: ChainID, Proposal: tc.have.ToProto()} - resp, err := s.SignProposal(context.Background(), req) + resp, err := s.SignProposal(ctx, req) if tc.err { require.Error(t, err) } else { pbProposal := tc.want.ToProto() - require.NoError(t, tc.pv.SignProposal(context.Background(), ChainID, pbProposal)) + require.NoError(t, tc.pv.SignProposal(ctx, ChainID, pbProposal)) assert.Equal(t, pbProposal.Signature, resp.Proposal.Signature) } }) diff --git a/privval/signer_client_test.go b/privval/signer_client_test.go index 2e3fbcb2d..1f060548c 100644 --- a/privval/signer_client_test.go +++ b/privval/signer_client_test.go @@ -11,6 +11,7 @@ import ( "github.com/tendermint/tendermint/crypto" "github.com/tendermint/tendermint/crypto/tmhash" + "github.com/tendermint/tendermint/libs/log" tmrand "github.com/tendermint/tendermint/libs/rand" cryptoproto "github.com/tendermint/tendermint/proto/tendermint/crypto" privvalproto "github.com/tendermint/tendermint/proto/tendermint/privval" @@ -27,7 +28,7 @@ type signerTestCase struct { closer context.CancelFunc } -func getSignerTestCases(ctx context.Context, t *testing.T) []signerTestCase { +func getSignerTestCases(ctx context.Context, t *testing.T, logger log.Logger) []signerTestCase { t.Helper() testCases := make([]signerTestCase, 0) @@ -39,7 +40,7 @@ func getSignerTestCases(ctx context.Context, t *testing.T) []signerTestCase { cctx, ccancel := context.WithCancel(ctx) // get a pair of signer listener, signer dialer endpoints - sl, sd := getMockEndpoints(cctx, t, dtc.addr, dtc.dialer) + sl, sd := getMockEndpoints(cctx, t, logger, dtc.addr, dtc.dialer) sc, err := NewSignerClient(cctx, sl, chainID) require.NoError(t, err) ss := NewSignerServer(sd, chainID, mockPV) @@ -63,7 +64,9 @@ func TestSignerClose(t *testing.T) { bctx, bcancel := context.WithCancel(context.Background()) defer bcancel() - for _, tc := range getSignerTestCases(bctx, t) { + logger := log.NewTestingLogger(t) + + for _, tc := range getSignerTestCases(bctx, t, logger) { t.Run(tc.name, func(t *testing.T) { defer tc.closer() @@ -77,7 +80,9 @@ func TestSignerPing(t *testing.T) { ctx, cancel := context.WithCancel(context.Background()) defer cancel() - for _, tc := range getSignerTestCases(ctx, t) { + logger := log.NewTestingLogger(t) + + for _, tc := range getSignerTestCases(ctx, t, logger) { err := tc.signerClient.Ping() assert.NoError(t, err) } @@ -87,7 +92,9 @@ func TestSignerGetPubKey(t *testing.T) { ctx, cancel := context.WithCancel(context.Background()) defer cancel() - for _, tc := range getSignerTestCases(ctx, t) { + logger := log.NewTestingLogger(t) + + for _, tc := range getSignerTestCases(ctx, t, logger) { t.Run(tc.name, func(t *testing.T) { defer tc.closer() @@ -113,7 +120,9 @@ func TestSignerProposal(t *testing.T) { ctx, cancel := context.WithCancel(context.Background()) defer cancel() - for _, tc := range getSignerTestCases(ctx, t) { + logger := log.NewTestingLogger(t) + + for _, tc := range getSignerTestCases(ctx, t, logger) { t.Run(tc.name, func(t *testing.T) { defer tc.closer() @@ -149,7 +158,9 @@ func TestSignerVote(t *testing.T) { ctx, cancel := context.WithCancel(context.Background()) defer cancel() - for _, tc := range getSignerTestCases(ctx, t) { + logger := log.NewTestingLogger(t) + + for _, tc := range getSignerTestCases(ctx, t, logger) { t.Run(tc.name, func(t *testing.T) { defer tc.closer() @@ -188,7 +199,9 @@ func TestSignerVoteResetDeadline(t *testing.T) { ctx, cancel := context.WithCancel(context.Background()) defer cancel() - for _, tc := range getSignerTestCases(ctx, t) { + logger := log.NewTestingLogger(t) + + for _, tc := range getSignerTestCases(ctx, t, logger) { t.Run(tc.name, func(t *testing.T) { ts := time.Now() hash := tmrand.Bytes(tmhash.Size) @@ -235,7 +248,9 @@ func TestSignerVoteKeepAlive(t *testing.T) { ctx, cancel := context.WithCancel(context.Background()) defer cancel() - for _, tc := range getSignerTestCases(ctx, t) { + logger := log.NewTestingLogger(t) + + for _, tc := range getSignerTestCases(ctx, t, logger) { t.Run(tc.name, func(t *testing.T) { defer tc.closer() @@ -283,7 +298,9 @@ func TestSignerSignProposalErrors(t *testing.T) { ctx, cancel := context.WithCancel(context.Background()) defer cancel() - for _, tc := range getSignerTestCases(ctx, t) { + logger := log.NewTestingLogger(t) + + for _, tc := range getSignerTestCases(ctx, t, logger) { t.Run(tc.name, func(t *testing.T) { defer tc.closer() // Replace service with a mock that always fails @@ -320,7 +337,9 @@ func TestSignerSignVoteErrors(t *testing.T) { ctx, cancel := context.WithCancel(context.Background()) defer cancel() - for _, tc := range getSignerTestCases(ctx, t) { + logger := log.NewTestingLogger(t) + + for _, tc := range getSignerTestCases(ctx, t, logger) { t.Run(tc.name, func(t *testing.T) { defer tc.closer() @@ -382,7 +401,9 @@ func TestSignerUnexpectedResponse(t *testing.T) { ctx, cancel := context.WithCancel(context.Background()) defer cancel() - for _, tc := range getSignerTestCases(ctx, t) { + logger := log.NewTestingLogger(t) + + for _, tc := range getSignerTestCases(ctx, t, logger) { t.Run(tc.name, func(t *testing.T) { defer tc.closer() diff --git a/privval/signer_listener_endpoint_test.go b/privval/signer_listener_endpoint_test.go index 2313b4353..47fe812c9 100644 --- a/privval/signer_listener_endpoint_test.go +++ b/privval/signer_listener_endpoint_test.go @@ -42,6 +42,8 @@ func TestSignerRemoteRetryTCPOnly(t *testing.T) { ctx, cancel := context.WithCancel(context.Background()) defer cancel() + logger := log.NewTestingLogger(t) + ln, err := net.Listen("tcp", "127.0.0.1:0") require.NoError(t, err) @@ -64,8 +66,7 @@ func TestSignerRemoteRetryTCPOnly(t *testing.T) { } }(ln, attemptCh) - dialerEndpoint := NewSignerDialerEndpoint( - log.TestingLogger(), + dialerEndpoint := NewSignerDialerEndpoint(logger, DialTCPFn(ln.Addr().String(), testTimeoutReadWrite, ed25519.GenPrivKey()), ) SignerDialerEndpointTimeoutReadWrite(time.Millisecond)(dialerEndpoint) @@ -91,9 +92,10 @@ func TestRetryConnToRemoteSigner(t *testing.T) { ctx, cancel := context.WithCancel(context.Background()) defer cancel() + logger := log.NewTestingLogger(t) + for _, tc := range getDialerTestCases(t) { var ( - logger = log.TestingLogger() chainID = tmrand.Str(12) mockPV = types.NewMockPV() endpointIsOpenCh = make(chan struct{}) @@ -184,12 +186,12 @@ func startListenerEndpointAsync( func getMockEndpoints( ctx context.Context, t *testing.T, + logger log.Logger, addr string, socketDialer SocketDialer, ) (*SignerListenerEndpoint, *SignerDialerEndpoint) { var ( - logger = log.TestingLogger() endpointIsOpenCh = make(chan struct{}) dialerEndpoint = NewSignerDialerEndpoint( diff --git a/rpc/client/rpc_test.go b/rpc/client/rpc_test.go index ff6c0d57c..591fe9bb0 100644 --- a/rpc/client/rpc_test.go +++ b/rpc/client/rpc_test.go @@ -40,7 +40,7 @@ func getHTTPClient(t *testing.T, conf *config.Config) *rpchttp.HTTP { c, err := rpchttp.NewWithClient(rpcAddr, http.DefaultClient) require.NoError(t, err) - c.Logger = log.TestingLogger() + c.Logger = log.NewTestingLogger(t) t.Cleanup(func() { if c.IsRunning() { require.NoError(t, c.Stop()) @@ -59,7 +59,7 @@ func getHTTPClientWithTimeout(t *testing.T, conf *config.Config, timeout time.Du c, err := rpchttp.NewWithClient(rpcAddr, http.DefaultClient) require.NoError(t, err) - c.Logger = log.TestingLogger() + c.Logger = log.NewTestingLogger(t) t.Cleanup(func() { http.DefaultClient.Timeout = 0 if c.IsRunning() { diff --git a/rpc/jsonrpc/client/ws_client_test.go b/rpc/jsonrpc/client/ws_client_test.go index 9cc65a758..13ac8444a 100644 --- a/rpc/jsonrpc/client/ws_client_test.go +++ b/rpc/jsonrpc/client/ws_client_test.go @@ -228,7 +228,7 @@ func startClient(ctx context.Context, t *testing.T, addr string) *WSClient { require.Nil(t, err) err = c.Start(ctx) require.Nil(t, err) - c.Logger = log.TestingLogger() + c.Logger = log.NewTestingLogger(t) return c } diff --git a/rpc/jsonrpc/jsonrpc_test.go b/rpc/jsonrpc/jsonrpc_test.go index 626959b01..1ee15d5d3 100644 --- a/rpc/jsonrpc/jsonrpc_test.go +++ b/rpc/jsonrpc/jsonrpc_test.go @@ -273,6 +273,8 @@ func TestServersAndClientsBasic(t *testing.T) { ctx, cancel := context.WithCancel(bctx) defer cancel() + logger := log.NewTestingLogger(t) + cl2, err := client.New(addr) require.Nil(t, err) fmt.Printf("=== testing server on %s using JSONRPC client", addr) @@ -280,7 +282,7 @@ func TestServersAndClientsBasic(t *testing.T) { cl3, err := client.NewWS(addr, websocketEndpoint) require.Nil(t, err) - cl3.Logger = log.TestingLogger() + cl3.Logger = logger err = cl3.Start(ctx) require.Nil(t, err) fmt.Printf("=== testing server on %s using WS client", addr) @@ -296,7 +298,7 @@ func TestWSNewWSRPCFunc(t *testing.T) { cl, err := client.NewWS(tcpAddr, websocketEndpoint) require.Nil(t, err) - cl.Logger = log.TestingLogger() + cl.Logger = log.NewTestingLogger(t) err = cl.Start(ctx) require.Nil(t, err) t.Cleanup(func() { @@ -330,7 +332,7 @@ func TestWSHandlesArrayParams(t *testing.T) { cl, err := client.NewWS(tcpAddr, websocketEndpoint) require.Nil(t, err) - cl.Logger = log.TestingLogger() + cl.Logger = log.NewTestingLogger(t) require.Nil(t, cl.Start(ctx)) t.Cleanup(func() { if err := cl.Stop(); err != nil { @@ -362,7 +364,7 @@ func TestWSClientPingPong(t *testing.T) { cl, err := client.NewWS(tcpAddr, websocketEndpoint) require.Nil(t, err) - cl.Logger = log.TestingLogger() + cl.Logger = log.NewTestingLogger(t) err = cl.Start(ctx) require.Nil(t, err) t.Cleanup(func() { diff --git a/rpc/jsonrpc/server/http_server_test.go b/rpc/jsonrpc/server/http_server_test.go index 983e2eb65..c546f82fc 100644 --- a/rpc/jsonrpc/server/http_server_test.go +++ b/rpc/jsonrpc/server/http_server_test.go @@ -31,6 +31,8 @@ func TestMaxOpenConnections(t *testing.T) { ctx, cancel := context.WithCancel(context.Background()) defer cancel() + logger := log.NewTestingLogger(t) + // Start the server. var open int32 mux := http.NewServeMux() @@ -46,7 +48,8 @@ func TestMaxOpenConnections(t *testing.T) { l, err := Listen("tcp://127.0.0.1:0", max) require.NoError(t, err) defer l.Close() - go Serve(ctx, l, mux, log.TestingLogger(), config) //nolint:errcheck // ignore for tests + + go Serve(ctx, l, mux, logger, config) //nolint:errcheck // ignore for tests // Make N GET calls to the server. attempts := max * 2 @@ -87,9 +90,11 @@ func TestServeTLS(t *testing.T) { ctx, cancel := context.WithCancel(context.Background()) defer cancel() + logger := log.NewTestingLogger(t) + chErr := make(chan error, 1) go func() { - chErr <- ServeTLS(ctx, ln, mux, "test.crt", "test.key", log.TestingLogger(), DefaultConfig()) + chErr <- ServeTLS(ctx, ln, mux, "test.crt", "test.key", logger, DefaultConfig()) }() select { diff --git a/rpc/jsonrpc/server/ws_handler_test.go b/rpc/jsonrpc/server/ws_handler_test.go index b691172a4..11c97ade0 100644 --- a/rpc/jsonrpc/server/ws_handler_test.go +++ b/rpc/jsonrpc/server/ws_handler_test.go @@ -13,7 +13,9 @@ import ( ) func TestWebsocketManagerHandler(t *testing.T) { - s := newWSServer() + logger := log.NewTestingLogger(t) + + s := newWSServer(t, logger) defer s.Close() // check upgrader works @@ -42,15 +44,20 @@ func TestWebsocketManagerHandler(t *testing.T) { dialResp.Body.Close() } -func newWSServer() *httptest.Server { +func newWSServer(t *testing.T, logger log.Logger) *httptest.Server { funcMap := map[string]*RPCFunc{ "c": NewWSRPCFunc(func(ctx *rpctypes.Context, s string, i int) (string, error) { return "foo", nil }, "s,i"), } wm := NewWebsocketManager(funcMap) - wm.SetLogger(log.TestingLogger()) + + wm.SetLogger(logger) mux := http.NewServeMux() mux.HandleFunc("/websocket", wm.WebsocketHandler) - return httptest.NewServer(mux) + srv := httptest.NewServer(mux) + + t.Cleanup(srv.Close) + + return srv }