github.com/hyperledger/burrow@v0.34.5-0.20220512172541-77f09336001d/integration/governance/identify_test.go (about)

     1  // +build integration
     2  
     3  package governance
     4  
     5  import (
     6  	"context"
     7  	"testing"
     8  
     9  	"github.com/hyperledger/burrow/config"
    10  	"github.com/hyperledger/burrow/consensus/tendermint"
    11  	"github.com/hyperledger/burrow/crypto"
    12  	"github.com/hyperledger/burrow/rpc/rpcquery"
    13  
    14  	"github.com/hyperledger/burrow/core"
    15  	"github.com/hyperledger/burrow/execution/registry"
    16  	"github.com/hyperledger/burrow/integration"
    17  	"github.com/hyperledger/burrow/integration/rpctest"
    18  	"github.com/hyperledger/burrow/txs/payload"
    19  	"github.com/stretchr/testify/require"
    20  )
    21  
    22  func TestIdentify(t *testing.T) {
    23  	accounts := integration.MakePrivateAccounts("accounts", 2)
    24  	kernels := make([]*core.Kernel, len(accounts))
    25  	configs := make([]*config.BurrowConfig, len(accounts))
    26  	genesisDoc := integration.TestGenesisDoc(accounts, 0)
    27  	var err error
    28  
    29  	for i, acc := range accounts {
    30  		configs[i], err = newConfig(genesisDoc, acc, accounts...)
    31  		require.NoError(t, err)
    32  		configs[i].Tendermint.IdentifyPeers = true
    33  	}
    34  
    35  	// start first validator
    36  	kernels[0], err = newKernelAndBoot(configs[0], accounts[0], accounts...)
    37  	require.NoError(t, err)
    38  	defer integration.Shutdown(kernels[0])
    39  
    40  	// identify first validator (self)
    41  	node := nodeFromConf(t,
    42  		configs[0],
    43  		configs[0].Tendermint.ListenAddress(),
    44  		accounts[0].ConcretePrivateAccount().PrivateKey)
    45  	identifyTx := payload.NewIdentifyTx(accounts[0].GetAddress(), node)
    46  	tcli := rpctest.NewTransactClient(t, kernels[0].GRPCListenAddress().String())
    47  	_, err = payloadSync(tcli, identifyTx)
    48  	require.NoError(t, err)
    49  
    50  	// start second node
    51  	kernels[1], err = newKernelAndBoot(configs[1], accounts[1], accounts...)
    52  	require.NoError(t, err)
    53  	defer integration.Shutdown(kernels[1])
    54  
    55  	// should not connect before identified
    56  	err = connectKernels(kernels[1], kernels[0])
    57  	require.Error(t, err)
    58  
    59  	// identify second node (from first)
    60  	node = nodeFromConf(t,
    61  		configs[1],
    62  		configs[1].Tendermint.ListenHost,
    63  		accounts[1].ConcretePrivateAccount().PrivateKey)
    64  	identifyTx = payload.NewIdentifyTx(accounts[1].GetAddress(), node)
    65  	_, err = payloadSync(tcli, identifyTx)
    66  	require.NoError(t, err)
    67  
    68  	// once identified, proceed
    69  	err = connectKernels(kernels[1], kernels[0])
    70  	require.NoError(t, err)
    71  
    72  	// query first validator for identities
    73  	qcli := rpctest.NewQueryClient(t, kernels[0].GRPCListenAddress().String())
    74  	nr, err := qcli.GetNetworkRegistry(context.TODO(), &rpcquery.GetNetworkRegistryParam{})
    75  	require.NoError(t, err)
    76  	netset := nr.GetSet()
    77  	require.Len(t, netset, 2)
    78  	addrs := make([]crypto.Address, len(netset))
    79  	for _, node := range netset {
    80  		addrs = append(addrs, node.Address)
    81  	}
    82  	require.Contains(t, addrs, accounts[0].GetAddress())
    83  	require.Contains(t, addrs, accounts[1].GetAddress())
    84  
    85  	// re-register node with different moniker
    86  	configs[1].Tendermint.Moniker = "foobar"
    87  	node = nodeFromConf(t,
    88  		configs[1],
    89  		configs[1].Tendermint.ListenHost,
    90  		accounts[1].ConcretePrivateAccount().PrivateKey)
    91  	identifyTx = payload.NewIdentifyTx(accounts[1].GetAddress(), node)
    92  	_, err = payloadSync(tcli, identifyTx)
    93  	require.NoError(t, err)
    94  
    95  	// should update second node
    96  	nr, err = qcli.GetNetworkRegistry(context.TODO(), &rpcquery.GetNetworkRegistryParam{})
    97  	require.NoError(t, err)
    98  	netset = nr.GetSet()
    99  	require.Len(t, netset, 2)
   100  	names := make([]string, len(netset))
   101  	for _, node := range netset {
   102  		names = append(names, node.Node.Moniker)
   103  	}
   104  	require.Contains(t, names, configs[1].Tendermint.Moniker)
   105  }
   106  
   107  func nodeFromConf(t *testing.T, conf *config.BurrowConfig, host string, val crypto.PrivateKey) *registry.NodeIdentity {
   108  	tmConf, err := conf.TendermintConfig()
   109  	require.NoError(t, err)
   110  	nodeKey, err := tendermint.EnsureNodeKey(tmConf.NodeKeyFile())
   111  	require.NoError(t, err)
   112  	addr, err := crypto.AddressFromHexString(string(nodeKey.ID()))
   113  	require.NoError(t, err)
   114  	return &registry.NodeIdentity{
   115  		Moniker:            conf.Tendermint.Moniker,
   116  		NetworkAddress:     host,
   117  		TendermintNodeID:   addr,
   118  		ValidatorPublicKey: val.GetPublicKey(),
   119  	}
   120  }