fix: panic in spew when dealing with unexported fields

[ccoVeille]

Summary

Fix panic that happens when spew tries to sort unexported fields

Changes

Fix the panic raised by Interface() on unexported fields

CanInterface() is the solution

Motivation

Now, go-spew is vendored, we can fix old issues we had

Related issues

• Related to go-spew vendoring #1826
• Closes Panic in assert/require.Equal when calling into go-spew #480
• Closes assert.Equal panic on diff unexported map with array as key #1813
• Closes internal/spew: don't panic on unexported struct key in map #1816
• Supersedes Catch panic when using go-spew #1824

[HaraldNordgren]

@ccoVeille Looks good! ✅

[HaraldNordgren]

Let's merge this? Then we can also close #1816.

[HaraldNordgren]

@ccoVeille Let's merge?

[ccoVeille]

I tend to not merge my own PR on a public repository.

Also, the release cycle of testify is slow paced.

@dolmen reviewed the changes and approved it.

Maybe @brackendawson could review them.

[brackendawson]

Results in such maps not being sorted:

func TestIfy(t *testing.T) {
	type test struct {
		m map[[1]byte]*struct{}
	}

	a := test{
		map[[1]byte]*struct{}{
			{1}: nil,
			{2}: nil,
		},
	}
	b := test{
		map[[1]byte]*struct{}{
			{2}: nil,
			{3}: nil,
			{1}: nil,
		},
	}

	assert.Equal(t, a, b)
}

Running tool: /usr/local/go/bin/go test -test.fullpath=true -timeout 30s -coverprofile=/var/folders/8c/f9y61rb14cn8c6_6lnz10q300000gn/T/vscode-gojqA8nF/go-code-cover github.com/brackendawson/kata -race

--- FAIL: TestIfy (0.00s)
    /Users/brackendawson/src/github.com/brackendawson/kata/kata_test.go:29: 
        	Error Trace:	/Users/brackendawson/src/github.com/brackendawson/kata/kata_test.go:29
        	Error:      	Not equal: 
        	            	expected: kata_test.test{m:map[[1]uint8]*struct {}{[1]uint8{0x1}:(*struct {})(nil), [1]uint8{0x2}:(*struct {})(nil)}}
        	            	actual  : kata_test.test{m:map[[1]uint8]*struct {}{[1]uint8{0x1}:(*struct {})(nil), [1]uint8{0x2}:(*struct {})(nil), [1]uint8{0x3}:(*struct {})(nil)}}
        	            	
        	            	Diff:
        	            	--- Expected
        	            	+++ Actual
        	            	@@ -1,8 +1,11 @@
        	            	 (kata_test.test) {
        	            	- m: (map[[1]uint8]*struct {}) (len=2) {
        	            	+ m: (map[[1]uint8]*struct {}) (len=3) {
        	            	+  ([1]uint8) (len=1) {
        	            	+   00000000  02                                                |.|
        	            	+  }: (*struct {})(<nil>),
        	            	+  ([1]uint8) (len=1) {
        	            	+   00000000  03                                                |.|
        	            	+  }: (*struct {})(<nil>),
        	            	   ([1]uint8) (len=1) {
        	            	    00000000  01                                                |.|
        	            	-  }: (*struct {})(<nil>),
        	            	-  ([1]uint8) (len=1) {
        	            	-   00000000  02                                                |.|
        	            	   }: (*struct {})(<nil>)
        	Test:       	TestIfy
FAIL
coverage: 0.0% of statements
FAIL	github.com/brackendawson/kata	0.327s
FAIL

This is better than a panic. We're able to format the map keys, so I wonder if we can fall back on a string sorting of the formatted values?