Adding MarshalsEquivalentJSON to value assertions

Author: Geish

assert/value.go

@@ -1,10 +1,16 @@
 package assert
 
 import (
+	"bytes"
+	"encoding/json"
 	"fmt"
 	"reflect"
 )
 
+const (
+	jsonIndent = "  "
+)
+
 // AssertableValue represents an under-test value that's expected to meet
 // certain criteria.
 type AssertableValue interface {
@@ -34,6 +40,12 @@ type AssertableValue interface {
 	// IsTrue asserts that the specified actual value is true.
 	// Returns a ValueAssertionResult that provides post-assert actions.
 	IsTrue() ValueAssertionResult
+
+	// MarshalsEquivalentJSON asserts that the specified actual value yields
+	// a JSON encoding equivalent to that of the specified expected value.
+	// See https://golang.org/pkg/encoding/json/#Marshal for encoding details.
+	// Returns a ValueAssertionResult that provides post-assert actions.
+	MarshalsEquivalentJSON(expected interface{}) ValueAssertionResult
 }
 
 type assertableValue struct {
@@ -50,16 +62,20 @@ type anyOtherValue struct{}
 func (actual *assertableValue) Equals(expected interface{}) ValueAssertionResult {
 	areEqual := reflect.DeepEqual(actual.value, expected)
 	if !areEqual {
-		if fmt.Sprint(actual.value) == fmt.Sprint(expected) {
-			actual.testContext.decoratedErrorf(
-				"Type mismatch.\nActual: %T=%v\nExpected: %T=%v\n", actual.value, actual.value, expected, expected)
-		} else {
-			actual.testContext.decoratedErrorf("Value mismatch.\nActual: %#v\nExpected: %#v\n", actual.value, expected)
-		}
+		actual.printValueMismatchError(expected)
 	}
 	return &valueAssertionResult{bool: areEqual, actual: actual.value, expected: expected}
 }
 
+func (actual *assertableValue) printValueMismatchError(expected interface{}) {
+	if fmt.Sprint(actual.value) == fmt.Sprint(expected) {
+		actual.testContext.decoratedErrorf(
+			"Type mismatch.\nActual: %T=%v\nExpected: %T=%v\n", actual.value, actual.value, expected, expected)
+	} else {
+		actual.testContext.decoratedErrorf("Value mismatch.\nActual: %#v\nExpected: %#v\n", actual.value, expected)
+	}
+}
+
 func (actual *assertableValue) DoesNotEqual(value interface{}) ValueAssertionResult {
 	areEqual := reflect.DeepEqual(actual.value, value)
 	if areEqual {
@@ -83,3 +99,23 @@ func (actual *assertableValue) IsFalse() ValueAssertionResult {
 func (actual *assertableValue) IsTrue() ValueAssertionResult {
 	return actual.Equals(true)
 }
+
+func (actual *assertableValue) MarshalsEquivalentJSON(expected interface{}) ValueAssertionResult {
+	var expectedBytes []byte
+	actualBytes, err := json.MarshalIndent(actual.value, "", jsonIndent)
+	if err != nil {
+		goto mismatch
+	}
+	expectedBytes, err = json.MarshalIndent(expected, "", jsonIndent)
+	if err != nil {
+		goto mismatch
+	}
+	if !bytes.Equal(actualBytes, expectedBytes) {
+		goto mismatch
+	}
+	return &valueAssertionResult{bool: true, actual: actual.value, expected: expected}
+
+mismatch:
+	actual.testContext.decoratedErrorf("JSON mismatch.\nActual: %s\nExpected: %s\n", actualBytes, expectedBytes)
+	return &valueAssertionResult{bool: false, actual: actual.value, expected: expected}
+}

assert/value_test.go

@@ -145,3 +145,32 @@ func ExampleAssertableValue_IsTrue_fail() {
 	// Expected: true
 	// Assertion failed successfully!
 }
+
+func ExampleAssertableValue_MarshalsEquivalentJSON_pass() {
+	foo := &struct {
+		Key string `json:"key"`
+	}{
+		Key: "value",
+	}
+	equivalentToFoo := &struct {
+		Key string `json:"key"`
+	}{
+		Key: "value",
+	}
+
+	if For(t).ThatActual(foo).MarshalsEquivalentJSON(equivalentToFoo).Passed() {
+		fmt.Println("Passed!")
+	}
+	// Output: Passed!
+}
+
+func ExampleAssertableValue_MarshalsEquivalentJSON_fail() {
+	if !mockTestContextToAssert().ThatActual(nil).MarshalsEquivalentJSON("").Passed() {
+		fmt.Println("Assertion failed successfully!")
+	}
+	// Output:
+	// file:3: JSON mismatch.
+	// Actual: null
+	// Expected: ""
+	// Assertion failed successfully!
+}