github.com/nspcc-dev/neo-go@v0.105.2-0.20240517133400-6be757af3eba/pkg/rpcclient/rolemgmt/roles_test.go (about)

     1  package rolemgmt
     2  
     3  import (
     4  	"errors"
     5  	"testing"
     6  
     7  	"github.com/nspcc-dev/neo-go/pkg/core/native/noderoles"
     8  	"github.com/nspcc-dev/neo-go/pkg/core/transaction"
     9  	"github.com/nspcc-dev/neo-go/pkg/crypto/keys"
    10  	"github.com/nspcc-dev/neo-go/pkg/neorpc/result"
    11  	"github.com/nspcc-dev/neo-go/pkg/util"
    12  	"github.com/nspcc-dev/neo-go/pkg/vm/stackitem"
    13  	"github.com/stretchr/testify/require"
    14  )
    15  
    16  type testAct struct {
    17  	err error
    18  	res *result.Invoke
    19  	tx  *transaction.Transaction
    20  	txh util.Uint256
    21  	vub uint32
    22  }
    23  
    24  func (t *testAct) Call(contract util.Uint160, operation string, params ...any) (*result.Invoke, error) {
    25  	return t.res, t.err
    26  }
    27  func (t *testAct) MakeCall(contract util.Uint160, method string, params ...any) (*transaction.Transaction, error) {
    28  	return t.tx, t.err
    29  }
    30  func (t *testAct) MakeUnsignedCall(contract util.Uint160, method string, attrs []transaction.Attribute, params ...any) (*transaction.Transaction, error) {
    31  	return t.tx, t.err
    32  }
    33  func (t *testAct) SendCall(contract util.Uint160, method string, params ...any) (util.Uint256, uint32, error) {
    34  	return t.txh, t.vub, t.err
    35  }
    36  
    37  func TestReaderGetDesignatedByRole(t *testing.T) {
    38  	ta := new(testAct)
    39  	rc := NewReader(ta)
    40  
    41  	ta.err = errors.New("")
    42  	_, err := rc.GetDesignatedByRole(noderoles.Oracle, 0)
    43  	require.Error(t, err)
    44  
    45  	ta.err = nil
    46  	ta.res = &result.Invoke{
    47  		State: "HALT",
    48  		Stack: []stackitem.Item{
    49  			stackitem.Make(100500),
    50  		},
    51  	}
    52  	_, err = rc.GetDesignatedByRole(noderoles.Oracle, 0)
    53  	require.Error(t, err)
    54  
    55  	ta.res = &result.Invoke{
    56  		State: "HALT",
    57  		Stack: []stackitem.Item{
    58  			stackitem.Null{},
    59  		},
    60  	}
    61  	_, err = rc.GetDesignatedByRole(noderoles.Oracle, 0)
    62  	require.Error(t, err)
    63  
    64  	ta.res = &result.Invoke{
    65  		State: "HALT",
    66  		Stack: []stackitem.Item{
    67  			stackitem.Make([]stackitem.Item{}),
    68  		},
    69  	}
    70  	nodes, err := rc.GetDesignatedByRole(noderoles.Oracle, 0)
    71  	require.NoError(t, err)
    72  	require.NotNil(t, nodes)
    73  	require.Equal(t, 0, len(nodes))
    74  
    75  	ta.res = &result.Invoke{
    76  		State: "HALT",
    77  		Stack: []stackitem.Item{
    78  			stackitem.Make([]stackitem.Item{stackitem.Null{}}),
    79  		},
    80  	}
    81  	_, err = rc.GetDesignatedByRole(noderoles.Oracle, 0)
    82  	require.Error(t, err)
    83  
    84  	ta.res = &result.Invoke{
    85  		State: "HALT",
    86  		Stack: []stackitem.Item{
    87  			stackitem.Make([]stackitem.Item{stackitem.Make(42)}),
    88  		},
    89  	}
    90  	_, err = rc.GetDesignatedByRole(noderoles.Oracle, 0)
    91  	require.Error(t, err)
    92  
    93  	k, err := keys.NewPrivateKey()
    94  	require.NoError(t, err)
    95  	ta.res = &result.Invoke{
    96  		State: "HALT",
    97  		Stack: []stackitem.Item{
    98  			stackitem.Make([]stackitem.Item{stackitem.Make(k.PublicKey().Bytes())}),
    99  		},
   100  	}
   101  	nodes, err = rc.GetDesignatedByRole(noderoles.Oracle, 0)
   102  	require.NoError(t, err)
   103  	require.NotNil(t, nodes)
   104  	require.Equal(t, 1, len(nodes))
   105  	require.Equal(t, k.PublicKey(), nodes[0])
   106  }
   107  
   108  func TestDesignateAsRole(t *testing.T) {
   109  	ta := new(testAct)
   110  	rc := New(ta)
   111  
   112  	k, err := keys.NewPrivateKey()
   113  	require.NoError(t, err)
   114  	ks := keys.PublicKeys{k.PublicKey()}
   115  
   116  	ta.err = errors.New("")
   117  	_, _, err = rc.DesignateAsRole(noderoles.Oracle, ks)
   118  	require.Error(t, err)
   119  
   120  	ta.err = nil
   121  	ta.txh = util.Uint256{1, 2, 3}
   122  	ta.vub = 42
   123  	h, vub, err := rc.DesignateAsRole(noderoles.Oracle, ks)
   124  	require.NoError(t, err)
   125  	require.Equal(t, ta.txh, h)
   126  	require.Equal(t, ta.vub, vub)
   127  }
   128  
   129  func TestDesignateAsRoleTransaction(t *testing.T) {
   130  	ta := new(testAct)
   131  	rc := New(ta)
   132  
   133  	k, err := keys.NewPrivateKey()
   134  	require.NoError(t, err)
   135  	ks := keys.PublicKeys{k.PublicKey()}
   136  
   137  	for _, fun := range []func(r noderoles.Role, pubs keys.PublicKeys) (*transaction.Transaction, error){
   138  		rc.DesignateAsRoleTransaction,
   139  		rc.DesignateAsRoleUnsigned,
   140  	} {
   141  		ta.err = errors.New("")
   142  		_, err := fun(noderoles.P2PNotary, ks)
   143  		require.Error(t, err)
   144  
   145  		ta.err = nil
   146  		ta.tx = &transaction.Transaction{Nonce: 100500, ValidUntilBlock: 42}
   147  		tx, err := fun(noderoles.P2PNotary, ks)
   148  		require.NoError(t, err)
   149  		require.Equal(t, ta.tx, tx)
   150  	}
   151  }