github.com/status-im/status-go@v1.1.0/services/rpcfilters/api_test.go (about)

     1  package rpcfilters
     2  
     3  import (
     4  	"context"
     5  	"math/big"
     6  	"sync"
     7  	"testing"
     8  	"time"
     9  
    10  	"github.com/stretchr/testify/assert"
    11  	"github.com/stretchr/testify/require"
    12  
    13  	"github.com/ethereum/go-ethereum/common/hexutil"
    14  	"github.com/ethereum/go-ethereum/eth/filters"
    15  	"github.com/ethereum/go-ethereum/rpc"
    16  )
    17  
    18  func TestFilterLiveness(t *testing.T) {
    19  	api := &PublicAPI{
    20  		filters:              make(map[rpc.ID]filter),
    21  		filterLivenessLoop:   10 * time.Millisecond,
    22  		filterLivenessPeriod: 15 * time.Millisecond,
    23  		client:               func() ContextCaller { return &callTracker{} },
    24  		chainID:              func() uint64 { return 1 },
    25  	}
    26  	id, err := api.NewFilter(filters.FilterCriteria{})
    27  	require.NoError(t, err)
    28  	quit := make(chan struct{})
    29  	var wg sync.WaitGroup
    30  	wg.Add(1)
    31  	go func() {
    32  		api.timeoutLoop(quit)
    33  		wg.Done()
    34  	}()
    35  	tick := time.Tick(10 * time.Millisecond)
    36  	after := time.After(100 * time.Millisecond)
    37  	func() {
    38  		for {
    39  			select {
    40  			case <-after:
    41  				assert.FailNow(t, "filter wasn't removed")
    42  				close(quit)
    43  				return
    44  			case <-tick:
    45  				api.filtersMu.Lock()
    46  				_, exist := api.filters[id]
    47  				api.filtersMu.Unlock()
    48  				if !exist {
    49  					close(quit)
    50  					return
    51  				}
    52  			}
    53  		}
    54  	}()
    55  	wg.Wait()
    56  }
    57  
    58  func TestGetFilterChangesResetsTimer(t *testing.T) {
    59  	api := &PublicAPI{
    60  		filters:              make(map[rpc.ID]filter),
    61  		filterLivenessLoop:   10 * time.Millisecond,
    62  		filterLivenessPeriod: 15 * time.Millisecond,
    63  		client:               func() ContextCaller { return &callTracker{} },
    64  		chainID:              func() uint64 { return 1 },
    65  	}
    66  	id, err := api.NewFilter(filters.FilterCriteria{})
    67  	require.NoError(t, err)
    68  
    69  	api.filtersMu.Lock()
    70  	f := api.filters[id]
    71  	require.True(t, f.deadline().Stop())
    72  	fake := make(chan time.Time, 1)
    73  	fake <- time.Time{}
    74  	f.deadline().C = fake
    75  	api.filtersMu.Unlock()
    76  
    77  	require.False(t, f.deadline().Stop())
    78  	// GetFilterChanges will Reset deadline
    79  	_, err = api.GetFilterChanges(id)
    80  	require.NoError(t, err)
    81  	require.True(t, f.deadline().Stop())
    82  }
    83  
    84  func TestGetFilterLogs(t *testing.T) {
    85  	t.Skip("flaky test")
    86  
    87  	tracker := new(callTracker)
    88  	api := &PublicAPI{
    89  		filters: make(map[rpc.ID]filter),
    90  		client:  func() ContextCaller { return tracker },
    91  		chainID: func() uint64 { return 1 },
    92  	}
    93  	block := big.NewInt(10)
    94  	id, err := api.NewFilter(filters.FilterCriteria{
    95  		FromBlock: block,
    96  	})
    97  	require.NoError(t, err)
    98  	logs, err := api.GetFilterLogs(context.TODO(), id)
    99  	require.NoError(t, err)
   100  	require.Empty(t, logs)
   101  	require.Len(t, tracker.criteria, 1)
   102  	rst, err := hexutil.DecodeBig(tracker.criteria[0]["fromBlock"].(string))
   103  	require.NoError(t, err)
   104  	require.Equal(t, block, rst)
   105  }