format.Object: indendation changes how structs are formatted

[pohly]

https://go.dev/play/p/LXbkvF1LXba

package main

import (
	"errors"
	"fmt"

	"github.com/onsi/gomega/format"
)

func main() {
	err := errors.New("fake")
	fmt.Println(format.Object(err, 1))
	fmt.Println(format.Object(err, 0))
}

This should print the same content, just with different indentation. But in practice the "fake" string is only enclosed with quotation marks (which I prefer) inside the struct dump when indentation > 0:

    <*errors.errorString | 0xc000014070>: 
    fake
    {s: "fake"}
<*errors.errorString | 0xc000014070>: 
fake
{s: fake}

[onsi]

this proved a bit gnarly - but it's fixed now.

"rewrite the format package" is one of those things I'd love to do someday.

[pohly]

When updating Kubernetes to Gomega v1.38.3 a regression test failed: a template failure message produced by WithTemplate("Expected Pod {{.To}} be in {{format .Data}}\nGot instead:\n{{.FormattedActual}}").WithTemplateData(phase) where phase is a string type became unquoted.

Before:

Expected Pod to be in <v1.PodPhase>: "Running"

After:

Expected Pod to be in <v1.PodPhase>: Running

https://github.com/kubernetes/kubernetes/blob/c180d6762d7ac5059d9b50457cafb0d7f4cf74a9/test/e2e/framework/pod/wait.go#L120

Not sure whether it's worth fixing. Maybe? A string type could contain characters which need quoting.

[pohly]

So this is because templating uses format.Object(<value>, 1), which previously was considered "nested" and thus quoted. Now it's considered the top-level value and not quoted.

Reproducer: https://go.dev/play/p/kbKNMfik7yq

Unit test:

diff --git a/gcustom/make_matcher_test.go b/gcustom/make_matcher_test.go
index 6c45419..805985f 100644
--- a/gcustom/make_matcher_test.go
+++ b/gcustom/make_matcher_test.go
@@ -250,6 +250,16 @@ var _ = Describe("MakeMatcher", func() {
                                Ω(m.NegatedFailureMessage(someType{"foo"})).Should(Equal("false true not to     <gcustom_test.someType>: {Name: \"foo\"} foo <int>: 17"))
                        })
 
+                       It("for a string type", func() {
+                               templ, err := gcustom.ParseTemplate("{{.To}} {{.FormattedActual}} {{format .Data}}")
+                               Ω(err).ShouldNot(HaveOccurred())
+
+                               type enumType string
+                               m = m.WithPrecompiledTemplate(templ, enumType("fish"))
+                               Ω(m.FailureMessage(enumType("thanks"))).Should(Equal("to     <gcustom_test.enumType>: thanks <gcustom_test.enumType>: fish"))
+                               Ω(m.NegatedFailureMessage(enumType("thanks"))).Should(Equal("not to     <gcustom_test.enumType>: thanks <gcustom_test.enumType>: fish"))
+                       })
+
                        It("can also take a template as an argument upon construction", func() {
                                templ, err := gcustom.ParseTemplate("{{.To}} {{format .Data}}")
                                Ω(err).ShouldNot(HaveOccurred())