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

     1  // +build integration
     2  
     3  package rpctransact
     4  
     5  import (
     6  	"context"
     7  	"testing"
     8  
     9  	"github.com/hyperledger/burrow/integration"
    10  
    11  	"github.com/hyperledger/burrow/event"
    12  	"github.com/hyperledger/burrow/execution/exec"
    13  	"github.com/hyperledger/burrow/execution/names"
    14  	"github.com/hyperledger/burrow/integration/rpctest"
    15  	"github.com/hyperledger/burrow/rpc/rpcquery"
    16  	"github.com/hyperledger/burrow/txs/payload"
    17  	"github.com/stretchr/testify/assert"
    18  	"github.com/stretchr/testify/require"
    19  )
    20  
    21  func TestNameTx(t *testing.T) {
    22  	t.Parallel()
    23  	kern, shutdown := integration.RunNode(t, rpctest.GenesisDoc, rpctest.PrivateAccounts)
    24  	defer shutdown()
    25  
    26  	waitNBlocks := func(n uint64) {
    27  		subID := event.GenSubID()
    28  		ch, err := kern.Emitter.Subscribe(context.Background(), subID, exec.QueryForBlockExecution(), 10)
    29  		require.NoError(t, err)
    30  		defer kern.Emitter.UnsubscribeAll(context.Background(), subID)
    31  		for i := uint64(0); i < n; i++ {
    32  			<-ch
    33  		}
    34  	}
    35  
    36  	t.Run("Sync", func(t *testing.T) {
    37  		cli := rpctest.NewTransactClient(t, kern.GRPCListenAddress().String())
    38  		name := "Flub"
    39  		data := "floooo"
    40  		expiresIn := uint64(100)
    41  		_, err := cli.NameTxSync(context.Background(), &payload.NameTx{
    42  			Input: &payload.TxInput{
    43  				Address: inputAddress,
    44  				Amount:  names.NameCostForExpiryIn(name, data, expiresIn),
    45  			},
    46  			Name: name,
    47  			Data: data,
    48  		})
    49  		require.NoError(t, err)
    50  
    51  		qcli := rpctest.NewQueryClient(t, kern.GRPCListenAddress().String())
    52  		entry, err := qcli.GetName(context.Background(), &rpcquery.GetNameParam{
    53  			Name: "n'existe pas",
    54  		})
    55  		require.Error(t, err)
    56  		entry, err = qcli.GetName(context.Background(), &rpcquery.GetNameParam{
    57  			Name: name,
    58  		})
    59  		require.NoError(t, err)
    60  		assert.Equal(t, name, entry.Name)
    61  		assert.Equal(t, data, entry.Data)
    62  		assert.Equal(t, inputAddress, entry.Owner)
    63  		assert.True(t, entry.Expires >= expiresIn, "expiry should be later than expiresIn")
    64  
    65  	})
    66  
    67  	t.Run("Registry", func(t *testing.T) {
    68  		tcli := rpctest.NewTransactClient(t, kern.GRPCListenAddress().String())
    69  		qcli := rpctest.NewQueryClient(t, kern.GRPCListenAddress().String())
    70  		names.MinNameRegistrationPeriod = 1
    71  
    72  		// register a new name, check if its there
    73  		// since entries ought to be unique and these run against different clients, we append the client
    74  		name := "ye_old_domain_name"
    75  		const data = "if not now, when"
    76  		numDesiredBlocks := uint64(2)
    77  
    78  		txe, err := rpctest.UpdateName(tcli, inputAddress, name, data, numDesiredBlocks)
    79  		require.NoError(t, err)
    80  
    81  		entry := txe.Result.NameEntry
    82  		assert.NotNil(t, entry, "name should return")
    83  		_, ok := txe.Envelope.Tx.Payload.(*payload.NameTx)
    84  		require.True(t, ok, "should be NameTx: %v", txe.Envelope.Tx.Payload)
    85  
    86  		assert.Equal(t, name, entry.Name)
    87  		assert.Equal(t, data, entry.Data)
    88  
    89  		entryQuery, err := qcli.GetName(context.Background(), &rpcquery.GetNameParam{Name: name})
    90  		require.NoError(t, err)
    91  
    92  		assert.Equal(t, entry, entryQuery)
    93  
    94  		// update the data as the owner, make sure still there
    95  		numDesiredBlocks = uint64(3)
    96  		const updatedData = "these are amongst the things I wish to bestow upon " +
    97  			"the youth of generations come: a safe supply of honey, and a better " +
    98  			"money. For what else shall they need"
    99  		_, err = rpctest.UpdateName(tcli, inputAddress, name, updatedData, numDesiredBlocks)
   100  		require.NoError(t, err)
   101  
   102  		entry, err = qcli.GetName(context.Background(), &rpcquery.GetNameParam{Name: name})
   103  		require.NoError(t, err)
   104  
   105  		assert.Equal(t, updatedData, entry.Data)
   106  
   107  		// try to update as non owner, should fail
   108  		txe, err = tcli.NameTxSync(context.Background(), &payload.NameTx{
   109  			Input: &payload.TxInput{
   110  				Address: rpctest.PrivateAccounts[1].GetAddress(),
   111  				Amount:  names.NameCostForExpiryIn(name, data, numDesiredBlocks),
   112  			},
   113  			Name: name,
   114  			Data: "flub flub floo",
   115  		})
   116  		require.Error(t, err, "updating as non-owner on non-expired name should fail")
   117  		assert.Contains(t, err.Error(), "permission denied")
   118  
   119  		waitNBlocks(numDesiredBlocks)
   120  		//now the entry should be expired, so we can update as non owner
   121  		const data2 = "this is not my beautiful house"
   122  		owner := rpctest.PrivateAccounts[3].GetAddress()
   123  		txe, err = rpctest.UpdateName(tcli, owner, name, data2, numDesiredBlocks)
   124  		require.NoError(t, err)
   125  		entry = txe.Result.NameEntry
   126  
   127  		entryQuery, err = qcli.GetName(context.Background(), &rpcquery.GetNameParam{Name: name})
   128  		require.NoError(t, err)
   129  		assert.Equal(t, entry, entryQuery)
   130  		assert.Equal(t, data2, entry.Data)
   131  		assert.Equal(t, owner, entry.Owner)
   132  	})
   133  
   134  }