hyperledger · nguyer · Jan 19, 2022 · Jan 19, 2022 · Jan 19, 2022 · Jan 19, 2022
@@ -1,6 +1,6 @@
 BEGIN;
 CREATE TABLE blockchainevents (
-  seq              INTEGER         PRIMARY KEY AUTOINCREMENT,
+  seq              SERIAL          PRIMARY KEY,
   id               UUID            NOT NULL,
   source           VARCHAR(256)    NOT NULL,
   namespace        VARCHAR(64)     NOT NULL,

@@ -201,7 +201,7 @@ func (cm *contractManager) resolveInvokeContractRequest(ctx context.Context, ns
 
 		method, err = cm.database.GetFFIMethod(ctx, ns, req.Interface, method.Pathname)
 		if err != nil || method == nil {
-			return nil, i18n.NewError(ctx, i18n.MsgContractMethodResolveError)
+			return nil, i18n.NewError(ctx, i18n.MsgContractMethodResolveError, err)
 		}
 	}
 	return method, nil

@@ -232,7 +232,7 @@ var (
 	MsgContractSubscriptionExists   = ffm("FF10312", "A contract subscription already exists in the namespace: '%s' with name: '%s'", 409)
 	MsgContractMethodNotSet         = ffm("FF10313", "Method not specified on invoke contract request", 400)
 	MsgContractNoMethodSignature    = ffm("FF10314", "Method signature is required if interfaceID is absent", 400)
-	MsgContractMethodResolveError   = ffm("FF10315", "Unable to resolve contract method", 400)
+	MsgContractMethodResolveError   = ffm("FF10315", "Unable to resolve contract method: %s", 400)
 	MsgContractLocationExists       = ffm("FF10316", "The contract location cannot be changed after it is created", 400)
 	MsgSubscriptionNoEvent          = ffm("FF10317", "An eventId or in-line event definition must be supplied when subscribing", 400)
 	MsgSubscriptionEventNotFound    = ffm("FF10318", "No event was found in namespace '%s' with id '%s'", 400)

@@ -63,11 +63,14 @@ func (ma *BatchPayload) Scan(src interface{}) error {
 	case nil:
 		return nil
 
-	case string, []byte:
+	case []byte:
+		return json.Unmarshal(src, &ma)
+
+	case string:
 		if src == "" {
 			return nil
 		}
-		return json.Unmarshal(src.([]byte), &ma)
+		return json.Unmarshal([]byte(src), &ma)
 
 	default:
 		return i18n.NewError(context.Background(), i18n.MsgScanFailed, src, ma)

@@ -51,6 +51,9 @@ func TestSQLSerializedMessageArray(t *testing.T) {
 	err = batchPayloadRead.Scan("")
 	assert.NoError(t, err)
 
+	err = batchPayloadRead.Scan("{}")
+	assert.NoError(t, err)
+
 	err = batchPayloadRead.Scan(nil)
 	assert.NoError(t, err)
 

@@ -50,6 +50,8 @@ func (fse *FFISerializedEvent) Scan(src interface{}) error {
 	case nil:
 		fse = nil
 		return nil
+	case string:
+		return json.Unmarshal([]byte(src), &fse)
 	case []byte:
 		return json.Unmarshal(src, &fse)
 	default:

@@ -34,9 +34,15 @@ func TestFFISerializedEventScanNil(t *testing.T) {
 	assert.Nil(t, err)
 }
 
+func TestFFISerializedEventScanString(t *testing.T) {
+	params := &FFISerializedEvent{}
+	err := params.Scan(`{"name":"event1","description":"a super event","params":[{"name":"details","type":"integer","details":{"type":"uint256"}}]}`)
+	assert.NoError(t, err)
+}
+
 func TestFFISerializedEventScanError(t *testing.T) {
 	params := &FFISerializedEvent{}
-	err := params.Scan("definitely not FFISerializedEvent")
+	err := params.Scan(map[string]interface{}{"this is": "not a supported serialization of a FFISerializedEvent"})
 	assert.Regexp(t, "FF10125", err)
 }
 

@@ -102,6 +102,8 @@ func (m *FFIParams) Scan(src interface{}) error {
 	case nil:
 		m = nil
 		return nil
+	case string:
+		return json.Unmarshal([]byte(src), &m)
 	case []byte:
 		return json.Unmarshal(src, &m)
 	default:

@@ -107,6 +107,12 @@ func TestFFIParamsScan(t *testing.T) {
 	assert.NoError(t, err)
 }
 
+func TestFFIParamsScanString(t *testing.T) {
+	params := &FFIParams{}
+	err := params.Scan(`[{"name": "x", "type": "integer", "internalType": "uint256"}]`)
+	assert.NoError(t, err)
+}
+
 func TestFFIParamsScanNil(t *testing.T) {
 	params := &FFIParams{}
 	err := params.Scan(nil)
@@ -115,7 +121,7 @@ func TestFFIParamsScanNil(t *testing.T) {
 
 func TestFFIParamsScanError(t *testing.T) {
 	params := &FFIParams{}
-	err := params.Scan("definitely not FFIParams")
+	err := params.Scan(map[string]interface{}{"type": "not supported for scanning FFIParams"})
 	assert.Regexp(t, "FF10125", err)
 }
 

@@ -37,11 +37,14 @@ func (jd *JSONObject) Scan(src interface{}) error {
 	case nil:
 		return nil
 
-	case string, []byte:
+	case string:
 		if src == "" {
 			return nil
 		}
-		return json.Unmarshal(src.([]byte), &jd)
+		return json.Unmarshal([]byte(src), &jd)
+
+	case []byte:
+		return json.Unmarshal(src, &jd)
 
 	default:
 		return i18n.NewError(context.Background(), i18n.MsgScanFailed, src, jd)
@@ -167,7 +170,11 @@ func (jd JSONObject) GetStringArrayOk(key string) ([]string, bool) {
 
 // Value implements sql.Valuer
 func (jd JSONObject) Value() (driver.Value, error) {
-	return json.Marshal(&jd)
+	b, err := json.Marshal(&jd)
+	if err != nil {
+		return nil, err
+	}
+	return string(b), err
 }
 
 func (jd JSONObject) String() string {

@@ -32,7 +32,7 @@ func TestJSONObject(t *testing.T) {
 
 	b, err := data.Value()
 	assert.NoError(t, err)
-	assert.IsType(t, []byte{}, b)
+	assert.IsType(t, "", b)
 
 	var dataRead JSONObject
 	err = dataRead.Scan(b)
@@ -84,21 +84,27 @@ func TestJSONObject(t *testing.T) {
 	assert.Equal(t, "", v)
 }
 
-func TestJSONObjectBool(t *testing.T) {
+func TestJSONObjectScan(t *testing.T) {
 
-	data := JSONObjectArray{
-		{"some": "data"},
-	}
+	data := JSONObject{"some": "data"}
 
-	b, err := data.Value()
+	sv, err := data.Value()
 	assert.NoError(t, err)
-	assert.Equal(t, "[{\"some\":\"data\"}]", b)
+	assert.Equal(t, "{\"some\":\"data\"}", sv)
 
-	var dataRead JSONObjectArray
-	err = dataRead.Scan(b)
+	var dataRead JSONObject
+	err = dataRead.Scan(sv)
 	assert.NoError(t, err)
 
-	assert.Equal(t, `[{"some":"data"}]`, fmt.Sprintf("%v", dataRead))
+	assert.Equal(t, `{"some":"data"}`, fmt.Sprintf("%v", dataRead))
+
+	sv, err = ((JSONObject)(nil)).Value()
+	assert.NoError(t, err)
+	assert.Equal(t, NullString, sv)
+
+	var badData JSONObject = map[string]interface{}{"bad": map[bool]bool{false: true}}
+	_, err = badData.Value()
+	assert.Error(t, err)
 
 	j1, err := json.Marshal(&data)
 	assert.NoError(t, err)
@@ -111,6 +117,13 @@ func TestJSONObjectBool(t *testing.T) {
 	err = dataRead.Scan("")
 	assert.NoError(t, err)
 
+	err = dataRead.Scan([]byte("{}"))
+	assert.NoError(t, err)
+
+	err = dataRead.Scan(`{"test": true}`)
+	assert.NoError(t, err)
+	assert.True(t, dataRead.GetBool("test"))
+
 	err = dataRead.Scan(nil)
 	assert.NoError(t, err)
 

@@ -17,6 +17,8 @@
 package fftypes
 
 import (
+	"encoding/json"
+	"fmt"
 	"testing"
 
 	"github.com/stretchr/testify/assert"
@@ -75,3 +77,57 @@ func TestJSONObjectArrayScan(t *testing.T) {
 	assert.Error(t, err)
 
 }
+
+func TestJSONObjectArrayScanExtra(t *testing.T) {
+
+	data := JSONObjectArray{{"some": "data"}}
+
+	sv, err := data.Value()
+	assert.NoError(t, err)
+	assert.Equal(t, "[{\"some\":\"data\"}]", sv)
+
+	var dataRead JSONObjectArray
+	err = dataRead.Scan(sv)
+	assert.NoError(t, err)
+
+	assert.Equal(t, `[{"some":"data"}]`, fmt.Sprintf("%v", dataRead))
+
+	var badData = JSONObjectArray{map[string]interface{}{"bad": map[bool]bool{false: true}}}
+	_, err = badData.Value()
+	assert.Error(t, err)
+
+	j1, err := json.Marshal(&data)
+	assert.NoError(t, err)
+	j2, err := json.Marshal(&dataRead)
+	assert.NoError(t, err)
+	assert.Equal(t, string(j1), string(j2))
+	j3 := dataRead.String()
+	assert.Equal(t, string(j1), j3)
+
+	err = dataRead.Scan("")
+	assert.NoError(t, err)
+
+	err = dataRead.Scan([]byte("[{}]"))
+	assert.NoError(t, err)
+
+	err = dataRead.Scan(`[{"test": true}]`)
+	assert.NoError(t, err)
+	assert.True(t, dataRead[0].GetBool("test"))
+
+	err = dataRead.Scan(nil)
+	assert.NoError(t, err)
+
+	var wrongType int
+	err = dataRead.Scan(&wrongType)
+	assert.Error(t, err)
+
+	hash, err := dataRead.Hash("goodStuff")
+	assert.NoError(t, err)
+	assert.NotEmpty(t, hash)
+
+	var badJson JSONObjectArray = []JSONObject{{"not": map[bool]string{true: "json"}}}
+	hash, err = badJson.Hash("badStuff")
+	assert.Regexp(t, "FF10151.*badStuff", err)
+	assert.Nil(t, hash)
+
+}