refactor: yet another one, someday I might be happy

renderer_test.go

@@ -1,12 +1,12 @@
-package render_test
+package render
 
 import (
 	"bytes"
 	"errors"
 	"fmt"
+	"strings"
 	"testing"
 
-	"github.com/jimeh/go-render"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 )
@@ -14,7 +14,7 @@ import (
 func TestRenderer_Render(t *testing.T) {
 	tests := []struct {
 		name      string
-		renderers map[string]render.FormatRenderer
+		renderers map[string]FormatRenderer
 		format    string
 		value     interface{}
 		want      string
@@ -23,7 +23,7 @@ func TestRenderer_Render(t *testing.T) {
 	}{
 		{
 			name: "existing renderer",
-			renderers: map[string]render.FormatRenderer{
+			renderers: map[string]FormatRenderer{
 				"mock": &mockRenderer{output: "mock output"},
 			},
 			format: "mock",
@@ -32,7 +32,7 @@ func TestRenderer_Render(t *testing.T) {
 		},
 		{
 			name: "existing renderer returns error",
-			renderers: map[string]render.FormatRenderer{
+			renderers: map[string]FormatRenderer{
 				"other": &mockRenderer{
 					output: "mock output",
 					err:    errors.New("mock error"),
@@ -44,30 +44,30 @@ func TestRenderer_Render(t *testing.T) {
 		},
 		{
 			name: "existing renderer returns ErrCannotRender",
-			renderers: map[string]render.FormatRenderer{
+			renderers: map[string]FormatRenderer{
 				"other": &mockRenderer{
 					output: "mock output",
-					err:    fmt.Errorf("%w: mock", render.ErrCannotRender),
+					err:    fmt.Errorf("%w: mock", ErrCannotRender),
 				},
 			},
 			format:    "other",
 			value:     struct{}{},
 			wantErr:   "render: unsupported format: other",
-			wantErrIs: []error{render.Err, render.ErrUnsupportedFormat},
+			wantErrIs: []error{Err, ErrUnsupportedFormat},
 		},
 		{
 			name:      "non-existing renderer",
-			renderers: map[string]render.FormatRenderer{},
+			renderers: map[string]FormatRenderer{},
 			format:    "unknown",
 			value:     struct{}{},
 			wantErr:   "render: unsupported format: unknown",
-			wantErrIs: []error{render.Err, render.ErrUnsupportedFormat},
+			wantErrIs: []error{Err, ErrUnsupportedFormat},
 		},
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			fr := &render.Renderer{
-				Formats: tt.renderers,
+			fr := &Renderer{
+				Renderers: tt.renderers,
 			}
 			var buf bytes.Buffer
 
@@ -98,41 +98,57 @@ func TestRenderer_RenderAllFormats(t *testing.T) {
 	tests = append(tests, yamlFormatTestCases...)
 
 	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			w := &mockWriter{WriteErr: tt.writeErr}
+		for _, format := range tt.formats {
+			t.Run(format+" format "+tt.name, func(t *testing.T) {
+				w := &mockWriter{WriteErr: tt.writeErr}
 
-			var err error
-			var panicRes any
-			renderer, err := render.New("binary", "json", "text", "xml", "yaml")
-			require.NoError(t, err)
+				value := tt.value
+				if tt.valueFunc != nil {
+					value = tt.valueFunc()
+				}
 
-			func() {
-				defer func() {
-					if r := recover(); r != nil {
-						panicRes = r
-					}
+				var err error
+				var panicRes any
+				renderer := compactRenderer
+				require.NoError(t, err)
+
+				func() {
+					defer func() {
+						if r := recover(); r != nil {
+							panicRes = r
+						}
+					}()
+					err = renderer.Render(w, format, value)
 				}()
-				err = renderer.Render(w, tt.format, tt.value)
-			}()
 
-			got := w.String()
+				got := w.String()
+				var want string
+				if tt.wantPretty == "" && tt.wantCompact == "" {
+					want = tt.want
+				} else {
+					want = tt.wantCompact
+				}
 
-			if tt.wantPanic != "" {
-				assert.Equal(t, tt.wantPanic, panicRes)
-			}
+				if tt.wantPanic != "" {
+					assert.Equal(t, tt.wantPanic, panicRes)
+				}
 
-			if tt.wantErr != "" {
-				assert.EqualError(t, err, tt.wantErr)
-			}
-			for _, e := range tt.wantErrIs {
-				assert.ErrorIs(t, err, e)
-			}
+				if tt.wantErr != "" {
+					wantErr := strings.ReplaceAll(
+						tt.wantErr, "{{format}}", format,
+					)
+					assert.EqualError(t, err, wantErr)
+				}
+				for _, e := range tt.wantErrIs {
+					assert.ErrorIs(t, err, e)
+				}
 
-			if tt.wantPanic == "" &&
-				tt.wantErr == "" && len(tt.wantErrIs) == 0 {
-				assert.NoError(t, err)
-				assert.Equal(t, tt.want, got)
-			}
-		})
+				if tt.wantPanic == "" &&
+					tt.wantErr == "" && len(tt.wantErrIs) == 0 {
+					assert.NoError(t, err)
+					assert.Equal(t, want, got)
+				}
+			})
+		}
 	}
 }