github.com/status-im/status-go@v1.1.0/services/wallet/transfer/block_test.go (about)

     1  package transfer
     2  
     3  import (
     4  	"math/big"
     5  	"testing"
     6  
     7  	"github.com/stretchr/testify/require"
     8  
     9  	"github.com/status-im/status-go/t/helpers"
    10  	"github.com/status-im/status-go/walletdatabase"
    11  
    12  	"github.com/ethereum/go-ethereum/common"
    13  )
    14  
    15  func setupTestTransferDB(t *testing.T) (*BlockDAO, func()) {
    16  	db, err := helpers.SetupTestMemorySQLDB(walletdatabase.DbInitializer{})
    17  	require.NoError(t, err)
    18  	return &BlockDAO{db}, func() {
    19  		require.NoError(t, db.Close())
    20  	}
    21  }
    22  
    23  func TestInsertRange(t *testing.T) {
    24  	b, stop := setupTestTransferDB(t)
    25  	defer stop()
    26  
    27  	r := &BlocksRange{
    28  		from: big.NewInt(0),
    29  		to:   big.NewInt(10),
    30  	}
    31  	nonce := uint64(199)
    32  	balance := big.NewInt(7657)
    33  	account := common.Address{2}
    34  
    35  	err := b.insertRange(777, account, r.from, r.to, balance, nonce)
    36  	require.NoError(t, err)
    37  
    38  	block, err := b.GetLastKnownBlockByAddress(777, account)
    39  	require.NoError(t, err)
    40  
    41  	require.Equal(t, 0, block.Number.Cmp(r.to))
    42  	require.Equal(t, 0, block.Balance.Cmp(balance))
    43  	require.Equal(t, nonce, uint64(*block.Nonce))
    44  }
    45  
    46  func TestGetNewRanges(t *testing.T) {
    47  	ranges := []*BlocksRange{
    48  		&BlocksRange{
    49  			from: big.NewInt(0),
    50  			to:   big.NewInt(10),
    51  		},
    52  		&BlocksRange{
    53  			from: big.NewInt(10),
    54  			to:   big.NewInt(20),
    55  		},
    56  	}
    57  
    58  	n, d := getNewRanges(ranges)
    59  	require.Equal(t, 1, len(n))
    60  	newRange := n[0]
    61  	require.Equal(t, int64(0), newRange.from.Int64())
    62  	require.Equal(t, int64(20), newRange.to.Int64())
    63  	require.Equal(t, 2, len(d))
    64  
    65  	ranges = []*BlocksRange{
    66  		&BlocksRange{
    67  			from: big.NewInt(0),
    68  			to:   big.NewInt(11),
    69  		},
    70  		&BlocksRange{
    71  			from: big.NewInt(10),
    72  			to:   big.NewInt(20),
    73  		},
    74  	}
    75  
    76  	n, d = getNewRanges(ranges)
    77  	require.Equal(t, 1, len(n))
    78  	newRange = n[0]
    79  	require.Equal(t, int64(0), newRange.from.Int64())
    80  	require.Equal(t, int64(20), newRange.to.Int64())
    81  	require.Equal(t, 2, len(d))
    82  
    83  	ranges = []*BlocksRange{
    84  		&BlocksRange{
    85  			from: big.NewInt(0),
    86  			to:   big.NewInt(20),
    87  		},
    88  		&BlocksRange{
    89  			from: big.NewInt(5),
    90  			to:   big.NewInt(15),
    91  		},
    92  	}
    93  
    94  	n, d = getNewRanges(ranges)
    95  	require.Equal(t, 1, len(n))
    96  	newRange = n[0]
    97  	require.Equal(t, int64(0), newRange.from.Int64())
    98  	require.Equal(t, int64(20), newRange.to.Int64())
    99  	require.Equal(t, 2, len(d))
   100  
   101  	ranges = []*BlocksRange{
   102  		&BlocksRange{
   103  			from: big.NewInt(5),
   104  			to:   big.NewInt(15),
   105  		},
   106  		&BlocksRange{
   107  			from: big.NewInt(5),
   108  			to:   big.NewInt(20),
   109  		},
   110  	}
   111  
   112  	n, d = getNewRanges(ranges)
   113  	require.Equal(t, 1, len(n))
   114  	newRange = n[0]
   115  	require.Equal(t, int64(5), newRange.from.Int64())
   116  	require.Equal(t, int64(20), newRange.to.Int64())
   117  	require.Equal(t, 2, len(d))
   118  
   119  	ranges = []*BlocksRange{
   120  		&BlocksRange{
   121  			from: big.NewInt(5),
   122  			to:   big.NewInt(10),
   123  		},
   124  		&BlocksRange{
   125  			from: big.NewInt(15),
   126  			to:   big.NewInt(20),
   127  		},
   128  	}
   129  
   130  	n, d = getNewRanges(ranges)
   131  	require.Equal(t, 0, len(n))
   132  	require.Equal(t, 0, len(d))
   133  
   134  	ranges = []*BlocksRange{
   135  		&BlocksRange{
   136  			from: big.NewInt(0),
   137  			to:   big.NewInt(10),
   138  		},
   139  		&BlocksRange{
   140  			from: big.NewInt(10),
   141  			to:   big.NewInt(20),
   142  		},
   143  		&BlocksRange{
   144  			from: big.NewInt(30),
   145  			to:   big.NewInt(40),
   146  		},
   147  	}
   148  
   149  	n, d = getNewRanges(ranges)
   150  	require.Equal(t, 1, len(n))
   151  	newRange = n[0]
   152  	require.Equal(t, int64(0), newRange.from.Int64())
   153  	require.Equal(t, int64(20), newRange.to.Int64())
   154  	require.Equal(t, 2, len(d))
   155  
   156  	ranges = []*BlocksRange{
   157  		&BlocksRange{
   158  			from: big.NewInt(0),
   159  			to:   big.NewInt(10),
   160  		},
   161  		&BlocksRange{
   162  			from: big.NewInt(10),
   163  			to:   big.NewInt(20),
   164  		},
   165  		&BlocksRange{
   166  			from: big.NewInt(30),
   167  			to:   big.NewInt(40),
   168  		},
   169  		&BlocksRange{
   170  			from: big.NewInt(40),
   171  			to:   big.NewInt(50),
   172  		},
   173  	}
   174  
   175  	n, d = getNewRanges(ranges)
   176  	require.Equal(t, 2, len(n))
   177  	newRange = n[0]
   178  	require.Equal(t, int64(0), newRange.from.Int64())
   179  	require.Equal(t, int64(20), newRange.to.Int64())
   180  	newRange = n[1]
   181  	require.Equal(t, int64(30), newRange.from.Int64())
   182  	require.Equal(t, int64(50), newRange.to.Int64())
   183  	require.Equal(t, 4, len(d))
   184  }
   185  
   186  func TestInsertZeroBalance(t *testing.T) {
   187  	db, _, err := helpers.SetupTestSQLDB(walletdatabase.DbInitializer{}, "zero-balance")
   188  	require.NoError(t, err)
   189  
   190  	b := &BlockDAO{db}
   191  	r := &BlocksRange{
   192  		from: big.NewInt(0),
   193  		to:   big.NewInt(10),
   194  	}
   195  	nonce := uint64(199)
   196  	balance := big.NewInt(0)
   197  	account := common.Address{2}
   198  
   199  	err = b.insertRange(777, account, r.from, r.to, balance, nonce)
   200  	require.NoError(t, err)
   201  
   202  	block, err := b.GetLastKnownBlockByAddress(777, account)
   203  	require.NoError(t, err)
   204  
   205  	require.Equal(t, 0, block.Number.Cmp(r.to))
   206  	require.Equal(t, big.NewInt(0).Int64(), block.Balance.Int64())
   207  	require.Equal(t, nonce, uint64(*block.Nonce))
   208  }