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

     1  package ext
     2  
     3  import (
     4  	"encoding/hex"
     5  	"fmt"
     6  	"testing"
     7  	"time"
     8  
     9  	"github.com/status-im/status-go/eth-node/types"
    10  
    11  	"github.com/status-im/status-go/mailserver"
    12  
    13  	"github.com/stretchr/testify/assert"
    14  	"github.com/stretchr/testify/require"
    15  )
    16  
    17  func TestMessagesRequest_setDefaults(t *testing.T) {
    18  	daysAgo := func(now time.Time, days int) uint32 {
    19  		return uint32(now.UTC().Add(-24 * time.Hour * time.Duration(days)).Unix())
    20  	}
    21  
    22  	tnow := time.Now()
    23  	now := uint32(tnow.UTC().Unix())
    24  	yesterday := daysAgo(tnow, 1)
    25  
    26  	scenarios := []struct {
    27  		given    *MessagesRequest
    28  		expected *MessagesRequest
    29  	}{
    30  		{
    31  			&MessagesRequest{From: 0, To: 0},
    32  			&MessagesRequest{From: yesterday, To: now, Timeout: defaultRequestTimeout},
    33  		},
    34  		{
    35  			&MessagesRequest{From: 1, To: 0},
    36  			&MessagesRequest{From: uint32(1), To: now, Timeout: defaultRequestTimeout},
    37  		},
    38  		{
    39  			&MessagesRequest{From: 0, To: yesterday},
    40  			&MessagesRequest{From: daysAgo(tnow, 2), To: yesterday, Timeout: defaultRequestTimeout},
    41  		},
    42  		// 100 - 1 day would be invalid, so we set From to 0
    43  		{
    44  			&MessagesRequest{From: 0, To: 100},
    45  			&MessagesRequest{From: 0, To: 100, Timeout: defaultRequestTimeout},
    46  		},
    47  		// set Timeout
    48  		{
    49  			&MessagesRequest{From: 0, To: 0, Timeout: 100},
    50  			&MessagesRequest{From: yesterday, To: now, Timeout: 100},
    51  		},
    52  	}
    53  
    54  	for i, s := range scenarios {
    55  		t.Run(fmt.Sprintf("Scenario %d", i), func(t *testing.T) {
    56  			s.given.SetDefaults(tnow)
    57  			require.Equal(t, s.expected, s.given)
    58  		})
    59  	}
    60  }
    61  
    62  func TestMakeMessagesRequestPayload(t *testing.T) {
    63  	var emptyTopic types.TopicType
    64  	testCases := []struct {
    65  		Name string
    66  		Req  MessagesRequest
    67  		Err  string
    68  	}{
    69  		{
    70  			Name: "empty cursor",
    71  			Req:  MessagesRequest{Cursor: ""},
    72  			Err:  "",
    73  		},
    74  		{
    75  			Name: "invalid cursor size",
    76  			Req:  MessagesRequest{Cursor: hex.EncodeToString([]byte{0x01, 0x02, 0x03})},
    77  			Err:  fmt.Sprintf("invalid cursor size: expected %d but got 3", mailserver.CursorLength),
    78  		},
    79  		{
    80  			Name: "valid cursor",
    81  			Req: MessagesRequest{
    82  				Cursor: hex.EncodeToString(mailserver.NewDBKey(123, emptyTopic, types.Hash{}).Cursor()),
    83  			},
    84  			Err: "",
    85  		},
    86  	}
    87  
    88  	for _, tc := range testCases {
    89  		t.Run(tc.Name, func(t *testing.T) {
    90  			_, err := MakeMessagesRequestPayload(tc.Req)
    91  			if tc.Err == "" {
    92  				require.NoError(t, err)
    93  			} else {
    94  				require.EqualError(t, err, tc.Err)
    95  			}
    96  		})
    97  	}
    98  }
    99  
   100  func TestTopicsToBloom(t *testing.T) {
   101  	t1 := stringToTopic("t1")
   102  	b1 := types.TopicToBloom(t1)
   103  	t2 := stringToTopic("t2")
   104  	b2 := types.TopicToBloom(t2)
   105  	t3 := stringToTopic("t3")
   106  	b3 := types.TopicToBloom(t3)
   107  
   108  	reqBloom := topicsToBloom(t1)
   109  	assert.True(t, types.BloomFilterMatch(reqBloom, b1))
   110  	assert.False(t, types.BloomFilterMatch(reqBloom, b2))
   111  	assert.False(t, types.BloomFilterMatch(reqBloom, b3))
   112  
   113  	reqBloom = topicsToBloom(t1, t2)
   114  	assert.True(t, types.BloomFilterMatch(reqBloom, b1))
   115  	assert.True(t, types.BloomFilterMatch(reqBloom, b2))
   116  	assert.False(t, types.BloomFilterMatch(reqBloom, b3))
   117  
   118  	reqBloom = topicsToBloom(t1, t2, t3)
   119  	assert.True(t, types.BloomFilterMatch(reqBloom, b1))
   120  	assert.True(t, types.BloomFilterMatch(reqBloom, b2))
   121  	assert.True(t, types.BloomFilterMatch(reqBloom, b3))
   122  }
   123  
   124  func TestCreateBloomFilter(t *testing.T) {
   125  	t1 := stringToTopic("t1")
   126  	t2 := stringToTopic("t2")
   127  
   128  	req := MessagesRequest{Topic: t1}
   129  	bloom := createBloomFilter(req)
   130  	assert.Equal(t, topicsToBloom(t1), bloom)
   131  
   132  	req = MessagesRequest{Topics: []types.TopicType{t1, t2}}
   133  	bloom = createBloomFilter(req)
   134  	assert.Equal(t, topicsToBloom(t1, t2), bloom)
   135  }
   136  
   137  func stringToTopic(s string) types.TopicType {
   138  	return types.BytesToTopic([]byte(s))
   139  }
   140  
   141  func TestExpiredOrCompleted(t *testing.T) {
   142  	timeout := time.Millisecond
   143  	events := make(chan types.EnvelopeEvent)
   144  	errors := make(chan error, 1)
   145  	hash := types.Hash{1}
   146  	go func() {
   147  		_, err := WaitForExpiredOrCompleted(hash, events, timeout)
   148  		errors <- err
   149  	}()
   150  	select {
   151  	case <-time.After(time.Second):
   152  		require.FailNow(t, "timed out waiting for waitForExpiredOrCompleted to complete")
   153  	case err := <-errors:
   154  		require.EqualError(t, err, fmt.Sprintf("request %x expired", hash))
   155  	}
   156  }