From b9bac1f384ceef7d7390b9dd9da759bce1741392 Mon Sep 17 00:00:00 2001 From: gary rong Date: Thu, 7 Nov 2019 05:09:37 +0800 Subject: [PATCH] les: fix and slim the unit tests of les (#20247) * les: loose restriction of unit tests * les: update unit tests * les, light: slim the unit tests --- les/clientpool.go | 3 +++ les/clientpool_test.go | 31 ++++++++++++++++++++++++------- les/distributor.go | 14 ++++++++------ les/distributor_test.go | 7 +++++-- les/odr_test.go | 7 ++++++- les/sync_test.go | 2 +- les/test_helper.go | 4 ++-- light/postprocess.go | 24 ++++++++++++------------ 8 files changed, 61 insertions(+), 31 deletions(-) diff --git a/les/clientpool.go b/les/clientpool.go index 2df538620b..0b4d1b9612 100644 --- a/les/clientpool.go +++ b/les/clientpool.go @@ -459,6 +459,9 @@ func (f *clientPool) addBalance(id enode.ID, amount uint64, setTotal bool) { defer func() { c.balanceTracker.setBalance(pb.value, negBalance) if !c.priority && pb.value > 0 { + // The capacity should be adjusted based on the requirement, + // but we have no idea about the new capacity, need a second + // call to udpate it. c.priority = true c.balanceTracker.addCallback(balanceCallbackZero, 0, func() { f.balanceExhausted(id) }) } diff --git a/les/clientpool_test.go b/les/clientpool_test.go index 5b9494c2aa..53973696ca 100644 --- a/les/clientpool_test.go +++ b/les/clientpool_test.go @@ -68,6 +68,14 @@ func (i poolTestPeer) freeClientId() string { func (i poolTestPeer) updateCapacity(uint64) {} +type poolTestPeerWithCap struct { + poolTestPeer + + cap uint64 +} + +func (i *poolTestPeerWithCap) updateCapacity(cap uint64) { i.cap = cap } + func testClientPool(t *testing.T, connLimit, clientCount, paidCount int, randomDisconnect bool) { rand.Seed(time.Now().UnixNano()) var ( @@ -308,9 +316,9 @@ func TestFreeClientKickedOut(t *testing.T) { for i := 0; i < 10; i++ { pool.connect(poolTestPeer(i), 1) - clock.Run(100 * time.Millisecond) + clock.Run(time.Millisecond) } - if pool.connect(poolTestPeer(11), 1) { + if pool.connect(poolTestPeer(10), 1) { t.Fatalf("New free client should be rejected") } clock.Run(5 * time.Minute) @@ -320,8 +328,8 @@ func TestFreeClientKickedOut(t *testing.T) { for i := 0; i < 10; i++ { select { case id := <-kicked: - if id != i { - t.Fatalf("Kicked client mismatch, want %v, got %v", i, id) + if id >= 10 { + t.Fatalf("Old client should be kicked, now got: %d", id) } case <-time.NewTimer(time.Second).C: t.Fatalf("timeout") @@ -364,11 +372,20 @@ func TestDowngradePriorityClient(t *testing.T) { pool.setLimits(10, uint64(10)) // Total capacity limit is 10 pool.setPriceFactors(priceFactors{1, 0, 1}, priceFactors{1, 0, 1}) - pool.addBalance(poolTestPeer(0).ID(), uint64(time.Minute), false) - pool.connect(poolTestPeer(0), 10) + p := &poolTestPeerWithCap{ + poolTestPeer: poolTestPeer(0), + } + pool.addBalance(p.ID(), uint64(time.Minute), false) + pool.connect(p, 10) + if p.cap != 10 { + t.Fatalf("The capcacity of priority peer hasn't been updated, got: %d", p.cap) + } + clock.Run(time.Minute) // All positive balance should be used up. time.Sleep(300 * time.Millisecond) // Ensure the callback is called - + if p.cap != 1 { + t.Fatalf("The capcacity of peer should be downgraded, got: %d", p.cap) + } pb := pool.ndb.getOrNewPB(poolTestPeer(0).ID()) if pb.value != 0 { t.Fatalf("Positive balance mismatch, want %v, got %v", 0, pb.value) diff --git a/les/distributor.go b/les/distributor.go index 62abef47dc..6d81149720 100644 --- a/les/distributor.go +++ b/les/distributor.go @@ -110,13 +110,15 @@ func (d *requestDistributor) registerTestPeer(p distPeer) { d.peerLock.Unlock() } -// distMaxWait is the maximum waiting time after which further necessary waiting -// times are recalculated based on new feedback from the servers -const distMaxWait = time.Millisecond * 50 +var ( + // distMaxWait is the maximum waiting time after which further necessary waiting + // times are recalculated based on new feedback from the servers + distMaxWait = time.Millisecond * 50 -// waitForPeers is the time window in which a request does not fail even if it -// has no suitable peers to send to at the moment -const waitForPeers = time.Second * 3 + // waitForPeers is the time window in which a request does not fail even if it + // has no suitable peers to send to at the moment + waitForPeers = time.Second * 3 +) // main event loop func (d *requestDistributor) loop() { diff --git a/les/distributor_test.go b/les/distributor_test.go index 00d43e1d6b..539c1aa7d7 100644 --- a/les/distributor_test.go +++ b/les/distributor_test.go @@ -86,8 +86,8 @@ func (p *testDistPeer) worker(t *testing.T, checkOrder bool, stop chan struct{}) const ( testDistBufLimit = 10000000 testDistMaxCost = 1000000 - testDistPeerCount = 5 - testDistReqCount = 5000 + testDistPeerCount = 2 + testDistReqCount = 10 testDistMaxResendCount = 3 ) @@ -128,6 +128,9 @@ func testRequestDistributor(t *testing.T, resend bool) { go peers[i].worker(t, !resend, stop) dist.registerTestPeer(peers[i]) } + // Disable the mechanism that we will wait a few time for request + // even there is no suitable peer to send right now. + waitForPeers = 0 var wg sync.WaitGroup diff --git a/les/odr_test.go b/les/odr_test.go index 74808b345f..7d10878226 100644 --- a/les/odr_test.go +++ b/les/odr_test.go @@ -193,6 +193,9 @@ func testOdr(t *testing.T, protocol int, expFail uint64, checkCached bool, fn od if clientHead.Number.Uint64() != 4 { t.Fatalf("Failed to sync the chain with server, head: %v", clientHead.Number.Uint64()) } + // Disable the mechanism that we will wait a few time for request + // even there is no suitable peer to send right now. + waitForPeers = 0 test := func(expFail uint64) { // Mark this as a helper to put the failures at the correct lines @@ -202,7 +205,9 @@ func testOdr(t *testing.T, protocol int, expFail uint64, checkCached bool, fn od bhash := rawdb.ReadCanonicalHash(server.db, i) b1 := fn(light.NoOdr, server.db, server.handler.server.chainConfig, server.handler.blockchain, nil, bhash) - ctx, cancel := context.WithTimeout(context.Background(), 200*time.Millisecond) + // Set the timeout as 1 second here, ensure there is enough time + // for travis to make the action. + ctx, cancel := context.WithTimeout(context.Background(), time.Second) b2 := fn(ctx, client.db, client.handler.backend.chainConfig, nil, client.handler.backend.blockchain, bhash) cancel() diff --git a/les/sync_test.go b/les/sync_test.go index 7eef13d4ca..8df6223b84 100644 --- a/les/sync_test.go +++ b/les/sync_test.go @@ -89,7 +89,7 @@ func testCheckpointSyncing(t *testing.T, protocol int, syncMode int) { for { _, hash, _, err := server.handler.server.oracle.contract.Contract().GetLatestCheckpoint(nil) if err != nil || hash == [32]byte{} { - time.Sleep(100 * time.Millisecond) + time.Sleep(10 * time.Millisecond) continue } break diff --git a/les/test_helper.go b/les/test_helper.go index 67b0225fed..ee3d7a32e1 100644 --- a/les/test_helper.go +++ b/les/test_helper.go @@ -71,10 +71,10 @@ var ( var ( // The block frequency for creating checkpoint(only used in test) - sectionSize = big.NewInt(512) + sectionSize = big.NewInt(128) // The number of confirmations needed to generate a checkpoint(only used in test). - processConfirms = big.NewInt(4) + processConfirms = big.NewInt(1) // The token bucket buffer limit for testing purpose. testBufLimit = uint64(1000000) diff --git a/light/postprocess.go b/light/postprocess.go index 083dcfceb2..af3b257923 100644 --- a/light/postprocess.go +++ b/light/postprocess.go @@ -79,21 +79,21 @@ var ( } // TestServerIndexerConfig wraps a set of configs as a test indexer config for server side. TestServerIndexerConfig = &IndexerConfig{ - ChtSize: 512, - ChtConfirms: 4, - BloomSize: 64, - BloomConfirms: 4, - BloomTrieSize: 512, - BloomTrieConfirms: 4, + ChtSize: 128, + ChtConfirms: 1, + BloomSize: 16, + BloomConfirms: 1, + BloomTrieSize: 128, + BloomTrieConfirms: 1, } // TestClientIndexerConfig wraps a set of configs as a test indexer config for client side. TestClientIndexerConfig = &IndexerConfig{ - ChtSize: 512, - ChtConfirms: 32, - BloomSize: 512, - BloomConfirms: 32, - BloomTrieSize: 512, - BloomTrieConfirms: 32, + ChtSize: 128, + ChtConfirms: 8, + BloomSize: 128, + BloomConfirms: 8, + BloomTrieSize: 128, + BloomTrieConfirms: 8, } )