Skip to content

Refactor yamlassert to fluent String/Bytes/Reader assertion types and update examples/tests #12

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 1 commit into from
Jun 22, 2026
Merged

Refactor yamlassert to fluent String/Bytes/Reader assertion types and update examples/tests #12

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
1 commit
Select commit
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
52 changes: 27 additions & 25 deletions hammy/README.md
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -68,9 +68,9 @@ Use `yamlassert` for semantic YAML equality, path checks, and multi-document str
```go
import ya "github.com/gogunit/gunit/hammy/yamlassert"

assert.Is(ya.Equal(actualYAML, expectedYAML))
assert.Is(ya.PathEqual(actualYAML, "user.name", "Ada\n"))
assert.Is(ya.DocumentCount(actualYAML, 2))
assert.Is(ya.String(actualYAML).EqualTo(expectedYAML))
assert.Is(ya.String(actualYAML).PathEqual("user.name", "Ada\n"))
assert.Is(ya.String(actualYAML).DocumentCount(2))
```

## Generic Matcher Core
Expand Down Expand Up @@ -159,30 +159,32 @@ func Test_payload_has_expected_type(t *testing.T) {

## YAML (`hammy/yamlassert`)

* [x] ArrayContains
* [x] ArrayContainsBytes
* [x] Contains
* [x] ContainsBytes
* [x] DocumentContains
* [x] DocumentContainsBytes
* [x] DocumentCount
* [x] DocumentCountBytes
* [x] DocumentEqual
* [x] DocumentEqualBytes
* [x] Equal
* [x] EqualBytes
* [x] EqualBytesWithOptions
* [x] EqualReader
* [x] EqualWithOptions
* [x] Bytes
* [x] Bytes.ArrayContains
* [x] Bytes.Contains
* [x] Bytes.DocumentContains
* [x] Bytes.DocumentCount
* [x] Bytes.DocumentEqual
* [x] Bytes.EqualTo
* [x] Bytes.EqualToWithOptions
* [x] Reader
* [x] Reader.EqualTo
* [x] Reader.IsValid
* [x] String
* [x] String.ArrayContains
* [x] String.Contains
* [x] String.DocumentContains
* [x] String.DocumentCount
* [x] String.DocumentEqual
* [x] String.EqualTo
* [x] String.EqualToWithOptions
* [x] IgnorePaths
* [x] PathEqual
* [x] PathEqualBytes
* [x] PathExists
* [x] PathMissing
* [x] String.PathEqual
* [x] String.PathExists
* [x] String.PathMissing
* [x] UnorderedArraysAt
* [x] Valid
* [x] ValidBytes
* [x] ValidReader
* [x] String.IsValid
* [x] Bytes.IsValid

## Number

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

func ExampleEqual() {
func ExampleStringAssert_EqualTo() {
actual := "name: Ada\nage: 37\n"
expected := "age: 37.0\nname: Ada\n"

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

func ExampleEqualWithOptions() {
func ExampleStringAssert_EqualToWithOptions() {
actual := "status: ok\nmeta:\n request_id: abc\n"
expected := "status: ok\nmeta:\n request_id: xyz\n"

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

func ExampleEqualBytes() {
printExample(yamlassert.EqualBytes([]byte("one: 1\n"), []byte("one: 1.0\n")))
func ExampleBytesAssert_EqualTo() {
printExample(yamlassert.Bytes([]byte("one: 1\n")).EqualTo([]byte("one: 1.0\n")))
// Output:
// message="YAML mismatch (-want +got):\n"
// success=true
}

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

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

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

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

func ExampleValid() {
printExample(yamlassert.Valid("name: Ada\n"))
func ExampleStringAssert_IsValid() {
printExample(yamlassert.String("name: Ada\n").IsValid())
// Output:
// message="got valid YAML"
// success=true
}

func ExampleValidBytes() {
printExample(yamlassert.ValidBytes([]byte("name: Ada\n")))
func ExampleBytesAssert_IsValid() {
printExample(yamlassert.Bytes([]byte("name: Ada\n")).IsValid())
// Output:
// message="got valid YAML"
// success=true
}

func ExampleValidReader() {
printExample(yamlassert.ValidReader(strings.NewReader("name: Ada\n")))
func ExampleReaderAssert_IsValid() {
printExample(yamlassert.Reader(strings.NewReader("name: Ada\n")).IsValid())
// Output:
// message="got valid YAML"
// success=true
}

func ExampleContains() {
func ExampleStringAssert_Contains() {
actual := "status: ok\nmeta:\n page: 1\n request_id: abc\n"
expected := "meta:\n page: 1.0\n"

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

func ExampleContainsBytes() {
func ExampleBytesAssert_Contains() {
actual := []byte("status: ok\nextra: true\n")
expected := []byte("status: ok\n")

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

func ExamplePathExists() {
printExample(yamlassert.PathExists("user:\n name: Ada\n", "user.name"))
func ExampleStringAssert_PathExists() {
printExample(yamlassert.String("user:\n name: Ada\n").PathExists("user.name"))
// Output:
// message="YAML path <user.name> exists"
// success=true
}

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

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

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

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

func ExampleArrayContains() {
func ExampleStringAssert_ArrayContains() {
actual := "items:\n - id: 1\n - id: 2\n"

printExample(yamlassert.ArrayContains(actual, "items", "id: 2.0\n"))
printExample(yamlassert.String(actual).ArrayContains("items", "id: 2.0\n"))
// Output:
// message="found matching element at YAML path <items> index <1>"
// success=true
}

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

printExample(yamlassert.ArrayContainsBytes(actual, "items", expected))
printExample(yamlassert.Bytes(actual).ArrayContains("items", expected))
// Output:
// message="found matching element at YAML path <items> index <1>"
// success=true
Expand All @@ -150,7 +150,7 @@ func ExampleIgnorePaths() {
actual := "status: ok\nmeta:\n request_id: abc\n"
expected := "status: ok\nmeta:\n request_id: xyz\n"

printExample(yamlassert.EqualWithOptions(actual, expected, yamlassert.IgnorePaths("meta.request_id")))
printExample(yamlassert.String(actual).EqualTo(expected, yamlassert.IgnorePaths("meta.request_id")))
// Output:
// message="YAML mismatch (-want +got):\n"
// success=true
Expand All @@ -160,52 +160,52 @@ func ExampleUnorderedArraysAt() {
actual := "tags: [go, test, yaml]\n"
expected := "tags: [yaml, go, test]\n"

printExample(yamlassert.EqualWithOptions(actual, expected, yamlassert.UnorderedArraysAt("tags")))
printExample(yamlassert.String(actual).EqualTo(expected, yamlassert.UnorderedArraysAt("tags")))
// Output:
// message="YAML mismatch (-want +got):\n"
// success=true
}

func ExampleDocumentCount() {
printExample(yamlassert.DocumentCount("---\nname: Ada\n---\nname: Grace\n", 2))
func ExampleStringAssert_DocumentCount() {
printExample(yamlassert.String("---\nname: Ada\n---\nname: Grace\n").DocumentCount(2))
// Output:
// message="got YAML document count <2>, wanted <2>"
// success=true
}

func ExampleDocumentCountBytes() {
printExample(yamlassert.DocumentCountBytes([]byte("---\nname: Ada\n---\nname: Grace\n"), 2))
func ExampleBytesAssert_DocumentCount() {
printExample(yamlassert.Bytes([]byte("---\nname: Ada\n---\nname: Grace\n")).DocumentCount(2))
// Output:
// message="got YAML document count <2>, wanted <2>"
// success=true
}

func ExampleDocumentEqual() {
printExample(yamlassert.DocumentEqual("---\nname: Ada\n---\nname: Grace\n", 1, "name: Grace\n"))
func ExampleStringAssert_DocumentEqual() {
printExample(yamlassert.String("---\nname: Ada\n---\nname: Grace\n").DocumentEqual(1, "name: Grace\n"))
// Output:
// message="YAML document <1> mismatch (-want +got):\n"
// success=true
}

func ExampleDocumentEqualBytes() {
printExample(yamlassert.DocumentEqualBytes([]byte("---\nname: Ada\n"), 0, []byte("name: Ada\n")))
func ExampleBytesAssert_DocumentEqual() {
printExample(yamlassert.Bytes([]byte("---\nname: Ada\n")).DocumentEqual(0, []byte("name: Ada\n")))
// Output:
// message="YAML document <0> mismatch (-want +got):\n"
// success=true
}

func ExampleDocumentContains() {
func ExampleStringAssert_DocumentContains() {
actual := "---\nstatus: ok\nmeta:\n page: 1\n"
expected := "meta:\n page: 1.0\n"

printExample(yamlassert.DocumentContains(actual, 0, expected))
printExample(yamlassert.String(actual).DocumentContains(0, expected))
// Output:
// message="YAML document <0> contained expected subset"
// success=true
}

func ExampleDocumentContainsBytes() {
printExample(yamlassert.DocumentContainsBytes([]byte("---\nstatus: ok\n"), 0, []byte("status: ok\n")))
func ExampleBytesAssert_DocumentContains() {
printExample(yamlassert.Bytes([]byte("---\nstatus: ok\n")).DocumentContains(0, []byte("status: ok\n")))
// Output:
// message="YAML document <0> contained expected subset"
// success=true
Expand Down
Loading
Loading