Allow merging multiple union types (#670)

* Add functionality to merge union types

As noted in #651, it's currently not possible to merge in a data type,
which means when we want to use an `allOf`, we end up only being able to
add a single type.

This introduces a new `Merge` method on generated union types, which
delegates to our `runtime.JsonMerge` method, which uses the `jsonmerge`
library.

We need to handle the case that a slice may be `nil`, and that the
upstream library does not have support for JSON arrays.

Closes #651.

* Add GoDoc comments for generated union types

Author: jamietanna

jsonmerge.go

@@ -0,0 +1,26 @@
+package runtime
+
+import (
+	"encoding/json"
+
+	"github.com/apapsch/go-jsonmerge/v2"
+)
+
+// JsonMerge merges two JSON representation into a single object. `data` is the
+// existing representation and `patch` is the new data to be merged in
+func JsonMerge(data, patch json.RawMessage) (json.RawMessage, error) {
+	merger := jsonmerge.Merger{
+		CopyNonexistent: true,
+	}
+	if data == nil {
+		data = []byte(`{}`)
+	}
+	if patch == nil {
+		patch = []byte(`{}`)
+	}
+	merged, err := merger.MergeBytes(data, patch)
+	if err != nil {
+		return nil, err
+	}
+	return merged, nil
+}

jsonmerge_test.go

@@ -0,0 +1,80 @@
+package runtime
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestJsonMerge(t *testing.T) {
+	t.Run("when object", func(t *testing.T) {
+		t.Run("Merges properties defined in both objects", func(t *testing.T) {
+			data := `{"foo": 1}`
+			patch := `{"foo": null}`
+			expected := `{"foo":null}`
+
+			actual, err := JsonMerge([]byte(data), []byte(patch))
+			assert.NoError(t, err)
+			assert.Equal(t, expected, string(actual))
+		})
+
+		t.Run("Sets property defined in only src object", func(t *testing.T) {
+			data := `{}`
+			patch := `{"source":"merge-me"}`
+			expected := `{"source":"merge-me"}`
+
+			actual, err := JsonMerge([]byte(data), []byte(patch))
+			assert.NoError(t, err)
+			assert.Equal(t, expected, string(actual))
+		})
+
+		t.Run("Handles child objects", func(t *testing.T) {
+			data := `{"channel":{"status":"valid"}}`
+			patch := `{"channel":{"id":1}}`
+			expected := `{"channel":{"id":1,"status":"valid"}}`
+
+			actual, err := JsonMerge([]byte(data), []byte(patch))
+			assert.NoError(t, err)
+			assert.Equal(t, expected, string(actual))
+		})
+
+		t.Run("Handles empty objects", func(t *testing.T) {
+			data := `{}`
+			patch := `{}`
+			expected := `{}`
+
+			actual, err := JsonMerge([]byte(data), []byte(patch))
+			assert.NoError(t, err)
+			assert.Equal(t, expected, string(actual))
+		})
+
+		t.Run("Handles nil data", func(t *testing.T) {
+			patch := `{"foo":"bar"}`
+			expected := `{"foo":"bar"}`
+
+			actual, err := JsonMerge(nil, []byte(patch))
+			assert.NoError(t, err)
+			assert.Equal(t, expected, string(actual))
+		})
+
+		t.Run("Handles nil patch", func(t *testing.T) {
+			data := `{"foo":"bar"}`
+			expected := `{"foo":"bar"}`
+
+			actual, err := JsonMerge([]byte(data), nil)
+			assert.NoError(t, err)
+			assert.Equal(t, expected, string(actual))
+		})
+	})
+	t.Run("when array", func(t *testing.T) {
+		t.Run("it does not merge", func(t *testing.T) {
+			data := `[{"foo": 1}]`
+			patch := `[{"foo": null}]`
+			expected := `[{"foo":1}]`
+
+			actual, err := JsonMerge([]byte(data), []byte(patch))
+			assert.NoError(t, err)
+			assert.Equal(t, expected, string(actual))
+		})
+	})
+}