github.com/ChainSafe/chainbridge-core@v1.4.2/chains/evm/calls/contracts/contract_test.go (about)

     1  package contracts
     2  
     3  import (
     4  	"errors"
     5  	"github.com/ChainSafe/chainbridge-core/chains/evm/calls/consts"
     6  	mock_calls "github.com/ChainSafe/chainbridge-core/chains/evm/calls/mock"
     7  	"github.com/ChainSafe/chainbridge-core/chains/evm/calls/transactor"
     8  	mock_transactor "github.com/ChainSafe/chainbridge-core/chains/evm/calls/transactor/mock"
     9  	"github.com/ethereum/go-ethereum/accounts/abi"
    10  	"github.com/ethereum/go-ethereum/common"
    11  	"github.com/golang/mock/gomock"
    12  	"github.com/stretchr/testify/suite"
    13  	"math/big"
    14  	"strings"
    15  	"testing"
    16  )
    17  
    18  type ContractTestSuite struct {
    19  	suite.Suite
    20  	gomockController                   *gomock.Controller
    21  	mockContractCallerDispatcherClient *mock_calls.MockContractCallerDispatcher
    22  	mockTransactor                     *mock_transactor.MockTransactor
    23  	contract                           Contract
    24  }
    25  
    26  func TestRunContractTestSuite(t *testing.T) {
    27  	suite.Run(t, new(ContractTestSuite))
    28  }
    29  
    30  func (s *ContractTestSuite) SetupSuite()    {}
    31  func (s *ContractTestSuite) TearDownSuite() {}
    32  func (s *ContractTestSuite) SetupTest() {
    33  	s.gomockController = gomock.NewController(s.T())
    34  	s.mockContractCallerDispatcherClient = mock_calls.NewMockContractCallerDispatcher(s.gomockController)
    35  	s.mockTransactor = mock_transactor.NewMockTransactor(s.gomockController)
    36  	// Use ERC721 contract ABI inside the contract test
    37  	a, _ := abi.JSON(strings.NewReader(consts.ERC721PresetMinterPauserABI))
    38  	b := common.FromHex(consts.ERC721PresetMinterPauserBin)
    39  	s.contract = NewContract(
    40  		common.Address{}, a, b, s.mockContractCallerDispatcherClient, s.mockTransactor,
    41  	)
    42  }
    43  func (s *ContractTestSuite) TearDownTest() {}
    44  
    45  func (s *ContractTestSuite) TestContract_PackMethod_ValidRequest_Success() {
    46  	res, err := s.contract.PackMethod("approve", common.Address{}, big.NewInt(10))
    47  	s.Equal(
    48  		common.Hex2Bytes("095ea7b30000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000a"),
    49  		res,
    50  	)
    51  	s.Nil(err)
    52  }
    53  
    54  func (s *ContractTestSuite) TestContract_PackMethod_InvalidRequest_Fail() {
    55  	res, err := s.contract.PackMethod("invalid_method", common.Address{}, big.NewInt(10))
    56  	s.Equal([]byte{}, res)
    57  	s.NotNil(err)
    58  }
    59  
    60  func (s *ContractTestSuite) TestContract_UnpackResult_InvalidRequest_Fail() {
    61  	rawInvalidApproveData := common.Hex2Bytes("095ea7b30000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000a")
    62  	res, err := s.contract.UnpackResult("approve", rawInvalidApproveData)
    63  	s.NotNil(err)
    64  	s.Nil(res)
    65  }
    66  
    67  func (s *ContractTestSuite) TestContract_ExecuteTransaction_ValidRequest_Success() {
    68  	s.mockTransactor.EXPECT().Transact(
    69  		&common.Address{},
    70  		gomock.Any(),
    71  		transactor.TransactOptions{},
    72  	).Return(&common.Hash{}, nil)
    73  	hash, err := s.contract.ExecuteTransaction(
    74  		"approve",
    75  		transactor.TransactOptions{}, common.Address{}, big.NewInt(10),
    76  	)
    77  	s.Nil(err)
    78  	s.NotNil(hash)
    79  }
    80  
    81  func (s *ContractTestSuite) TestContract_ExecuteTransaction_TransactError_Fail() {
    82  	s.mockTransactor.EXPECT().Transact(
    83  		&common.Address{},
    84  		gomock.Any(),
    85  		transactor.TransactOptions{},
    86  	).Return(nil, errors.New("error"))
    87  	hash, err := s.contract.ExecuteTransaction(
    88  		"approve",
    89  		transactor.TransactOptions{}, common.Address{}, big.NewInt(10),
    90  	)
    91  	s.Nil(hash)
    92  	s.Error(err, "error")
    93  }
    94  
    95  func (s *ContractTestSuite) TestContract_ExecuteTransaction_InvalidRequest_Fail() {
    96  	hash, err := s.contract.ExecuteTransaction(
    97  		"approve",
    98  		transactor.TransactOptions{}, common.Address{}, // missing one argument
    99  	)
   100  	s.Nil(hash)
   101  	s.Error(err, "error")
   102  }
   103  
   104  func (s *ContractTestSuite) TestContract_CallContract_CallContractError_Fail() {
   105  	s.mockContractCallerDispatcherClient.EXPECT().CallContract(
   106  		gomock.Any(),
   107  		gomock.Any(),
   108  		nil,
   109  	).Return(nil, errors.New("error"))
   110  	s.mockContractCallerDispatcherClient.EXPECT().From().Times(1).Return(common.Address{})
   111  
   112  	res, err := s.contract.CallContract("ownerOf", big.NewInt(0))
   113  	if err != nil {
   114  		return
   115  	}
   116  	s.Nil(res)
   117  	s.Error(err, "error")
   118  }
   119  
   120  func (s *ContractTestSuite) TestContract_CallContract_InvalidRequest_Fail() {
   121  	res, err := s.contract.CallContract("invalidMethod", big.NewInt(0))
   122  	if err != nil {
   123  		return
   124  	}
   125  	s.Nil(res)
   126  	s.Error(err, "error")
   127  }
   128  
   129  func (s *ContractTestSuite) TestContract_CallContract_MissingContract_Fail() {
   130  	s.mockContractCallerDispatcherClient.EXPECT().CallContract(
   131  		gomock.Any(),
   132  		gomock.Any(),
   133  		nil,
   134  	).Return(nil, errors.New("error"))
   135  	s.mockContractCallerDispatcherClient.EXPECT().From().Times(1).Return(common.Address{})
   136  	res, err := s.contract.CallContract("ownerOf", big.NewInt(0))
   137  	if err != nil {
   138  		return
   139  	}
   140  	s.Nil(res)
   141  	s.Error(err, "error")
   142  }
   143  
   144  func (s *ContractTestSuite) TestContract_DeployContract_InvalidRequest_Fail() {
   145  	res, err := s.contract.DeployContract("invalid_param")
   146  	s.Equal(common.Address{}, res)
   147  	s.Error(err, "error")
   148  }
   149  
   150  func (s *ContractTestSuite) TestContract_DeployContract_TransactionError_Fail() {
   151  	s.mockTransactor.EXPECT().Transact(
   152  		nil, gomock.Any(), gomock.Any(),
   153  	).Times(1).Return(&common.Hash{}, errors.New("error"))
   154  	res, err := s.contract.DeployContract("TestERC721", "TST721", "")
   155  	s.Equal(common.Address{}, res)
   156  	s.Error(err, "error")
   157  }
   158  
   159  func (s *ContractTestSuite) TestContract_DeployContract_GetTxByHashError_Fail() {
   160  	s.mockTransactor.EXPECT().Transact(
   161  		nil, gomock.Any(), gomock.Any(),
   162  	).Times(1).Return(&common.Hash{}, nil)
   163  	s.mockContractCallerDispatcherClient.EXPECT().GetTransactionByHash(
   164  		common.Hash{},
   165  	).Return(nil, false, errors.New("error"))
   166  
   167  	res, err := s.contract.DeployContract("TestERC721", "TST721", "")
   168  	s.Equal(common.Address{}, res)
   169  	s.Error(err, "error")
   170  }