Merge pull request #24 from hellofresh/patch/metadata-easyjson

Use easyjson for metadata unmarshaling

Author: boekkooi-fresh

Gopkg.lock

@@ -1,6 +1,10 @@
 package metadata
 
-import "encoding/json"
+import (
+	"encoding/json"
+
+	"github.com/mailru/easyjson/jlexer"
+)
 
 // Metadata is an immutable map[string]interface{} implementation
 type Metadata interface {
@@ -94,35 +98,31 @@ func (v *valueData) MarshalJSON() ([]byte, error) {
 	return json.Marshal(v.AsMap())
 }
 
-// JSONMetadata is a special struct to UnmarshalJSON metadata
-type JSONMetadata struct {
-	Metadata Metadata
-}
-
-var (
-	// Ensure JSONMetadata implements the json.Marshaler interface
-	_ json.Marshaler = &JSONMetadata{}
-	// Ensure JSONMetadata implements the json.Unmarshaler interface
-	_ json.Unmarshaler = &JSONMetadata{}
-)
-
-// MarshalJSON returns a json representation of the wrapped Metadata
-func (j JSONMetadata) MarshalJSON() ([]byte, error) {
-	if j.Metadata == nil {
-		j.Metadata = New()
+func UnmarshalJSON(json []byte) (Metadata, error) {
+	in := jlexer.Lexer{Data: json}
+	metadata := New()
+
+	isTopLevel := in.IsStart()
+	if in.IsNull() {
+		if isTopLevel {
+			in.Consumed()
+		}
+		in.Skip()
+		return metadata, in.Error()
 	}
 
-	return json.Marshal(j.Metadata)
-}
+	in.Delim('{')
+	for !in.IsDelim('}') {
+		key := in.UnsafeString()
+		in.WantColon()
+		metadata = WithValue(metadata, key, in.Interface())
+		in.WantComma()
+	}
+	in.Delim('}')
 
-// UnmarshalJSON unmarshal the json into Metdadata
-func (j *JSONMetadata) UnmarshalJSON(data []byte) error {
-	var valueMap map[string]interface{}
-	err := json.Unmarshal(data, &valueMap)
-	if err != nil {
-		return err
+	if isTopLevel {
+		in.Consumed()
 	}
 
-	j.Metadata = FromMap(valueMap)
-	return nil
+	return metadata, in.Error()
 }

metadata/metadata.go

@@ -172,6 +172,30 @@ var jsonTestCases = []struct {
 			"another": "value"
 		}`,
 	},
+	{
+		"metadata with 'complex' json",
+		func() metadata.Metadata {
+			m := metadata.New()
+			m = metadata.WithValue(m, "test", nil)
+			m = metadata.WithValue(m, "another", "value")
+			m = metadata.WithValue(m, "arr", []interface{}{"a", "b", "c"})
+			m = metadata.WithValue(m, "arrInArr", []interface{}{"a", []interface{}{"b"}})
+			m = metadata.WithValue(m, "obj", map[string]interface{}{"a": float64(1)})
+			m = metadata.WithValue(m, "objInObj", map[string]interface{}{
+				"a": float64(1),
+				"b": map[string]interface{}{"a": float64(2)},
+			})
+			return m
+		},
+		`{
+			"test": null,
+			"another": "value",
+			"arr": [ "a", "b", "c" ],
+			"arrInArr": [ "a", [ "b" ] ],
+			"obj": { "a": 1 },
+			"objInObj": { "a": 1, "b": {"a": 2} }
+		}`,
+	},
 }
 
 func TestMetadata_MarshalJSON(t *testing.T) {
@@ -187,30 +211,27 @@ func TestMetadata_MarshalJSON(t *testing.T) {
 	}
 }
 
-func TestJSONMetadata_MarshalJSON(t *testing.T) {
+func TestJSONMetadata_UnmarshalJSON(t *testing.T) {
 	for _, testCase := range jsonTestCases {
 		t.Run(testCase.title, func(t *testing.T) {
-			m := metadata.JSONMetadata{
-				Metadata: testCase.metadata(),
-			}
+			m, err := metadata.UnmarshalJSON([]byte(testCase.json))
 
-			mJSON, err := json.Marshal(m)
-
-			assert.JSONEq(t, testCase.json, string(mJSON))
-			assert.NoError(t, err)
+			// Need to use AsMap otherwise we can have inconsistent tests results.
+			if assert.NoError(t, err) {
+				assert.Equal(t, testCase.metadata().AsMap(), m.AsMap())
+			}
 		})
 	}
 }
 
-func TestJSONMetadata_UnmarshalJSON(t *testing.T) {
-	for _, testCase := range jsonTestCases {
-		t.Run(testCase.title, func(t *testing.T) {
-			var m metadata.JSONMetadata
-			err := json.Unmarshal([]byte(testCase.json), &m)
+func BenchmarkJSONMetadata_UnmarshalJSON(b *testing.B) {
+	payload := []byte(`{"_aggregate_id": "b9ebca7a-c1eb-40dd-94a4-fac7c5e84fb5", "_aggregate_type": "bank_account", "_aggregate_version": 1}`)
 
-			// Need to use AsMap otherwise we can have inconsistent tests results.
-			assert.Equal(t, testCase.metadata().AsMap(), m.Metadata.AsMap())
-			assert.NoError(t, err)
-		})
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		_, err := metadata.UnmarshalJSON(payload)
+		if err != nil {
+			b.Fail()
+		}
 	}
 }

metadata/metadata_test.go

@@ -2,7 +2,6 @@ package sql
 
 import (
 	"database/sql"
-	"encoding/json"
 	"fmt"
 	"time"
 
@@ -78,11 +77,10 @@ func (a *aggregateChangedEventStream) Message() (goengine.Message, int64, error)
 		return nil, 0, err
 	}
 
-	metadataWrapper := metadata.JSONMetadata{Metadata: metadata.New()}
-	if err := json.Unmarshal(jsonMetadata, &metadataWrapper); err != nil {
+	meta, err := metadata.UnmarshalJSON(jsonMetadata)
+	if err != nil {
 		return nil, 0, err
 	}
-	meta := metadataWrapper.Metadata
 
 	payload, err := a.payloadFactory.CreatePayload(eventName, jsonPayload)
 	if err != nil {

strategy/json/sql/message_factory_aggregate.go

@@ -164,7 +164,7 @@ func TestAggregateChangedFactory_CreateFromRows(t *testing.T) {
 
 					return mockRows, mocks.NewMessagePayloadFactory(ctrl)
 				},
-				"unexpected end of JSON input",
+				"parse error: expected { near offset 1 of ''",
 			},
 			{
 				"bad payload",