github.com/status-im/status-go@v1.1.0/services/connector/commands/request_accounts_test.go (about)

     1  package commands
     2  
     3  import (
     4  	"encoding/json"
     5  	"testing"
     6  	"time"
     7  
     8  	"github.com/stretchr/testify/assert"
     9  
    10  	"github.com/status-im/status-go/eth-node/types"
    11  	persistence "github.com/status-im/status-go/services/connector/database"
    12  	walletCommon "github.com/status-im/status-go/services/wallet/common"
    13  	"github.com/status-im/status-go/signal"
    14  )
    15  
    16  func TestFailToRequestAccountsWithMissingDAppFields(t *testing.T) {
    17  	db, close := SetupTestDB(t)
    18  	defer close()
    19  
    20  	cmd := &RequestAccountsCommand{Db: db}
    21  
    22  	// Missing DApp fields
    23  	request, err := ConstructRPCRequest("eth_requestAccounts", []interface{}{}, nil)
    24  	assert.NoError(t, err)
    25  
    26  	result, err := cmd.Execute(request)
    27  	assert.Equal(t, ErrRequestMissingDAppData, err)
    28  	assert.Empty(t, result)
    29  }
    30  
    31  func TestRequestAccountsWithSignalTimeout(t *testing.T) {
    32  	db, close := SetupTestDB(t)
    33  	defer close()
    34  
    35  	clientHandler := NewClientSideHandler()
    36  
    37  	cmd := &RequestAccountsCommand{
    38  		ClientHandler: clientHandler,
    39  		Db:            db,
    40  	}
    41  
    42  	request, err := prepareSendTransactionRequest(testDAppData, types.Address{0x01})
    43  	assert.NoError(t, err)
    44  
    45  	backupWalletResponseMaxInterval := WalletResponseMaxInterval
    46  	WalletResponseMaxInterval = 1 * time.Millisecond
    47  
    48  	_, err = cmd.Execute(request)
    49  	assert.Equal(t, ErrWalletResponseTimeout, err)
    50  	WalletResponseMaxInterval = backupWalletResponseMaxInterval
    51  }
    52  
    53  func TestRequestAccountsAcceptedAndRequestAgain(t *testing.T) {
    54  	db, close := SetupTestDB(t)
    55  	defer close()
    56  
    57  	clientHandler := NewClientSideHandler()
    58  
    59  	cmd := &RequestAccountsCommand{
    60  		ClientHandler: clientHandler,
    61  		Db:            db,
    62  	}
    63  
    64  	request, err := ConstructRPCRequest("eth_requestAccounts", []interface{}{}, &testDAppData)
    65  	assert.NoError(t, err)
    66  
    67  	accountAddress := types.Address{0x03}
    68  	dAppPermissionGranted := false
    69  
    70  	signal.SetMobileSignalHandler(signal.MobileSignalHandler(func(s []byte) {
    71  		var evt EventType
    72  		err := json.Unmarshal(s, &evt)
    73  		assert.NoError(t, err)
    74  
    75  		switch evt.Type {
    76  		case signal.EventConnectorSendRequestAccounts:
    77  			var ev signal.ConnectorSendRequestAccountsSignal
    78  			err := json.Unmarshal(evt.Event, &ev)
    79  			assert.NoError(t, err)
    80  
    81  			err = clientHandler.RequestAccountsAccepted(RequestAccountsAcceptedArgs{
    82  				RequestID: ev.RequestID,
    83  				Account:   accountAddress,
    84  				ChainID:   walletCommon.EthereumMainnet,
    85  			})
    86  			assert.NoError(t, err)
    87  		case signal.EventConnectorDAppPermissionGranted:
    88  			dAppPermissionGranted = true
    89  		}
    90  	}))
    91  	t.Cleanup(signal.ResetMobileSignalHandler)
    92  
    93  	expectedResponse := FormatAccountAddressToResponse(accountAddress)
    94  	response, err := cmd.Execute(request)
    95  	assert.NoError(t, err)
    96  	assert.NoError(t, err)
    97  	assert.Equal(t, expectedResponse, response)
    98  
    99  	// Check dApp in the database
   100  	dApp, err := persistence.SelectDAppByUrl(db, request.URL)
   101  	assert.NoError(t, err)
   102  	assert.Equal(t, request.Name, dApp.Name)
   103  	assert.Equal(t, request.IconURL, dApp.IconURL)
   104  	assert.Equal(t, accountAddress, dApp.SharedAccount)
   105  	assert.Equal(t, walletCommon.EthereumMainnet, dApp.ChainID)
   106  
   107  	// This should not invoke UI side
   108  	response, err = cmd.Execute(request)
   109  	assert.NoError(t, err)
   110  	assert.Equal(t, expectedResponse, response)
   111  
   112  	assert.True(t, dAppPermissionGranted)
   113  }
   114  
   115  func TestRequestAccountsRejected(t *testing.T) {
   116  	db, close := SetupTestDB(t)
   117  	defer close()
   118  
   119  	clientHandler := NewClientSideHandler()
   120  
   121  	cmd := &RequestAccountsCommand{
   122  		ClientHandler: clientHandler,
   123  		Db:            db,
   124  	}
   125  
   126  	request, err := ConstructRPCRequest("eth_requestAccounts", []interface{}{}, &testDAppData)
   127  	assert.NoError(t, err)
   128  
   129  	signal.SetMobileSignalHandler(signal.MobileSignalHandler(func(s []byte) {
   130  		var evt EventType
   131  		err := json.Unmarshal(s, &evt)
   132  		assert.NoError(t, err)
   133  
   134  		switch evt.Type {
   135  		case signal.EventConnectorSendRequestAccounts:
   136  			var ev signal.ConnectorSendRequestAccountsSignal
   137  			err := json.Unmarshal(evt.Event, &ev)
   138  			assert.NoError(t, err)
   139  
   140  			err = clientHandler.RequestAccountsRejected(RejectedArgs{
   141  				RequestID: ev.RequestID,
   142  			})
   143  			assert.NoError(t, err)
   144  		}
   145  	}))
   146  	t.Cleanup(signal.ResetMobileSignalHandler)
   147  
   148  	_, err = cmd.Execute(request)
   149  	assert.Equal(t, ErrRequestAccountsRejectedByUser, err)
   150  }