jimeh/go-render
1
0
Fork 0
mirror of https://github.com/jimeh/go-render.git synced 2026-02-19 03:16:39 +00:00
Code Issues Packages Projects Releases Wiki Activity

chore: improve errors and tests

Browse Source
This commit is contained in:
Jim Myhrberg
2024-03-23 21:05:57 +00:00
parent 5247fbd90b
commit ccc3668fa2
7 changed files with 262 additions and 30 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
binary.go
View File

@@ -17,7 +17,7 @@ var _ FormatRenderer = (*Binary)(nil)
func (bm *Binary) Render(w io.Writer, v any) error {
x, ok := v.(encoding.BinaryMarshaler)
if !ok {
return ErrCannotRender
return fmt.Errorf("%w: %T", ErrCannotRender, v)
}
b, err := x.MarshalBinary()

1
binary_test.go
View File

@@ -37,6 +37,7 @@ func TestBinary_Render(t *testing.T) {
{
name: "does not implement encoding.BinaryMarshaler",
value: struct{}{},
wantErr: "render: cannot render: struct {}",
wantErrIs: []error{render.Err, render.ErrCannotRender},
},
{

3
multi.go
View File

@@ -2,6 +2,7 @@ package render
import (
"errors"
"fmt"
"io"
)
@@ -26,5 +27,5 @@ func (mr *MultiRenderer) Render(w io.Writer, v any) error {
}
}
return ErrCannotRender
return fmt.Errorf("%w: %T", ErrCannotRender, v)
}

3
multi_test.go
View File

@@ -28,7 +28,8 @@ func TestMultiRenderer_Render(t *testing.T) {
cannotRenderer,
cannotRenderer,
},
value: struct{}{},
value: "test",
wantErr: "render: cannot render: string",
wantErrIs: []error{render.ErrCannotRender},
},
{

6
render.go
View File

@@ -104,6 +104,10 @@ func Render(w io.Writer, format string, v any) error {
func New(formats ...string) (*Renderer, error) {
renderers := map[string]FormatRenderer{}
if len(formats) == 0 {
return nil, fmt.Errorf("%w: no formats specified", Err)
}
for _, format := range formats {
switch format {
case "binary":
@@ -128,7 +132,7 @@ func New(formats ...string) (*Renderer, error) {
func MustNew(formats ...string) *Renderer {
r, err := New(formats...)
if err != nil {
panic(err)
panic(err.Error())
}
return r

97
render_example_test.go
View File

@@ -201,7 +201,77 @@ func (u *User) String() string {
)
}
func ExampleRender_textViaStringer() {
func ExampleRender_textFromByteSlice() {
data := []byte("Hello, World!1")
// Render the object to XML.
buf := &bytes.Buffer{}
err := render.Render(buf, "text", data)
if err != nil {
panic(err)
}
fmt.Println(buf.String())
// Output:
// Hello, World!1
}
func ExampleRender_textFromString() {
data := "Hello, World!"
// Render the object to XML.
buf := &bytes.Buffer{}
err := render.Render(buf, "text", data)
if err != nil {
panic(err)
}
fmt.Println(buf.String())
// Output:
// Hello, World!
}
func ExampleRender_textFromIOReader() {
var data io.Reader = strings.NewReader("Hello, World!!!1")
// Render the object to XML.
buf := &bytes.Buffer{}
err := render.Render(buf, "text", data)
if err != nil {
panic(err)
}
fmt.Println(buf.String())
// Output:
// Hello, World!!!1
}
func ExampleRender_textFromWriterTo() {
// The Role struct has a WriteTo method which writes a string representation
// of a role to an io.Writer:
//
// func (r *Role) WriteTo(w io.Writer) (int64, error) {
// s := fmt.Sprintf("%s (%s)", r.Name, r.Icon)
// n, err := w.Write([]byte(s))
//
// return int64(n), err
// }
data := &Role{Name: "admin", Icon: "shield"}
// Render the object to XML.
buf := &bytes.Buffer{}
err := render.Render(buf, "text", data)
if err != nil {
panic(err)
}
fmt.Println(buf.String())
// Output:
// admin (shield)
}
func ExampleRender_textFromStringer() {
// The User struct has a String method which returns a string representation
// of a user:
//
@@ -233,28 +303,3 @@ func ExampleRender_textViaStringer() {
// Output:
// John Doe (30): golang, json, yaml, toml
}
func ExampleRender_textViaWriterTo() {
// The Role struct has a WriteTo method which writes a string representation
// of a role to an io.Writer:
//
// func (r *Role) WriteTo(w io.Writer) (int64, error) {
// s := fmt.Sprintf("%s (%s)", r.Name, r.Icon)
// n, err := w.Write([]byte(s))
//
// return int64(n), err
// }
data := &Role{Name: "admin", Icon: "shield"}
// Render the object to XML.
buf := &bytes.Buffer{}
err := render.Render(buf, "text", data)
if err != nil {
panic(err)
}
fmt.Println(buf.String())
// Output:
// admin (shield)
}

180
render_test.go
View File

@@ -351,3 +351,183 @@ func TestRender(t *testing.T) {
})
}
}
func TestNew(t *testing.T) {
tests := []struct {
name string
formats []string
want *render.Renderer
wantErr string
wantErrIs []error
}{
{
name: "no formats",
formats: []string{},
wantErr: "render: no formats specified",
wantErrIs: []error{render.Err},
},
{
name: "single format",
formats: []string{"json"},
want: &render.Renderer{
Formats: map[string]render.FormatRenderer{
"json": render.DefaultJSON,
},
},
},
{
name: "multiple formats",
formats: []string{"json", "text", "yaml"},
want: &render.Renderer{
Formats: map[string]render.FormatRenderer{
"json": render.DefaultJSON,
"text": render.DefaultText,
"yaml": render.DefaultYAML,
},
},
},
{
name: "invalid format",
formats: []string{"json", "text", "invalid"},
wantErr: "render: unsupported format: invalid",
wantErrIs: []error{render.Err, render.ErrUnsupportedFormat},
},
{
name: "duplicate format",
formats: []string{"json", "text", "json"},
want: &render.Renderer{
Formats: map[string]render.FormatRenderer{
"json": render.DefaultJSON,
"text": render.DefaultText,
},
},
},
{
name: "all formats",
formats: []string{"json", "text", "yaml", "xml", "binary"},
want: &render.Renderer{
Formats: map[string]render.FormatRenderer{
"json": render.DefaultJSON,
"text": render.DefaultText,
"yaml": render.DefaultYAML,
"xml": render.DefaultXML,
"binary": render.DefaultBinary,
},
},
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
got, err := render.New(tt.formats...)
if tt.wantErr != "" {
assert.EqualError(t, err, tt.wantErr)
}
for _, e := range tt.wantErrIs {
assert.ErrorIs(t, err, e)
}
if tt.wantErr == "" && len(tt.wantErrIs) == 0 {
assert.NoError(t, err)
assert.Equal(t, tt.want, got)
}
})
}
}
func TestMustNew(t *testing.T) {
tests := []struct {
name string
formats []string
want *render.Renderer
wantErr string
wantErrIs []error
wantPanic string
}{
{
name: "no formats",
formats: []string{},
wantPanic: "render: no formats specified",
},
{
name: "single format",
formats: []string{"json"},
want: &render.Renderer{
Formats: map[string]render.FormatRenderer{
"json": render.DefaultJSON,
},
},
},
{
name: "multiple formats",
formats: []string{"json", "text", "yaml"},
want: &render.Renderer{
Formats: map[string]render.FormatRenderer{
"json": render.DefaultJSON,
"text": render.DefaultText,
"yaml": render.DefaultYAML,
},
},
},
{
name: "invalid format",
formats: []string{"json", "text", "invalid"},
wantPanic: "render: unsupported format: invalid",
},
{
name: "duplicate format",
formats: []string{"json", "text", "json"},
want: &render.Renderer{
Formats: map[string]render.FormatRenderer{
"json": render.DefaultJSON,
"text": render.DefaultText,
},
},
},
{
name: "all formats",
formats: []string{"json", "text", "yaml", "xml", "binary"},
want: &render.Renderer{
Formats: map[string]render.FormatRenderer{
"json": render.DefaultJSON,
"text": render.DefaultText,
"yaml": render.DefaultYAML,
"xml": render.DefaultXML,
"binary": render.DefaultBinary,
},
},
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
var got *render.Renderer
var err error
var panicRes any
func() {
defer func() {
if r := recover(); r != nil {
panicRes = r
}
}()
got = render.MustNew(tt.formats...)
}()
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.wantPanic == "" &&
tt.wantErr == "" && len(tt.wantErrIs) == 0 {
assert.NoError(t, err)
assert.Equal(t, tt.want, got)
}
})
}
}