Json

Asserting JSON Documents

Assertions

All links point to https://pkg.go.dev/github.com/go-openapi/testify/v2

This domain exposes 5 functionalities. Generic assertions are marked with a .

JSONEq

JSONEq asserts that two JSON strings are semantically equivalent.

Expected and actual must be valid JSON.

Examples

	assertions.JSONEq(t, `{"hello": "world", "foo": "bar"}`, `{"foo": "bar", "hello": "world"}`)
	success: `{"hello": "world", "foo": "bar"}`, `{"foo": "bar", "hello": "world"}`
	failure: `{"hello": "world", "foo": "bar"}`, `[{"foo": "bar"}, {"hello": "world"}]`

Copy and click to open Go Playground

// real-world test would inject *testing.T from TestJSONEq(t *testing.T)
package main

import (
	"fmt"
	"testing"

	"github.com/go-openapi/testify/v2/assert"
)

func main() {
	t := new(testing.T) // should come from testing, e.g. func TestJSONEq(t *testing.T)
	success := assert.JSONEq(t, `{"hello": "world", "foo": "bar"}`, `{"foo": "bar", "hello": "world"}`)
	fmt.Printf("success: %t\n", success)

}

Copy and click to open Go Playground

// real-world test would inject *testing.T from TestJSONEq(t *testing.T)
package main

import (
	"fmt"
	"testing"

	"github.com/go-openapi/testify/v2/require"
)

func main() {
	t := new(testing.T) // should come from testing, e.g. func TestJSONEq(t *testing.T)
	require.JSONEq(t, `{"hello": "world", "foo": "bar"}`, `{"foo": "bar", "hello": "world"}`)
	fmt.Println("passed")

}

Signature	Usage
`assert.JSONEq(t T, expected string, actual string, msgAndArgs ...any) bool`	package-level function
`assert.JSONEqf(t T, expected string, actual string, msg string, args ...any) bool`	formatted variant
`assert.(*Assertions).JSONEq(expected string, actual string) bool`	method variant
`assert.(*Assertions).JSONEqf(expected string, actual string, msg string, args ..any)`	method formatted variant

Signature	Usage
`require.JSONEq(t T, expected string, actual string, msgAndArgs ...any) bool`	package-level function
`require.JSONEqf(t T, expected string, actual string, msg string, args ...any) bool`	formatted variant
`require.(*Assertions).JSONEq(expected string, actual string) bool`	method variant
`require.(*Assertions).JSONEqf(expected string, actual string, msg string, args ..any)`	method formatted variant

Signature	Usage
`assertions.JSONEq(t T, expected string, actual string, msgAndArgs ...any) bool`	internal implementation

Source: github.com/go-openapi/testify/v2/internal/assertions#JSONEq

JSONEqBytes

JSONEqBytes asserts that two JSON slices of bytes are semantically equivalent.

Expected and actual must be valid JSON.

Examples

	assertions.JSONEqBytes(t, []byte(`{"hello": "world", "foo": "bar"}`), []byte(`{"foo": "bar", "hello": "world"}`))
	success: []byte(`{"hello": "world", "foo": "bar"}`), []byte(`{"foo": "bar", "hello": "world"}`)
	failure: []byte(`{"hello": "world", "foo": "bar"}`), []byte(`[{"foo": "bar"}, {"hello": "world"}]`)

Copy and click to open Go Playground

// real-world test would inject *testing.T from TestJSONEqBytes(t *testing.T)
package main

import (
	"fmt"
	"testing"

	"github.com/go-openapi/testify/v2/assert"
)

func main() {
	t := new(testing.T) // should come from testing, e.g. func TestJSONEqBytes(t *testing.T)
	success := assert.JSONEqBytes(t, []byte(`{"hello": "world", "foo": "bar"}`), []byte(`{"foo": "bar", "hello": "world"}`))
	fmt.Printf("success: %t\n", success)

}

Copy and click to open Go Playground

// real-world test would inject *testing.T from TestJSONEqBytes(t *testing.T)
package main

import (
	"fmt"
	"testing"

	"github.com/go-openapi/testify/v2/require"
)

func main() {
	t := new(testing.T) // should come from testing, e.g. func TestJSONEqBytes(t *testing.T)
	require.JSONEqBytes(t, []byte(`{"hello": "world", "foo": "bar"}`), []byte(`{"foo": "bar", "hello": "world"}`))
	fmt.Println("passed")

}

Signature	Usage
`assert.JSONEqBytes(t T, expected []byte, actual []byte, msgAndArgs ...any) bool`	package-level function
`assert.JSONEqBytesf(t T, expected []byte, actual []byte, msg string, args ...any) bool`	formatted variant
`assert.(*Assertions).JSONEqBytes(expected []byte, actual []byte) bool`	method variant
`assert.(*Assertions).JSONEqBytesf(expected []byte, actual []byte, msg string, args ..any)`	method formatted variant

Signature	Usage
`require.JSONEqBytes(t T, expected []byte, actual []byte, msgAndArgs ...any) bool`	package-level function
`require.JSONEqBytesf(t T, expected []byte, actual []byte, msg string, args ...any) bool`	formatted variant
`require.(*Assertions).JSONEqBytes(expected []byte, actual []byte) bool`	method variant
`require.(*Assertions).JSONEqBytesf(expected []byte, actual []byte, msg string, args ..any)`	method formatted variant

Signature	Usage
`assertions.JSONEqBytes(t T, expected []byte, actual []byte, msgAndArgs ...any) bool`	internal implementation

Source: github.com/go-openapi/testify/v2/internal/assertions#JSONEqBytes

Maintainer Note
Proposal for enhancement.
We could use and indirection for users to inject their favorite JSON library like we do for YAML.

JSONEqT[EDoc, ADoc Text]

JSONEqT asserts that two JSON documents are semantically equivalent.

The expected and actual arguments may be string or []byte. They do not need to be of the same type.

Expected and actual must be valid JSON.

Examples

	assertions.JSONEqT(t, `{"hello": "world", "foo": "bar"}`, []byte(`{"foo": "bar", "hello": "world"}`))
	success: `{"hello": "world", "foo": "bar"}`, []byte(`{"foo": "bar", "hello": "world"}`)
	failure: `{"hello": "world", "foo": "bar"}`, `[{"foo": "bar"}, {"hello": "world"}]`

Copy and click to open Go Playground

// real-world test would inject *testing.T from TestJSONEqT(t *testing.T)
package main

import (
	"fmt"
	"testing"

	"github.com/go-openapi/testify/v2/assert"
)

func main() {
	t := new(testing.T) // should come from testing, e.g. func TestJSONEqT(t *testing.T)
	success := assert.JSONEqT(t, `{"hello": "world", "foo": "bar"}`, []byte(`{"foo": "bar", "hello": "world"}`))
	fmt.Printf("success: %t\n", success)

}

Copy and click to open Go Playground

// real-world test would inject *testing.T from TestJSONEqT(t *testing.T)
package main

import (
	"fmt"
	"testing"

	"github.com/go-openapi/testify/v2/require"
)

func main() {
	t := new(testing.T) // should come from testing, e.g. func TestJSONEqT(t *testing.T)
	require.JSONEqT(t, `{"hello": "world", "foo": "bar"}`, []byte(`{"foo": "bar", "hello": "world"}`))
	fmt.Println("passed")

}

Signature	Usage
`assert.JSONEqT[EDoc, ADoc Text](t T, expected EDoc, actual ADoc, msgAndArgs ...any) bool`	package-level function
`assert.JSONEqTf[EDoc, ADoc Text](t T, expected EDoc, actual ADoc, msg string, args ...any) bool`	formatted variant

Signature	Usage
`require.JSONEqT[EDoc, ADoc Text](t T, expected EDoc, actual ADoc, msgAndArgs ...any) bool`	package-level function
`require.JSONEqTf[EDoc, ADoc Text](t T, expected EDoc, actual ADoc, msg string, args ...any) bool`	formatted variant

Signature	Usage
`assertions.JSONEqT[EDoc, ADoc Text](t T, expected EDoc, actual ADoc, msgAndArgs ...any) bool`	internal implementation

Source: github.com/go-openapi/testify/v2/internal/assertions#JSONEqT

JSONMarshalAsT[EDoc Text]

JSONMarshalAsT wraps JSONEq after json.Marshal.

The input JSON may be a string or []byte.

It fails if the marshaling returns an error or if the expected JSON bytes differ semantically from the expected ones.

Examples

	actual := struct {
		A int `json:"a"`
	}{
		A: 10,
	}
	assertions.JSONUnmarshalAsT(t,expected, `{"a": 10}`)
	success: []byte(`{"A": "a"}`), dummyStruct{A: "a"}
	failure: `[{"foo": "bar"}, {"hello": "world"}]`, 1

Copy and click to open Go Playground

// real-world test would inject *testing.T from TestJSONMarshalAsT(t *testing.T)
package main

import (
	"fmt"
	"testing"

	"github.com/go-openapi/testify/v2/assert"
)

func main() {
	t := new(testing.T) // should come from testing, e.g. func TestJSONMarshalAsT(t *testing.T)
	success := assert.JSONMarshalAsT(t, []byte(`{"A": "a"}`), dummyStruct{A: "a"})
	fmt.Printf("success: %t\n", success)

}

type dummyStruct struct {
	A string
	b int
}

Copy and click to open Go Playground

// real-world test would inject *testing.T from TestJSONMarshalAsT(t *testing.T)
package main

import (
	"fmt"
	"testing"

	"github.com/go-openapi/testify/v2/require"
)

func main() {
	t := new(testing.T) // should come from testing, e.g. func TestJSONMarshalAsT(t *testing.T)
	require.JSONMarshalAsT(t, []byte(`{"A": "a"}`), dummyStruct{A: "a"})
	fmt.Println("passed")

}

type dummyStruct struct {
	A string
	b int
}

Signature	Usage
`assert.JSONMarshalAsT[EDoc Text](t T, expected EDoc, object any, msgAndArgs ...any) bool`	package-level function
`assert.JSONMarshalAsTf[EDoc Text](t T, expected EDoc, object any, msg string, args ...any) bool`	formatted variant

Signature	Usage
`require.JSONMarshalAsT[EDoc Text](t T, expected EDoc, object any, msgAndArgs ...any) bool`	package-level function
`require.JSONMarshalAsTf[EDoc Text](t T, expected EDoc, object any, msg string, args ...any) bool`	formatted variant

Signature	Usage
`assertions.JSONMarshalAsT[EDoc Text](t T, expected EDoc, object any, msgAndArgs ...any) bool`	internal implementation

Source: github.com/go-openapi/testify/v2/internal/assertions#JSONMarshalAsT

JSONUnmarshalAsT[Object any, ADoc Text]

JSONUnmarshalAsT wraps Equal after json.Unmarshal.

The input JSON may be a string or []byte.

It fails if the unmarshaling returns an error or if the resulting object is not equal to the expected one.

Be careful not to wrap the expected object into an “any” interface if this is not what you expected: the unmarshaling would take this type to unmarshal as a mapstringany.

Examples

	expected := struct {
		A int `json:"a"`
	}{
		A: 10,
	}
	assertions.JSONUnmarshalAsT(t,expected, `{"a": 10}`)
	success: dummyStruct{A: "a"} , []byte(`{"A": "a"}`)
	failure: 1, `[{"foo": "bar"}, {"hello": "world"}]`

Copy and click to open Go Playground

// real-world test would inject *testing.T from TestJSONUnmarshalAsT(t *testing.T)
package main

import (
	"fmt"
	"testing"

	"github.com/go-openapi/testify/v2/assert"
)

func main() {
	t := new(testing.T) // should come from testing, e.g. func TestJSONUnmarshalAsT(t *testing.T)
	success := assert.JSONUnmarshalAsT(t, dummyStruct{A: "a"}, []byte(`{"A": "a"}`))
	fmt.Printf("success: %t\n", success)

}

type dummyStruct struct {
	A string
	b int
}

Copy and click to open Go Playground

// real-world test would inject *testing.T from TestJSONUnmarshalAsT(t *testing.T)
package main

import (
	"fmt"
	"testing"

	"github.com/go-openapi/testify/v2/require"
)

func main() {
	t := new(testing.T) // should come from testing, e.g. func TestJSONUnmarshalAsT(t *testing.T)
	require.JSONUnmarshalAsT(t, dummyStruct{A: "a"}, []byte(`{"A": "a"}`))
	fmt.Println("passed")

}

type dummyStruct struct {
	A string
	b int
}

Signature	Usage
`assert.JSONUnmarshalAsT[Object any, ADoc Text](t T, expected Object, jazon ADoc, msgAndArgs ...any) bool`	package-level function
`assert.JSONUnmarshalAsTf[Object any, ADoc Text](t T, expected Object, jazon ADoc, msg string, args ...any) bool`	formatted variant

Signature	Usage
`require.JSONUnmarshalAsT[Object any, ADoc Text](t T, expected Object, jazon ADoc, msgAndArgs ...any) bool`	package-level function
`require.JSONUnmarshalAsTf[Object any, ADoc Text](t T, expected Object, jazon ADoc, msg string, args ...any) bool`	formatted variant

Signature	Usage
`assertions.JSONUnmarshalAsT[Object any, ADoc Text](t T, expected Object, jazon ADoc, msgAndArgs ...any) bool`	internal implementation

Source: github.com/go-openapi/testify/v2/internal/assertions#JSONUnmarshalAsT

Generated with github.com/go-openapi/testify/codegen/v2