Add ShouldJSONEqual assertion

assertions/assertions.go

@@ -59,6 +59,7 @@ var assertMap = map[string]AssertFunc{
 	"ShouldHappenOnOrAfter":        ShouldHappenOnOrAfter,
 	"ShouldHappenBetween":          ShouldHappenBetween,
 	"ShouldTimeEqual":              ShouldTimeEqual,
+	"ShouldJSONEqual":              ShouldJSONEqual,
 	"ShouldBeArray":                ShouldBeArray,
 	"ShouldBeMap":                  ShouldBeMap,
 	"ShouldMatchRegex":             ShouldMatchRegex,
@@ -770,7 +771,6 @@ func ShouldHaveLength(actual interface{}, expected ...interface{}) error {
 	}
 
 	return fmt.Errorf("expected '%v' have length of %d but it wasn't (%d)", actual, length, actualLength)
-
 }
 
 // ShouldStartWith receives exactly 2 string parameters and ensures that the first starts with the second.
@@ -1174,6 +1174,120 @@ func ShouldTimeEqual(actual interface{}, expected ...interface{}) error {
 	return fmt.Errorf("expected '%v' to be time equals to '%v' ", actualTime, expectedTime)
 }
 
+// ShouldJSONEqual receives exactly 2 JSON arguments and does a JSON equality check.
+// This means the keys can be in different order, and whitespace (except in keys or values) is ignored.
+// JSON can be an object or array (i.e. start with `{` or `[`).
+//
+// Example of testsuite file:
+//
+//	name: test ShouldJSONEqual
+//	vars:
+//	  json_expected: '{"a":1,"b":"foo"}'
+//	testcases:
+//	- name: test assertion
+//	  steps:
+//	  - type: exec
+//	    script: "echo '{ \"b\" : \"foo\", \"a\" : 1 }'"
+//	    assertions:
+//	      - result.systemout ShouldJSONEqual "{{.json_expected}}"
+func ShouldJSONEqual(actual interface{}, expected ...interface{}) error {
+	if err := need(1, expected); err != nil {
+		return err
+	}
+
+	expectedString, err := cast.ToStringE(expected[0])
+	if err != nil {
+		return err
+	}
+
+	// `actual` can be a map, slice or the string representation of a JSON object or array.
+	var actualMap map[string]interface{}
+	var actualSlice []interface{}
+	var obj bool
+	switch actual.(type) {
+	case map[string]interface{}:
+		obj = true
+		var err error
+		actualMap, err = cast.ToStringMapE(actual)
+		if err != nil {
+			return err
+		}
+		// Marshal and unmarshal for later deepequal to work
+		actualBytes, err := json.Marshal(actualMap)
+		if err != nil {
+			return err
+		}
+		err = json.Unmarshal(actualBytes, &actualMap)
+		if err != nil {
+			return err
+		}
+	case []interface{}:
+		obj = false
+		var err error
+		actualSlice, err = cast.ToSliceE(actual)
+		if err != nil {
+			return err
+		}
+		// Marshal and unmarshal for later deepequal to work
+		actualBytes, err := json.Marshal(actualSlice)
+		if err != nil {
+			return err
+		}
+		err = json.Unmarshal(actualBytes, &actualSlice)
+		if err != nil {
+			return err
+		}
+	case string:
+		actualString, err := cast.ToStringE(actual)
+		if err != nil {
+			return err
+		}
+
+		// JSON can start with { or [
+		if strings.TrimSpace(actualString)[0] == '{' {
+			obj = true
+			actualMap = map[string]interface{}{}
+			err = json.Unmarshal([]byte(actualString), &actualMap)
+			if err != nil {
+				return err
+			}
+		} else if strings.TrimSpace(actualString)[0] == '[' {
+			obj = false
+			actualSlice = []interface{}{}
+			err = json.Unmarshal([]byte(actualString), &actualSlice)
+			if err != nil {
+				return err
+			}
+		} else {
+			return fmt.Errorf("actual string must represent a JSON object or array, starting with '{' or '['")
+		}
+	default:
+		return fmt.Errorf("unexpected type for actual: %T", actual)
+	}
+
+	if obj {
+		expectedMap := map[string]interface{}{}
+		err = json.Unmarshal([]byte(expectedString), &expectedMap)
+		if err != nil {
+			return err
+		}
+		if reflect.DeepEqual(actualMap, expectedMap) {
+			return nil
+		}
+		return fmt.Errorf("expected '%#v' to be JSON equals to '%#v' ", actualMap, expectedMap)
+	} else {
+		expectedSlice := []interface{}{}
+		err = json.Unmarshal([]byte(expectedString), &expectedSlice)
+		if err != nil {
+			return err
+		}
+		if reflect.DeepEqual(actualSlice, expectedSlice) {
+			return nil
+		}
+		return fmt.Errorf("expected '%#v' to be JSON equals to '%#v' ", actualSlice, expectedSlice)
+	}
+}
+
 func getTimeFromString(in interface{}) (time.Time, error) {
 	if t, isTime := in.(time.Time); isTime {
 		return t, nil

assertions/assertions_test.go

@@ -1458,3 +1458,143 @@ func TestShouldMatchRegex(t *testing.T) {
 		})
 	}
 }
+
+func TestShouldJSONEqual(t *testing.T) {
+	type args struct {
+		actual   interface{}
+		expected []interface{}
+	}
+
+	tests := []struct {
+		name    string
+		args    args
+		wantErr bool
+	}{
+		{
+			name: "ok",
+			args: args{
+				actual:   `{"a":1,"b":"foo"}`,
+				expected: []interface{}{`{"a":1,"b":"foo"}`},
+			},
+		},
+		{
+			// Same with map
+			name: "ok",
+			args: args{
+				actual:   map[string]interface{}{"a": 1, "b": "foo"},
+				expected: []interface{}{`{"a":1,"b":"foo"}`},
+			},
+		},
+		{
+			// Spaces, newlines, tabs and key order don't matter
+			name: "ok",
+			args: args{
+				actual:   `{"a":1,"b":"foo"}`,
+				expected: []interface{}{` { "b" : "foo" ,` + "\n\t" + ` "a" : 1 } `},
+			},
+		},
+		{
+			// Order in nested objects doesn't matter
+			name: "ok",
+			args: args{
+				actual:   `{"a":{"nested1":1,"nested2":2}}`,
+				expected: []interface{}{`{"a":{"nested2":2,"nested1":1}}`},
+			},
+		},
+		{
+			// An array instead of object is valid JSON too
+			name: "ok",
+			args: args{
+				actual:   `[1,2]`,
+				expected: []interface{}{`[1,2]`},
+			},
+		},
+		{
+			// Same with slice
+			name: "ok",
+			args: args{
+				actual:   []interface{}{1, 2},
+				expected: []interface{}{`[1,2]`},
+			},
+		},
+		{
+			// Bad value
+			name: "ko",
+			args: args{
+				actual:   `{"a":1}`,
+				expected: []interface{}{`{"a":2}`},
+			},
+			wantErr: true,
+		},
+		{
+			// Bad type
+			name: "ko",
+			args: args{
+				actual:   `{"a":1}`,
+				expected: []interface{}{`{"a":"1"}`},
+			},
+			wantErr: true,
+		},
+		{
+			// Missing key
+			name: "ko",
+			args: args{
+				actual:   `{"a":1,"b":"foo"}`,
+				expected: []interface{}{`{"a":1}`},
+			},
+			wantErr: true,
+		},
+		{
+			// Wrong array order
+			name: "ko",
+			args: args{
+				actual:   `{"a":[1,2]}`,
+				expected: []interface{}{`{"a":[2,1]}`},
+			},
+			wantErr: true,
+		},
+		{
+			// Object instead of array
+			name: "ko",
+			args: args{
+				actual:   `{"a":1}`,
+				expected: []interface{}{`[1]`},
+			},
+			wantErr: true,
+		},
+		{
+			// Same with map
+			name: "ko",
+			args: args{
+				actual:   map[string]interface{}{"a": 1},
+				expected: []interface{}{`[1]`},
+			},
+			wantErr: true,
+		},
+		{
+			// Array instead of object
+			name: "ko",
+			args: args{
+				actual:   `[1]`,
+				expected: []interface{}{`{"a":1}}`},
+			},
+			wantErr: true,
+		},
+		{
+			// Same with slice
+			name: "ko",
+			args: args{
+				actual:   []interface{}{1},
+				expected: []interface{}{`{"a":1}}`},
+			},
+			wantErr: true,
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			if err := ShouldJSONEqual(tt.args.actual, tt.args.expected...); (err != nil) != tt.wantErr {
+				t.Errorf("ShouldJSONEqual() error = %v, wantErr %v", err, tt.wantErr)
+			}
+		})
+	}
+}

tests/assertions/ShouldJSONEqual.yml

@@ -0,0 +1,10 @@
+name: test ShouldJSONEqual
+vars:
+  json_expected: '{"a":1,"b":"foo"}'
+testcases:
+- name: test assertion
+  steps:
+  - type: exec
+    script: "echo '{ \"b\" : \"foo\", \"a\" : 1 }'"
+    assertions:
+      - result.systemout ShouldJSONEqual "{{.json_expected}}"