github.com/algorand/go-algorand-sdk@v1.24.0/abi/interactions_test.go (about)

     1  package abi
     2  
     3  import (
     4  	"encoding/json"
     5  	"testing"
     6  
     7  	"github.com/stretchr/testify/require"
     8  )
     9  
    10  func TestMethodFromSignature(t *testing.T) {
    11  	Uint32, err := TypeOf("uint32")
    12  	require.NoError(t, err)
    13  
    14  	expectedArgs := []Arg{
    15  		{Name: "", Type: "uint32", typeObject: &Uint32, Desc: ""},
    16  		{Name: "", Type: "uint32", typeObject: &Uint32, Desc: ""},
    17  	}
    18  	expected := Method{
    19  		Name:    "add",
    20  		Desc:    "",
    21  		Args:    expectedArgs,
    22  		Returns: Return{Type: "uint32", typeObject: &Uint32, Desc: ""},
    23  	}
    24  
    25  	methodSig := "add(uint32,uint32)uint32"
    26  	result, err := MethodFromSignature(methodSig)
    27  
    28  	require.NoError(t, err)
    29  	require.Equal(t, result, expected)
    30  }
    31  
    32  func TestMethodFromSignatureWithTuple(t *testing.T) {
    33  	Uint32, err := TypeOf("uint32")
    34  	require.NoError(t, err)
    35  
    36  	Uint32Tuple, err := TypeOf("(uint32,uint32)")
    37  	require.NoError(t, err)
    38  
    39  	Uint32TupleTuple, err := TypeOf("(uint32,(uint32,uint32))")
    40  	require.NoError(t, err)
    41  
    42  	expectedArgs := []Arg{
    43  		{Name: "", Type: "(uint32,(uint32,uint32))", typeObject: &Uint32TupleTuple, Desc: ""},
    44  		{Name: "", Type: "uint32", typeObject: &Uint32, Desc: ""},
    45  	}
    46  	expected := Method{
    47  		Name:    "add",
    48  		Desc:    "",
    49  		Args:    expectedArgs,
    50  		Returns: Return{Type: "(uint32,uint32)", typeObject: &Uint32Tuple, Desc: ""},
    51  	}
    52  
    53  	methodSig := "add((uint32,(uint32,uint32)),uint32)(uint32,uint32)"
    54  	result, err := MethodFromSignature(methodSig)
    55  
    56  	require.NoError(t, err)
    57  	require.Equal(t, expected, result)
    58  }
    59  
    60  func TestMethodFromSignatureWithVoidReturn(t *testing.T) {
    61  	Uint32, err := TypeOf("uint32")
    62  	require.NoError(t, err)
    63  
    64  	expectedArgs := []Arg{
    65  		{Name: "", Type: "uint32", typeObject: &Uint32, Desc: ""},
    66  		{Name: "", Type: "uint32", typeObject: &Uint32, Desc: ""},
    67  	}
    68  	expected := Method{
    69  		Name:    "add",
    70  		Desc:    "",
    71  		Args:    expectedArgs,
    72  		Returns: Return{Type: "void", Desc: ""},
    73  	}
    74  
    75  	methodSig := "add(uint32,uint32)void"
    76  	result, err := MethodFromSignature(methodSig)
    77  
    78  	require.NoError(t, err)
    79  	require.Equal(t, expected, result)
    80  }
    81  
    82  func TestMethodFromSignatureWithNoArgs(t *testing.T) {
    83  	expectedArgs := []Arg{}
    84  	expected := Method{
    85  		Name:    "add",
    86  		Desc:    "",
    87  		Args:    expectedArgs,
    88  		Returns: Return{Type: "void", Desc: ""},
    89  	}
    90  
    91  	methodSig := "add()void"
    92  	result, err := MethodFromSignature(methodSig)
    93  
    94  	require.NoError(t, err)
    95  	require.Equal(t, expected, result)
    96  }
    97  
    98  func TestMethodFromSignatureInvalidFormat(t *testing.T) {
    99  	methodSig := "add)uint32,uint32)uint32"
   100  	_, err := MethodFromSignature(methodSig)
   101  	require.Error(t, err)
   102  
   103  	methodSig = "add(uint32, uint32)uint32"
   104  	_, err = MethodFromSignature(methodSig)
   105  	require.Error(t, err)
   106  
   107  	methodSig = "(uint32,uint32)uint32"
   108  	_, err = MethodFromSignature(methodSig)
   109  	require.Error(t, err)
   110  
   111  	methodSig = "add((uint32, uint32)uint32"
   112  	_, err = MethodFromSignature(methodSig)
   113  	require.Error(t, err)
   114  }
   115  
   116  func TestMethodFromSignatureInvalidAbiType(t *testing.T) {
   117  	methodSig := "add(uint32,uint32)int32"
   118  	_, err := MethodFromSignature(methodSig)
   119  	require.Error(t, err)
   120  }
   121  
   122  func TestGetSignature(t *testing.T) {
   123  	expectedArgs := []Arg{
   124  		{Name: "", Type: "uint32", Desc: ""},
   125  		{Name: "", Type: "uint32", Desc: ""},
   126  	}
   127  
   128  	method := Method{
   129  		Name:    "add",
   130  		Desc:    "",
   131  		Args:    expectedArgs,
   132  		Returns: Return{Type: "uint32", Desc: ""},
   133  	}
   134  
   135  	expected := "add(uint32,uint32)uint32"
   136  	require.Equal(t, method.GetSignature(), expected)
   137  }
   138  
   139  func TestGetSelector(t *testing.T) {
   140  	args := []Arg{
   141  		{Name: "", Type: "uint32", Desc: ""},
   142  		{Name: "", Type: "uint32", Desc: ""},
   143  	}
   144  
   145  	method := Method{
   146  		Name:    "add",
   147  		Desc:    "",
   148  		Args:    args,
   149  		Returns: Return{Type: "uint32", Desc: ""},
   150  	}
   151  
   152  	expected := []byte{0x3e, 0x1e, 0x52, 0xbd}
   153  	require.Equal(t, method.GetSelector(), expected)
   154  }
   155  
   156  func TestEncodeJsonMethod(t *testing.T) {
   157  	args := []Arg{
   158  		{Name: "0", Type: "uint32", Desc: ""},
   159  		{Name: "1", Type: "uint32", Desc: ""},
   160  	}
   161  
   162  	method := Method{
   163  		Name:    "add",
   164  		Desc:    "",
   165  		Args:    args,
   166  		Returns: Return{Type: "uint32", Desc: ""},
   167  	}
   168  
   169  	expected := `{"name":"add","args":[{"name":"0","type":"uint32"},{"name":"1","type":"uint32"}],"returns":{"type":"uint32"}}`
   170  
   171  	jsonMethod, err := json.Marshal(method)
   172  	require.NoError(t, err)
   173  	require.Equal(t, expected, string(jsonMethod))
   174  }
   175  
   176  func TestEncodeJsonMethodWithDescription(t *testing.T) {
   177  	args := []Arg{
   178  		{Name: "0", Type: "uint32", Desc: "description"},
   179  		{Name: "1", Type: "uint32", Desc: "description"},
   180  	}
   181  
   182  	method := Method{
   183  		Name:    "add",
   184  		Desc:    "description",
   185  		Args:    args,
   186  		Returns: Return{Type: "uint32", Desc: "description"},
   187  	}
   188  
   189  	expected := `{"name":"add","desc":"description","args":[{"name":"0","type":"uint32","desc":"description"},{"name":"1","type":"uint32","desc":"description"}],"returns":{"type":"uint32","desc":"description"}}`
   190  
   191  	jsonMethod, err := json.Marshal(method)
   192  	require.NoError(t, err)
   193  	require.Equal(t, expected, string(jsonMethod))
   194  }
   195  
   196  func TestEncodeJsonInterface(t *testing.T) {
   197  	args := []Arg{
   198  		{Name: "0", Type: "uint32", Desc: ""},
   199  		{Name: "1", Type: "uint32", Desc: ""},
   200  	}
   201  
   202  	method := Method{
   203  		Name:    "add",
   204  		Desc:    "",
   205  		Args:    args,
   206  		Returns: Return{Type: "uint32", Desc: ""},
   207  	}
   208  
   209  	interfaceObject := Interface{
   210  		Name:    "interface",
   211  		Methods: []Method{method},
   212  	}
   213  
   214  	expected := `{"name":"interface","methods":[{"name":"add","args":[{"name":"0","type":"uint32"},{"name":"1","type":"uint32"}],"returns":{"type":"uint32"}}]}`
   215  
   216  	jsonInterface, err := json.Marshal(interfaceObject)
   217  	require.NoError(t, err)
   218  	require.Equal(t, expected, string(jsonInterface))
   219  }
   220  
   221  func TestEncodeJsonInterfaceWithDescription(t *testing.T) {
   222  	args := []Arg{
   223  		{Name: "0", Type: "uint32", Desc: "description"},
   224  		{Name: "1", Type: "uint32", Desc: "description"},
   225  	}
   226  
   227  	method := Method{
   228  		Name:    "add",
   229  		Desc:    "description",
   230  		Args:    args,
   231  		Returns: Return{Type: "uint32", Desc: "description"},
   232  	}
   233  
   234  	interfaceObject := Interface{
   235  		Name:    "interface",
   236  		Methods: []Method{method},
   237  	}
   238  
   239  	expected := `{"name":"interface","methods":[{"name":"add","desc":"description","args":[{"name":"0","type":"uint32","desc":"description"},{"name":"1","type":"uint32","desc":"description"}],"returns":{"type":"uint32","desc":"description"}}]}`
   240  
   241  	jsonInterface, err := json.Marshal(interfaceObject)
   242  	require.NoError(t, err)
   243  	require.Equal(t, expected, string(jsonInterface))
   244  }
   245  
   246  func TestEncodeJsonContract(t *testing.T) {
   247  	args := []Arg{
   248  		{Name: "0", Type: "uint32", Desc: ""},
   249  		{Name: "1", Type: "uint32", Desc: ""},
   250  	}
   251  
   252  	method := Method{
   253  		Name:    "add",
   254  		Desc:    "",
   255  		Args:    args,
   256  		Returns: Return{Type: "uint32", Desc: ""},
   257  	}
   258  
   259  	network := ContractNetworkInfo{AppID: 123}
   260  
   261  	contract := Contract{
   262  		Name:     "contract",
   263  		Networks: map[string]ContractNetworkInfo{"genesis hash": network},
   264  		Methods:  []Method{method},
   265  	}
   266  
   267  	expected := `{"name":"contract","networks":{"genesis hash":{"appID":123}},"methods":[{"name":"add","args":[{"name":"0","type":"uint32"},{"name":"1","type":"uint32"}],"returns":{"type":"uint32"}}]}`
   268  
   269  	jsonContract, err := json.Marshal(contract)
   270  	require.NoError(t, err)
   271  	require.Equal(t, expected, string(jsonContract))
   272  }
   273  
   274  func TestEncodeJsonContractWithDescription(t *testing.T) {
   275  	args := []Arg{
   276  		{Name: "0", Type: "uint32", Desc: "description"},
   277  		{Name: "1", Type: "uint32", Desc: "description"},
   278  	}
   279  
   280  	method := Method{
   281  		Name:    "add",
   282  		Desc:    "description",
   283  		Args:    args,
   284  		Returns: Return{Type: "uint32", Desc: "description"},
   285  	}
   286  
   287  	network := ContractNetworkInfo{AppID: 123}
   288  
   289  	contract := Contract{
   290  		Name:     "contract",
   291  		Desc:     "description for contract",
   292  		Networks: map[string]ContractNetworkInfo{"genesis hash": network},
   293  		Methods:  []Method{method},
   294  	}
   295  
   296  	expected := `{"name":"contract","desc":"description for contract","networks":{"genesis hash":{"appID":123}},"methods":[{"name":"add","desc":"description","args":[{"name":"0","type":"uint32","desc":"description"},{"name":"1","type":"uint32","desc":"description"}],"returns":{"type":"uint32","desc":"description"}}]}`
   297  
   298  	jsonContract, err := json.Marshal(contract)
   299  	require.NoError(t, err)
   300  	require.Equal(t, expected, string(jsonContract))
   301  }