status-go/e2e/api/backend_test.go

package api_test

import (
	"math/rand"
	"testing"
	"time"

	"github.com/status-im/status-go/e2e"
	"github.com/status-im/status-go/geth/account"
	"github.com/status-im/status-go/geth/common"
	"github.com/status-im/status-go/geth/jail"
	"github.com/status-im/status-go/geth/log"
	"github.com/status-im/status-go/geth/node"
	"github.com/status-im/status-go/geth/params"
	. "github.com/status-im/status-go/testing"
	"github.com/stretchr/testify/suite"
)

func TestAPIBackendTestSuite(t *testing.T) {
	suite.Run(t, new(APIBackendTestSuite))
}

type APIBackendTestSuite struct {
	e2e.BackendTestSuite
}

// FIXME(tiabc): There's also a test with the same name in geth/node/manager_test.go
// so this test should only check StatusBackend logic with a mocked version of the underlying NodeManager.
func (s *APIBackendTestSuite) TestRaceConditions() {
	require := s.Require()
	require.NotNil(s.Backend)

	cnt := 25
	progress := make(chan struct{}, cnt)
	rnd := rand.New(rand.NewSource(time.Now().UnixNano()))

	nodeConfig1, err := e2e.MakeTestNodeConfig(GetNetworkID())
	require.NoError(err)

	nodeConfig2, err := e2e.MakeTestNodeConfig(GetNetworkID())
	require.NoError(err)

	nodeConfigs := []*params.NodeConfig{nodeConfig1, nodeConfig2}

	var funcsToTest = []func(*params.NodeConfig){
		func(config *params.NodeConfig) {
			log.Info("StartNode()")
			_, err := s.Backend.StartNode(config)
			s.T().Logf("StartNode() for network: %d, error: %v", config.NetworkID, err)
			progress <- struct{}{}
		},
		func(config *params.NodeConfig) {
			log.Info("StopNode()")
			_, err := s.Backend.StopNode()
			s.T().Logf("StopNode() for network: %d, error: %v", config.NetworkID, err)
			progress <- struct{}{}
		},
		// func(config *params.NodeConfig) {
		// 	log.Info("ResetChainData()")
		// 	_, err := s.Backend.ResetChainData()
		// 	s.T().Logf("ResetChainData(), error: %v", err)
		// 	progress <- struct{}{}
		// },
		func(config *params.NodeConfig) {
			log.Info("RestartNode()")
			_, err := s.Backend.RestartNode()
			s.T().Logf("RestartNode(), error: %v", err)
			progress <- struct{}{}
		},
		func(config *params.NodeConfig) {
			log.Info("NodeManager()")
			instance := s.Backend.NodeManager()
			s.NotNil(instance)
			s.IsType(&node.NodeManager{}, instance)
			s.T().Logf("NodeManager(), result: %v", instance)
			progress <- struct{}{}
		},
		func(config *params.NodeConfig) {
			log.Info("AccountManager()")
			instance := s.Backend.AccountManager()
			s.NotNil(instance)
			s.IsType(&account.Manager{}, instance)
			s.T().Logf("Manager(), result: %v", instance)
			progress <- struct{}{}
		},
		func(config *params.NodeConfig) {
			log.Info("JailManager()")
			instance := s.Backend.JailManager()
			s.NotNil(instance)
			s.IsType(&jail.Jail{}, instance)
			s.T().Logf("JailManager(), result: %v", instance)
			progress <- struct{}{}
		},
		func(config *params.NodeConfig) {
			log.Info("CreateAccount()")
			address, pubKey, mnemonic, err := s.Backend.AccountManager().CreateAccount("password")
			s.T().Logf("CreateAccount(), error: %v (address: %v, pubKey: %v, mnemonic: %v)", err, address, pubKey, mnemonic)
			if err != nil {
				progress <- struct{}{}
				return
			}

			// SelectAccount
			log.Info("CreateAccount()")
			err = s.Backend.AccountManager().SelectAccount(address, "password")
			s.T().Logf("SelectAccount(%v, %v), error: %v", address, "password", err)

			// CreateChildAccount
			log.Info("CreateChildAccount()")
			address, pubKey, err = s.Backend.AccountManager().CreateChildAccount(address, "password")
			s.T().Logf("CreateAccount(), error: %v (address: %v, pubKey: %v)", err, address, pubKey)

			// RecoverAccount
			log.Info("RecoverAccount()")
			address, pubKey, err = s.Backend.AccountManager().RecoverAccount("password", mnemonic)
			s.T().Logf("RecoverAccount(), error: %v (address: %v, pubKey: %v)", err, address, pubKey)

			progress <- struct{}{}
		},
		func(config *params.NodeConfig) {
			log.Info("VerifyAccountPassword()")
			_, err := s.Backend.AccountManager().VerifyAccountPassword(config.KeyStoreDir, "0x0", "bar")
			s.T().Logf("VerifyAccountPassword(), err: %v", err)
			progress <- struct{}{}
		},
		func(config *params.NodeConfig) {
			log.Info("Logout()")
			s.T().Logf("Logout(), result: %v", s.Backend.AccountManager().Logout())
			progress <- struct{}{}
		},
		func(config *params.NodeConfig) {
			log.Info("IsNodeRunning()")
			s.T().Logf("IsNodeRunning(), result: %v", s.Backend.IsNodeRunning())
			progress <- struct{}{}
		},
		func(config *params.NodeConfig) {
			log.Info("CompleteTransaction()")
			_, err := s.Backend.CompleteTransaction("id", "password")
			s.T().Logf("CompleteTransaction(), error: %v", err)
			progress <- struct{}{}
		},
		func(config *params.NodeConfig) {
			log.Info("DiscardTransaction()")
			s.T().Logf("DiscardTransaction(), error: %v", s.Backend.DiscardTransaction("id"))
			progress <- struct{}{}
		},
		func(config *params.NodeConfig) {
			log.Info("CompleteTransactions()")
			ids := []common.QueuedTxID{"id1", "id2"}
			s.T().Logf("CompleteTransactions(), result: %v", s.Backend.CompleteTransactions(ids, "password"))
			progress <- struct{}{}
		},
		func(config *params.NodeConfig) {
			log.Info("DiscardTransactions()")
			ids := []common.QueuedTxID{"id1", "id2"}
			s.T().Logf("DiscardTransactions(), result: %v", s.Backend.DiscardTransactions(ids))
			progress <- struct{}{}
		},
	}

	// increase StartNode()/StopNode() population
	for i := 0; i < 5; i++ {
		funcsToTest = append(funcsToTest, funcsToTest[0], funcsToTest[1])
	}

	for i := 0; i < cnt; i++ {
		randConfig := nodeConfigs[rnd.Intn(len(nodeConfigs))]
		randFunc := funcsToTest[rnd.Intn(len(funcsToTest))]

		if rnd.Intn(100) > 75 { // introduce random delays
			time.Sleep(500 * time.Millisecond)
		}
		go randFunc(randConfig)
	}

	for range progress {
		cnt -= 1
		if cnt <= 0 {
			break
		}
	}

	time.Sleep(2 * time.Second)            // so that we see some logs
	nodeStopped, _ := s.Backend.StopNode() // just in case we have a node running
	if nodeStopped != nil {
		<-nodeStopped
	}
}

// FIXME(tiabc): There's also a test with the same name in geth/node/manager_test.go
// so this test should only check StatusBackend logic with a mocked version of the underlying NodeManager.
func (s *APIBackendTestSuite) TestNetworkSwitching() {
	// get Ropsten config
	nodeConfig, err := e2e.MakeTestNodeConfig(GetNetworkID())
	s.NoError(err)

	s.False(s.Backend.IsNodeRunning())
	nodeStarted, err := s.Backend.StartNode(nodeConfig)
	s.NoError(err)

	<-nodeStarted // wait till node is started
	s.True(s.Backend.IsNodeRunning())

	firstHash, err := e2e.FirstBlockHash(s.Backend.NodeManager())
	s.NoError(err)
	s.Equal(GetHeadHash(), firstHash)

	// now stop node, and make sure that a new node, on different network can be started
	nodeStopped, err := s.Backend.StopNode()
	s.NoError(err)
	<-nodeStopped

	// start new node with completely different config
	nodeConfig, err = e2e.MakeTestNodeConfig(GetNetworkID())
	s.NoError(err)

	s.False(s.Backend.IsNodeRunning())
	nodeStarted, err = s.Backend.StartNode(nodeConfig)
	s.NoError(err)

	<-nodeStarted
	s.True(s.Backend.IsNodeRunning())

	// make sure we are on another network indeed
	firstHash, err = e2e.FirstBlockHash(s.Backend.NodeManager())
	s.NoError(err)
	s.Equal(GetHeadHash(), firstHash)

	nodeStopped, err = s.Backend.StopNode()
	s.NoError(err)
	<-nodeStopped
}

// FIXME(tiabc): There's also a test with the same name in geth/node/manager_test.go
// so this test should only check StatusBackend logic with a mocked version of the underlying NodeManager.
func (s *APIBackendTestSuite) TestResetChainData() {
	s.T().Skip()

	require := s.Require()
	require.NotNil(s.Backend)

	s.StartTestBackend()
	defer s.StopTestBackend()

	EnsureNodeSync(s.Backend.NodeManager())

	s.True(s.Backend.IsNodeRunning())
	nodeReady, err := s.Backend.ResetChainData()
	require.NoError(err)
	<-nodeReady
	s.True(s.Backend.IsNodeRunning()) // new node, with previous config should be running

	// make sure we can read the first byte, and it is valid (for Rinkeby)
	firstHash, err := e2e.FirstBlockHash(s.Backend.NodeManager())
	s.NoError(err)
	s.Equal(GetHeadHash(), firstHash)
}

// FIXME(tiabc): There's also a test with the same name in geth/node/manager_test.go
// so this test should only check StatusBackend logic with a mocked version of the underlying NodeManager.
func (s *APIBackendTestSuite) TestRestartNode() {
	require := s.Require()
	require.NotNil(s.Backend)

	// get config
	nodeConfig, err := e2e.MakeTestNodeConfig(GetNetworkID())
	s.NoError(err)

	s.False(s.Backend.IsNodeRunning())
	nodeStarted, err := s.Backend.StartNode(nodeConfig)
	s.NoError(err)

	<-nodeStarted // wait till node is started
	s.True(s.Backend.IsNodeRunning())

	firstHash, err := e2e.FirstBlockHash(s.Backend.NodeManager())
	s.NoError(err)
	s.Equal(GetHeadHash(), firstHash)

	s.True(s.Backend.IsNodeRunning())
	nodeRestarted, err := s.Backend.RestartNode()
	require.NoError(err)
	<-nodeRestarted
	s.True(s.Backend.IsNodeRunning()) // new node, with previous config should be running

	// make sure we can read the first byte, and it is valid (for Rinkeby)
	firstHash, err = e2e.FirstBlockHash(s.Backend.NodeManager())
	s.NoError(err)
	s.Equal(GetHeadHash(), firstHash)
}