Skip to content

Add jsonassert receiver API #11

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Merged
nfisher merged 3 commits into from
Jun 22, 2026
Merged

Add jsonassert receiver API #11

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
3 commits
Select commit Hold shift + click to select a range
7449470
Add jsonassert receiver API
nfisher Jun 22, 2026
1aa82ce
Inline jsonassert compatibility wrappers
nfisher Jun 22, 2026
c98b5c3
Remove jsonassert legacy function exports
nfisher Jun 22, 2026
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
53 changes: 28 additions & 25 deletions hammy/README.md
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -58,9 +58,9 @@ Use `jsonassert` for semantic JSON equality that ignores object key order and in
```go
import ja "github.com/gogunit/gunit/hammy/jsonassert"

assert.Is(ja.Equal(actualJSON, expectedJSON))
assert.Is(ja.PathEqual(actualJSON, "user.name", `"Ada"`))
assert.Is(ja.EqualWithOptions(actualJSON, expectedJSON, ja.IgnorePaths("meta.request_id")))
assert.Is(ja.String(actualJSON).EqualTo(expectedJSON))
assert.Is(ja.String(actualJSON).PathEqual("user.name", `"Ada"`))
assert.Is(ja.String(actualJSON).EqualToWithOptions(expectedJSON, ja.IgnorePaths("meta.request_id")))
```

Use `yamlassert` for semantic YAML equality, path checks, and multi-document streams:
Expand Down Expand Up @@ -132,30 +132,33 @@ func Test_payload_has_expected_type(t *testing.T) {

## JSON (`hammy/jsonassert`)

* [x] ArrayContains
* [x] ArrayContainsBytes
* [x] Contains
* [x] ContainsBytes
* [x] Equal
* [x] EqualBytes
* [x] EqualBytesWithOptions
* [x] EqualLines
* [x] EqualLinesBytes
* [x] EqualLinesBytesWithOptions
* [x] EqualLinesWithOptions
* [x] EqualReader
* [x] EqualWithOptions
* [x] String
* [x] EqualTo
* [x] EqualToWithOptions
* [x] LinesEqualTo
* [x] LinesEqualToWithOptions
* [x] LinesContain
* [x] LinesContainSubset
* [x] IsValid
* [x] Contains
* [x] PathExists
* [x] PathMissing
* [x] PathEqual
* [x] ArrayContains
* [x] Bytes
* [x] EqualTo
* [x] EqualToWithOptions
* [x] LinesEqualTo
* [x] LinesEqualToWithOptions
* [x] IsValid
* [x] Contains
* [x] PathEqual
* [x] ArrayContains
* [x] Reader
* [x] EqualTo
* [x] IsValid
* [x] IgnorePaths
* [x] LinesContain
* [x] LinesContainSubset
* [x] PathEqual
* [x] PathEqualBytes
* [x] PathExists
* [x] PathMissing
* [x] UnorderedArraysAt
* [x] Valid
* [x] ValidBytes
* [x] ValidReader

## YAML (`hammy/yamlassert`)

Expand Down
96 changes: 48 additions & 48 deletions hammy/jsonassert/example_test.go
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -8,213 +8,213 @@ import (
"github.com/gogunit/gunit/hammy/jsonassert"
)

func ExampleEqual() {
func ExampleStringAssert_EqualTo() {
actual := `{"name":"Ada","age":37}`
expected := `{
"name": "Ada",
"age": 37
}`

printExample(jsonassert.Equal(actual, expected))
printExample(jsonassert.String(actual).EqualTo(expected))
// Output:
// message="JSON mismatch (-want +got):\n"
// success=true
}

func ExampleEqual_reorderedObjectKeys() {
func ExampleStringAssert_EqualTo_reorderedObjectKeys() {
actual := `{"name":"Ada","age":37}`
expected := `{"age":37,"name":"Ada"}`

printExample(jsonassert.Equal(actual, expected))
printExample(jsonassert.String(actual).EqualTo(expected))
// Output:
// message="JSON mismatch (-want +got):\n"
// success=true
}

func ExampleEqualWithOptions() {
func ExampleStringAssert_EqualToWithOptions() {
actual := `{"status":"ok","meta":{"request_id":"abc"}}`
expected := `{"status":"ok","meta":{"request_id":"xyz"}}`

printExample(jsonassert.EqualWithOptions(actual, expected, jsonassert.IgnorePaths("meta.request_id")))
printExample(jsonassert.String(actual).EqualToWithOptions(expected, jsonassert.IgnorePaths("meta.request_id")))
// Output:
// message="JSON mismatch (-want +got):\n"
// success=true
}

func ExampleEqualLines() {
func ExampleStringAssert_LinesEqualTo() {
actual := `{"name":"Ada","age":37}` + "\n" + `{"name":"Grace","age":85}`
expected := `{"age":37.0,"name":"Ada"}` + "\n" + `{"age":85.0,"name":"Grace"}`

printExample(jsonassert.EqualLines(actual, expected))
printExample(jsonassert.String(actual).LinesEqualTo(expected))
// Output:
// message="JSONL mismatch (-want +got):\n"
// success=true
}

func ExampleEqualLinesWithOptions() {
func ExampleStringAssert_LinesEqualToWithOptions() {
actual := `{"status":"ok","meta":{"request_id":"abc"}}` + "\n" + `{"status":"ok","meta":{"request_id":"def"}}`
expected := `{"status":"ok","meta":{"request_id":"uvw"}}` + "\n" + `{"status":"ok","meta":{"request_id":"xyz"}}`

printExample(jsonassert.EqualLinesWithOptions(actual, expected, jsonassert.IgnorePaths("meta.request_id")))
printExample(jsonassert.String(actual).LinesEqualToWithOptions(expected, jsonassert.IgnorePaths("meta.request_id")))
// Output:
// message="JSONL mismatch (-want +got):\n"
// success=true
}

func ExampleEqualLinesBytes() {
func ExampleBytesAssert_LinesEqualTo() {
actual := []byte(`{"id":1}` + "\n" + `{"id":2}`)
expected := []byte(`{"id":1.0}` + "\n" + `{"id":2.0}`)

printExample(jsonassert.EqualLinesBytes(actual, expected))
printExample(jsonassert.Bytes(actual).LinesEqualTo(expected))
// Output:
// message="JSONL mismatch (-want +got):\n"
// success=true
}

func ExampleEqualLinesBytesWithOptions() {
func ExampleBytesAssert_LinesEqualToWithOptions() {
actual := []byte(`{"tags":["go","test"]}` + "\n" + `{"tags":["json","assert"]}`)
expected := []byte(`{"tags":["test","go"]}` + "\n" + `{"tags":["assert","json"]}`)

printExample(jsonassert.EqualLinesBytesWithOptions(actual, expected, jsonassert.UnorderedArraysAt("tags")))
printExample(jsonassert.Bytes(actual).LinesEqualToWithOptions(expected, jsonassert.UnorderedArraysAt("tags")))
// Output:
// message="JSONL mismatch (-want +got):\n"
// success=true
}

func ExampleEqualBytes() {
func ExampleBytesAssert_EqualTo() {
actual := []byte(`{"one":1}`)
expected := []byte(`{"one":1.0}`)

printExample(jsonassert.EqualBytes(actual, expected))
printExample(jsonassert.Bytes(actual).EqualTo(expected))
// Output:
// message="JSON mismatch (-want +got):\n"
// success=true
}

func ExampleEqualBytesWithOptions() {
func ExampleBytesAssert_EqualToWithOptions() {
actual := []byte(`{"tags":["go","test"]}`)
expected := []byte(`{"tags":["test","go"]}`)

printExample(jsonassert.EqualBytesWithOptions(actual, expected, jsonassert.UnorderedArraysAt("tags")))
printExample(jsonassert.Bytes(actual).EqualToWithOptions(expected, jsonassert.UnorderedArraysAt("tags")))
// Output:
// message="JSON mismatch (-want +got):\n"
// success=true
}

func ExampleEqualReader() {
func ExampleReaderAssert_EqualTo() {
actual := strings.NewReader(`{"one":1}`)
expected := strings.NewReader(`{"one":1.0}`)

printExample(jsonassert.EqualReader(actual, expected))
printExample(jsonassert.Reader(actual).EqualTo(expected))
// Output:
// message="JSON mismatch (-want +got):\n"
// success=true
}

func ExampleValid() {
printExample(jsonassert.Valid(`{"name":"Ada"}`))
func ExampleStringAssert_IsValid() {
printExample(jsonassert.String(`{"name":"Ada"}`).IsValid())
// Output:
// message="got valid JSON"
// success=true
}

func ExampleValidBytes() {
printExample(jsonassert.ValidBytes([]byte(`{"name":"Ada"}`)))
func ExampleBytesAssert_IsValid() {
printExample(jsonassert.Bytes([]byte(`{"name":"Ada"}`)).IsValid())
// Output:
// message="got valid JSON"
// success=true
}

func ExampleValidReader() {
printExample(jsonassert.ValidReader(strings.NewReader(`{"name":"Ada"}`)))
func ExampleReaderAssert_IsValid() {
printExample(jsonassert.Reader(strings.NewReader(`{"name":"Ada"}`)).IsValid())
// Output:
// message="got valid JSON"
// success=true
}

func ExampleContains() {
func ExampleStringAssert_Contains() {
actual := `{"status":"ok","meta":{"page":1,"request_id":"abc"}}`
expected := `{"meta":{"page":1.0}}`

printExample(jsonassert.Contains(actual, expected))
printExample(jsonassert.String(actual).Contains(expected))
// Output:
// message="JSON contained expected subset"
// success=true
}

func ExampleContainsBytes() {
func ExampleBytesAssert_Contains() {
actual := []byte(`{"status":"ok","extra":true}`)
expected := []byte(`{"status":"ok"}`)

printExample(jsonassert.ContainsBytes(actual, expected))
printExample(jsonassert.Bytes(actual).Contains(expected))
// Output:
// message="JSON contained expected subset"
// success=true
}

func ExampleLinesContain() {
func ExampleStringAssert_LinesContain() {
actual := `{"id":1,"name":"Ada"}` + "\n" + `{"id":2,"name":"Grace"}`

printExample(jsonassert.LinesContain(actual, `{"name":"Grace","id":2.0}`))
printExample(jsonassert.String(actual).LinesContain(`{"name":"Grace","id":2.0}`))
// Output:
// message="found matching JSONL line <1>"
// success=true
}

func ExampleLinesContainSubset() {
func ExampleStringAssert_LinesContainSubset() {
actual := `{"status":"ok","meta":{"page":1,"request_id":"abc"}}` + "\n" + `{"status":"done"}`

printExample(jsonassert.LinesContainSubset(actual, `{"meta":{"page":1.0}}`))
printExample(jsonassert.String(actual).LinesContainSubset(`{"meta":{"page":1.0}}`))
// Output:
// message="found JSONL line <0> containing expected subset"
// success=true
}

func ExamplePathExists() {
printExample(jsonassert.PathExists(`{"user":{"name":"Ada"}}`, "user.name"))
func ExampleStringAssert_PathExists() {
printExample(jsonassert.String(`{"user":{"name":"Ada"}}`).PathExists("user.name"))
// Output:
// message="JSON path <user.name> exists"
// success=true
}

func ExamplePathMissing() {
printExample(jsonassert.PathMissing(`{"user":{"name":"Ada"}}`, "user.email"))
func ExampleStringAssert_PathMissing() {
printExample(jsonassert.String(`{"user":{"name":"Ada"}}`).PathMissing("user.email"))
// Output:
// message="JSON path <user.email> missing"
// success=true
}

func ExamplePathEqual() {
printExample(jsonassert.PathEqual(`{"user":{"age":37}}`, "user.age", `37.0`))
func ExampleStringAssert_PathEqual() {
printExample(jsonassert.String(`{"user":{"age":37}}`).PathEqual("user.age", `37.0`))
// Output:
// message="JSON path <user.age> mismatch (-want +got):\n"
// success=true
}

func ExamplePathEqualBytes() {
func ExampleBytesAssert_PathEqual() {
actual := []byte(`{"user":{"name":"Ada"}}`)
expected := []byte(`"Ada"`)

printExample(jsonassert.PathEqualBytes(actual, "user.name", expected))
printExample(jsonassert.Bytes(actual).PathEqual("user.name", expected))
// Output:
// message="JSON path <user.name> mismatch (-want +got):\n"
// success=true
}

func ExampleArrayContains() {
func ExampleStringAssert_ArrayContains() {
actual := `{"items":[{"id":1},{"id":2}]}`

printExample(jsonassert.ArrayContains(actual, "items", `{"id":2.0}`))
printExample(jsonassert.String(actual).ArrayContains("items", `{"id":2.0}`))
// Output:
// message="found matching element at JSON path <items> index <1>"
// success=true
}

func ExampleArrayContainsBytes() {
func ExampleBytesAssert_ArrayContains() {
actual := []byte(`{"items":[1,2]}`)
expected := []byte(`2.0`)

printExample(jsonassert.ArrayContainsBytes(actual, "items", expected))
printExample(jsonassert.Bytes(actual).ArrayContains("items", expected))
// Output:
// message="found matching element at JSON path <items> index <1>"
// success=true
Expand All @@ -224,7 +224,7 @@ func ExampleIgnorePaths() {
actual := `{"status":"ok","meta":{"request_id":"abc"}}`
expected := `{"status":"ok","meta":{"request_id":"xyz"}}`

printExample(jsonassert.EqualWithOptions(actual, expected, jsonassert.IgnorePaths("meta.request_id")))
printExample(jsonassert.String(actual).EqualToWithOptions(expected, jsonassert.IgnorePaths("meta.request_id")))
// Output:
// message="JSON mismatch (-want +got):\n"
// success=true
Expand All @@ -234,7 +234,7 @@ func ExampleUnorderedArraysAt() {
actual := `{"tags":["go","test","json"]}`
expected := `{"tags":["json","go","test"]}`

printExample(jsonassert.EqualWithOptions(actual, expected, jsonassert.UnorderedArraysAt("tags")))
printExample(jsonassert.String(actual).EqualToWithOptions(expected, jsonassert.UnorderedArraysAt("tags")))
// Output:
// message="JSON mismatch (-want +got):\n"
// success=true
Expand Down
Loading
Loading