github.com/ChainSafe/chainbridge-core@v1.4.2/chains/evm/cli/bridge/vote-proposal_test.go (about)

     1  package bridge_test
     2  
     3  import (
     4  	"encoding/hex"
     5  	"errors"
     6  	"testing"
     7  
     8  	"github.com/ChainSafe/chainbridge-core/chains/evm/calls"
     9  	"github.com/ChainSafe/chainbridge-core/chains/evm/calls/transactor"
    10  	"github.com/ChainSafe/chainbridge-core/chains/evm/cli"
    11  	"github.com/ChainSafe/chainbridge-core/chains/evm/cli/bridge"
    12  	mock_bridge "github.com/ChainSafe/chainbridge-core/chains/evm/cli/bridge/mock"
    13  	"github.com/ChainSafe/chainbridge-core/chains/evm/executor/proposal"
    14  	"github.com/ethereum/go-ethereum/common"
    15  	"github.com/golang/mock/gomock"
    16  	"github.com/spf13/cobra"
    17  	"github.com/stretchr/testify/suite"
    18  )
    19  
    20  type VoteProposalTestSuite struct {
    21  	suite.Suite
    22  	gomockController    *gomock.Controller
    23  	mockVoteProposalCmd *cobra.Command
    24  	voter               *mock_bridge.MockVoter
    25  }
    26  
    27  func TestRunVoteProposalTestSuite(t *testing.T) {
    28  	suite.Run(t, new(VoteProposalTestSuite))
    29  }
    30  
    31  func (s *VoteProposalTestSuite) SetupSuite()    {}
    32  func (s *VoteProposalTestSuite) TearDownSuite() {}
    33  func (s *VoteProposalTestSuite) SetupTest() {
    34  	s.gomockController = gomock.NewController(s.T())
    35  	s.voter = mock_bridge.NewMockVoter(s.gomockController)
    36  
    37  	s.mockVoteProposalCmd = &cobra.Command{
    38  		RunE: func(cmd *cobra.Command, args []string) error {
    39  			return bridge.VoteProposalCmd(
    40  				cmd,
    41  				args,
    42  				s.voter)
    43  		},
    44  		Args: func(cmd *cobra.Command, args []string) error {
    45  			err := bridge.ValidateVoteProposalFlags(cmd, args)
    46  			if err != nil {
    47  				return err
    48  			}
    49  
    50  			err = bridge.ProcessVoteProposalFlags(cmd, args)
    51  			return err
    52  		},
    53  	}
    54  	cli.BindEVMCLIFlags(s.mockVoteProposalCmd)
    55  	bridge.BindVoteProposalCmdFlags(s.mockVoteProposalCmd)
    56  }
    57  
    58  func (s *VoteProposalTestSuite) TestValidate_InvalidBridgeAddress() {
    59  	rootCmdArgs := []string{
    60  		"--url", "test-url",
    61  		"--private-key", "test-private-key",
    62  		"--bridge", "invalid",
    63  		"--data", "hex-data",
    64  		"--resource", "test-resource",
    65  		"--domain", "1",
    66  	}
    67  	s.mockVoteProposalCmd.SetArgs(rootCmdArgs)
    68  
    69  	err := s.mockVoteProposalCmd.Execute()
    70  
    71  	s.NotNil(err)
    72  	s.Equal(err.Error(), "invalid bridge address: invalid")
    73  }
    74  
    75  func (s *VoteProposalTestSuite) TestValidate_InvalidResourceID() {
    76  	rootCmdArgs := []string{
    77  		"--url", "test-url",
    78  		"--private-key", "test-private-key",
    79  		"--bridge", "0x829bd824b016326a401d083b33d092293333a830",
    80  		"--data", "hex-data",
    81  		"--resource", "111",
    82  		"--domain", "1",
    83  	}
    84  	s.mockVoteProposalCmd.SetArgs(rootCmdArgs)
    85  
    86  	err := s.mockVoteProposalCmd.Execute()
    87  
    88  	s.NotNil(err)
    89  	s.Equal(err.Error(), "failed decoding resourceID hex string: encoding/hex: odd length hex string")
    90  }
    91  
    92  func (s *VoteProposalTestSuite) TestValidate_FailedSimulateCall() {
    93  	rootCmdArgs := []string{
    94  		"--url", "test-url",
    95  		"--private-key", "test-private-key",
    96  		"--bridge", "0x829bd824b016326a401d083b33d092293333a830",
    97  		"--data", "00000000000000000000000000000000000000000000000000000000000f424000000000000000000000000000000000000000000000000000000000000000148e0a907331554af72563bd8d43051c2e64be5d35",
    98  		"--resource", "0x000000000000000000000075df75bcdca8ea2360c562b4aadbaf3dfaf5b19b00",
    99  		"--deposit-nonce", "2",
   100  		"--domain", "1",
   101  	}
   102  	s.mockVoteProposalCmd.SetArgs(rootCmdArgs)
   103  	resourceID, _ := hex.DecodeString("000000000000000000000075df75bcdca8ea2360c562b4aadbaf3dfaf5b19b00")
   104  	s.voter.EXPECT().SimulateVoteProposal(&proposal.Proposal{
   105  		Source:       1,
   106  		DepositNonce: 2,
   107  		Data:         common.Hex2Bytes("00000000000000000000000000000000000000000000000000000000000f424000000000000000000000000000000000000000000000000000000000000000148e0a907331554af72563bd8d43051c2e64be5d35"),
   108  		ResourceId:   calls.SliceTo32Bytes(resourceID),
   109  	}).Return(errors.New("failed simulating call"))
   110  
   111  	err := s.mockVoteProposalCmd.Execute()
   112  
   113  	s.NotNil(err)
   114  	s.Equal(err.Error(), "failed simulating call")
   115  }
   116  
   117  func (s *VoteProposalTestSuite) TestValidate_FailedVoteCall() {
   118  	rootCmdArgs := []string{
   119  		"--url", "test-url",
   120  		"--private-key", "test-private-key",
   121  		"--bridge", "0x829bd824b016326a401d083b33d092293333a830",
   122  		"--data", "00000000000000000000000000000000000000000000000000000000000f424000000000000000000000000000000000000000000000000000000000000000148e0a907331554af72563bd8d43051c2e64be5d35",
   123  		"--resource", "0x000000000000000000000075df75bcdca8ea2360c562b4aadbaf3dfaf5b19b00",
   124  		"--deposit-nonce", "2",
   125  		"--domain", "1",
   126  	}
   127  	s.mockVoteProposalCmd.SetArgs(rootCmdArgs)
   128  	resourceID, _ := hex.DecodeString("000000000000000000000075df75bcdca8ea2360c562b4aadbaf3dfaf5b19b00")
   129  	s.voter.EXPECT().SimulateVoteProposal(&proposal.Proposal{
   130  		Source:       1,
   131  		DepositNonce: 2,
   132  		Data:         common.Hex2Bytes("00000000000000000000000000000000000000000000000000000000000f424000000000000000000000000000000000000000000000000000000000000000148e0a907331554af72563bd8d43051c2e64be5d35"),
   133  		ResourceId:   calls.SliceTo32Bytes(resourceID),
   134  	}).Return(nil)
   135  	s.voter.EXPECT().VoteProposal(&proposal.Proposal{
   136  		Source:       1,
   137  		DepositNonce: 2,
   138  		Data:         common.Hex2Bytes("00000000000000000000000000000000000000000000000000000000000f424000000000000000000000000000000000000000000000000000000000000000148e0a907331554af72563bd8d43051c2e64be5d35"),
   139  		ResourceId:   calls.SliceTo32Bytes(resourceID),
   140  	}, transactor.TransactOptions{}).Return(&common.Hash{}, errors.New("failed vote call"))
   141  
   142  	err := s.mockVoteProposalCmd.Execute()
   143  
   144  	s.NotNil(err)
   145  	s.Equal(err.Error(), "failed vote call")
   146  }
   147  
   148  func (s *VoteProposalTestSuite) TestValidate_SuccessfulVote() {
   149  	rootCmdArgs := []string{
   150  		"--url", "test-url",
   151  		"--private-key", "test-private-key",
   152  		"--bridge", "0x829bd824b016326a401d083b33d092293333a830",
   153  		"--data", "00000000000000000000000000000000000000000000000000000000000f424000000000000000000000000000000000000000000000000000000000000000148e0a907331554af72563bd8d43051c2e64be5d35",
   154  		"--resource", "0x000000000000000000000075df75bcdca8ea2360c562b4aadbaf3dfaf5b19b00",
   155  		"--deposit-nonce", "2",
   156  		"--domain", "1",
   157  	}
   158  	s.mockVoteProposalCmd.SetArgs(rootCmdArgs)
   159  	resourceID, _ := hex.DecodeString("000000000000000000000075df75bcdca8ea2360c562b4aadbaf3dfaf5b19b00")
   160  	s.voter.EXPECT().SimulateVoteProposal(&proposal.Proposal{
   161  		Source:       1,
   162  		DepositNonce: 2,
   163  		Data:         common.Hex2Bytes("00000000000000000000000000000000000000000000000000000000000f424000000000000000000000000000000000000000000000000000000000000000148e0a907331554af72563bd8d43051c2e64be5d35"),
   164  		ResourceId:   calls.SliceTo32Bytes(resourceID),
   165  	}).Return(nil)
   166  	s.voter.EXPECT().VoteProposal(&proposal.Proposal{
   167  		Source:       1,
   168  		DepositNonce: 2,
   169  		Data:         common.Hex2Bytes("00000000000000000000000000000000000000000000000000000000000f424000000000000000000000000000000000000000000000000000000000000000148e0a907331554af72563bd8d43051c2e64be5d35"),
   170  		ResourceId:   calls.SliceTo32Bytes(resourceID),
   171  	}, transactor.TransactOptions{}).Return(&common.Hash{}, nil)
   172  
   173  	err := s.mockVoteProposalCmd.Execute()
   174  
   175  	s.Nil(err)
   176  }