neo-go/pkg/rpc/stack_param_test.go

package rpc

import (
	"encoding/hex"
	"encoding/json"
	"reflect"
	"testing"

	"github.com/CityOfZion/neo-go/pkg/util"
)

var testCases = []struct {
	input  string
	result StackParam
}{
	{
		input:  `{"type":"Integer","value":12345}`,
		result: StackParam{Type: Integer, Value: int64(12345)},
	},
	{
		input:  `{"type":"Integer","value":"12345"}`,
		result: StackParam{Type: Integer, Value: int64(12345)},
	},
	{
		input:  `{"type":"ByteArray","value":"010203"}`,
		result: StackParam{Type: ByteArray, Value: []byte{0x01, 0x02, 0x03}},
	},
	{
		input:  `{"type":"String","value":"Some string"}`,
		result: StackParam{Type: String, Value: "Some string"},
	},
	{
		input: `{"type":"Array","value":[
{"type": "String", "value": "str 1"},
{"type": "Integer", "value": 2}]}`,
		result: StackParam{
			Type: Array,
			Value: []StackParam{
				{Type: String, Value: "str 1"},
				{Type: Integer, Value: int64(2)},
			},
		},
	},
}

var errorCases = []string{
	`{"type": "ByteArray","value":`,        // incorrect JSON
	`{"type": "ByteArray","value":1}`,      // incorrect Value
	`{"type": "ByteArray","value":"12zz"}`, // incorrect ByteArray value
	`{"type": "String","value":`,           // incorrect JSON
	`{"type": "String","value":1}`,         // incorrect Value
	`{"type": "Integer","value": "nn"}`,    // incorrect Integer value
	`{"type": "Integer","value": []}`,      // incorrect Integer value
	`{"type": "Array","value": 123}`,       // incorrect Array value
	`{"type": "Hash160","value": "0bcd"}`,  // incorrect Uint160 value
	`{"type": "Hash256","value": "0bcd"}`,  // incorrect Uint256 value
	`{"type": "Stringg","value": ""}`,      // incorrect type
}

func TestStackParam_UnmarshalJSON(t *testing.T) {
	var (
		err  error
		r, s StackParam
	)
	for _, tc := range testCases {
		if err = json.Unmarshal([]byte(tc.input), &s); err != nil {
			t.Errorf("error while unmarhsalling: %v", err)
		} else if !reflect.DeepEqual(s, tc.result) {
			t.Errorf("got (%v), expected (%v)", s, tc.result)
		}
	}

	// Hash160 unmarshalling
	err = json.Unmarshal([]byte(`{"type": "Hash160","value": "0bcd2978634d961c24f5aea0802297ff128724d6"}`), &s)
	if err != nil {
		t.Errorf("error while unmarhsalling: %v", err)
	}

	h160, err := util.Uint160DecodeString("0bcd2978634d961c24f5aea0802297ff128724d6")
	if err != nil {
		t.Errorf("unmarshal error: %v", err)
	}

	if r = (StackParam{Type: Hash160, Value: h160}); !reflect.DeepEqual(s, r) {
		t.Errorf("got (%v), expected (%v)", s, r)
	}

	// Hash256 unmarshalling
	err = json.Unmarshal([]byte(`{"type": "Hash256","value": "f037308fa0ab18155bccfc08485468c112409ea5064595699e98c545f245f32d"}`), &s)
	if err != nil {
		t.Errorf("error while unmarhsalling: %v", err)
	}
	h256, err := util.Uint256DecodeString("f037308fa0ab18155bccfc08485468c112409ea5064595699e98c545f245f32d")
	if err != nil {
		t.Errorf("unmarshal error: %v", err)
	}
	if r = (StackParam{Type: Hash256, Value: h256}); !reflect.DeepEqual(s, r) {
		t.Errorf("got (%v), expected (%v)", s, r)
	}

	for _, input := range errorCases {
		if err = json.Unmarshal([]byte(input), &s); err == nil {
			t.Errorf("expected error, got (nil)")
		}
	}
}

const (
	hash160    = "0bcd2978634d961c24f5aea0802297ff128724d6"
	hash256    = "7fe610b7c8259ae949accacb091a1bc53219c51a1cb8752fbc6457674c13ec0b"
	testString = "myteststring"
)

func TestStackParam_TryParse(t *testing.T) {
	// ByteArray to util.Uint160 conversion
	data, err := hex.DecodeString(hash160)
	if err != nil {
		t.Fatal(err)
	}

	var (
		outputUint160, expectedUint160 util.Uint160
		input                          = StackParam{
			Type:  ByteArray,
			Value: data,
		}
	)
	expectedUint160, err = util.Uint160DecodeString(hash160)
	if err != nil {
		t.Fatal(err)
	}
	if err = input.TryParse(&outputUint160); err != nil {
		t.Errorf("failed to parse stackparam to Uint160: %v", err)
	}
	if !reflect.DeepEqual(outputUint160, expectedUint160) {
		t.Errorf("got (%v), expected (%v)", outputUint160, expectedUint160)
	}

	// ByteArray to util.Uint256 conversion
	data, err = hex.DecodeString(hash256)
	if err != nil {
		t.Fatal(err)
	}

	var (
		outputUint256, expectedUint256 util.Uint256
		uint256input                   = StackParam{
			Type:  ByteArray,
			Value: data,
		}
	)
	expectedUint256, err = util.Uint256DecodeString(hash256)
	if err != nil {
		t.Fatal(err)
	}
	if err = uint256input.TryParse(&outputUint256); err != nil {
		t.Errorf("failed to parse stackparam to []byte: %v", err)
	}
	if !reflect.DeepEqual(outputUint256, expectedUint256) {
		t.Errorf("got (%v), expected (%v)", outputUint256, expectedUint256)
	}

	// ByteArray to []byte conversion
	var (
		outputBytes   []byte
		expectedBytes = expectedUint160.Bytes()
	)
	if err = input.TryParse(&outputBytes); err != nil {
		t.Errorf("failed to parse stackparam to []byte: %v", err)
	}
	if !reflect.DeepEqual(outputBytes, expectedBytes) {
		t.Errorf("got (%v), expected (%v)", outputBytes, expectedBytes)
	}

	// ByteArray to int64 conversion
	data, err = hex.DecodeString("637829cd0b")
	if err != nil {
		t.Fatal(err)
	}
	var (
		outputInt, expectedInt int64
		intinput               = StackParam{
			Type:  ByteArray,
			Value: data,
		}
	)
	expectedInt = 50686687331
	if err = intinput.TryParse(&outputInt); err != nil {
		t.Errorf("failed to parse stackparam to []byte: %v", err)
	}
	if !reflect.DeepEqual(outputInt, expectedInt) {
		t.Errorf("got (%v), expected (%v)", outputInt, expectedInt)
	}

	// ByteArray to string conversion
	data = []byte(testString)
	var (
		outputStr, expectedStr string
		strinput               = StackParam{
			Type:  ByteArray,
			Value: data,
		}
	)
	expectedStr = testString
	if err = strinput.TryParse(&outputStr); err != nil {
		t.Errorf("failed to parse stackparam to []byte: %v", err)
	}
	if !reflect.DeepEqual(outputStr, expectedStr) {
		t.Errorf("got (%v), expected (%v)", outputStr, expectedStr)
	}

	// StackParams to []util.Uint160
	data, err = hex.DecodeString(hash160)
	if err != nil {
		t.Fatal(err)
	}
	expUint160, err := util.Uint160DecodeString(hash160)
	if err != nil {
		t.Fatal(err)
	}
	var (
		params = StackParams{
			StackParam{
				Type:  ByteArray,
				Value: data,
			},
			StackParam{
				Type:  ByteArray,
				Value: data,
			},
		}
		expectedArray = []util.Uint160{
			expUint160,
			expUint160,
		}
		out1, out2 = &util.Uint160{}, &util.Uint160{}
	)
	if err = params.TryParseArray(out1, out2); err != nil {
		t.Errorf("failed to parse stackparam to []byte: %v", err)
	}
	outArray := []util.Uint160{*out1, *out2}
	if !reflect.DeepEqual(outArray, expectedArray) {
		t.Errorf("got (%v), expected (%v)", outArray, expectedArray)
	}

}