Merge pull request mattbaird#3 from tmichaud314/add-replace-null-value

Fixes add/replace null-value marshalling

Author: mattbaird

jsonpatch.go

@@ -1,6 +1,7 @@
 package jsonpatch
 
 import (
+	"bytes"
 	"encoding/json"
 	"fmt"
 	"reflect"
@@ -20,6 +21,24 @@ func (j *JsonPatchOperation) Json() string {
 	return string(b)
 }
 
+func (j *JsonPatchOperation) MarshalJSON() ([]byte, error) {
+	var b bytes.Buffer
+	b.WriteString("{")
+	b.WriteString(fmt.Sprintf(`"op":"%s"`, j.Operation))
+	b.WriteString(fmt.Sprintf(`,"path":"%s"`, j.Path))
+	// Consider omitting Value for non-nullable operations.
+	if j.Value != nil || j.Operation == "replace" || j.Operation == "add" {
+		v, err := json.Marshal(j.Value)
+		if err != nil {
+			return nil, err
+		}
+		b.WriteString(`,"value":`)
+		b.Write(v)
+	}
+	b.WriteString("}")
+	return b.Bytes(), nil
+}
+
 type ByPath []JsonPatchOperation
 
 func (a ByPath) Len() int           { return len(a) }

jsonpatch_json_test.go

@@ -0,0 +1,31 @@
+package jsonpatch
+
+import (
+	"github.com/stretchr/testify/assert"
+	"testing"
+)
+
+func TestMarshalNullableValue(t *testing.T) {
+	p1 := JsonPatchOperation{
+		Operation: "replace",
+		Path:      "/a1",
+		Value:     nil,
+	}
+	assert.JSONEq(t, `{"op":"replace", "path":"/a1","value":null}`, p1.Json())
+
+	p2 := JsonPatchOperation{
+		Operation: "replace",
+		Path:      "/a2",
+		Value:     "v2",
+	}
+	assert.JSONEq(t, `{"op":"replace", "path":"/a2", "value":"v2"}`, p2.Json())
+}
+
+func TestMarshalNonNullableValue(t *testing.T) {
+	p1 := JsonPatchOperation{
+		Operation: "remove",
+		Path:      "/a1",
+	}
+	assert.JSONEq(t, `{"op":"remove", "path":"/a1"}`, p1.Json())
+
+}

jsonpatch_simple_test.go

@@ -12,8 +12,19 @@ var simpleC = `{"a":100, "b":100, "c":"hello"}`
 var simpleD = `{"a":100, "b":200, "c":"hello", "d":"foo"}`
 var simpleE = `{"a":100, "b":200}`
 var simplef = `{"a":100, "b":100, "d":"foo"}`
+var simpleG = `{"a":100, "b":null, "d":"foo"}`
 var empty = `{}`
 
+func TestOneNullReplace(t *testing.T) {
+	patch, e := CreatePatch([]byte(simplef), []byte(simpleG))
+	assert.NoError(t, e)
+	assert.Equal(t, len(patch), 1, "they should be equal")
+	change := patch[0]
+	assert.Equal(t, change.Operation, "replace", "they should be equal")
+	assert.Equal(t, change.Path, "/b", "they should be equal")
+	assert.Equal(t, change.Value, nil, "they should be equal")
+}
+
 func TestSame(t *testing.T) {
 	patch, e := CreatePatch([]byte(simpleA), []byte(simpleA))
 	assert.NoError(t, e)