Improve tests coverage

binder_test.go

@@ -5,19 +5,61 @@ import (
 	"github.com/stretchr/testify/assert"
 	"mime/multipart"
 	"net/http"
+	"reflect"
 	"strings"
 	"testing"
 )
 
 type (
 	customer struct {
-		ID   string `json:"id" xml:"id" form:"id"`
+		ID   int    `json:"id" xml:"id" form:"id"`
 		Name string `json:"name" xml:"name" form:"name"`
 	}
+
+	testStruct struct {
+		I           int
+		I8          int8
+		I16         int16
+		I32         int32
+		I64         int64
+		UI          uint
+		UI8         uint8
+		UI16        uint16
+		UI32        uint32
+		UI64        uint64
+		B           bool
+		F32         float32
+		F64         float64
+		S           string
+		cantSet     string
+		DoesntExist string
+	}
 )
 
+func (t testStruct) GetCantSet() string {
+	return t.cantSet
+}
+
+var values = map[string][]string{
+	"I":       {"0"},
+	"I8":      {"8"},
+	"I16":     {"16"},
+	"I32":     {"32"},
+	"I64":     {"64"},
+	"UI":      {"0"},
+	"UI8":     {"8"},
+	"UI16":    {"16"},
+	"UI32":    {"32"},
+	"UI64":    {"64"},
+	"B":       {"true"},
+	"F32":     {"32.5"},
+	"F64":     {"64.5"},
+	"S":       {"test"},
+	"cantSet": {"test"},
+}
+
 const (
-	customerJSON     = `{"id":"1","name":"Joe"}`
+	customerJSON     = `{"id":1,"name":"Joe"}`
 	customerXML      = `<customer><id>1</id><name>Joe</name></customer>`
 	customerForm     = `id=1&name=Joe`
 	incorrectContent = "this is incorrect content"
@@ -46,6 +88,8 @@ func TestXMLBinding(t *testing.T) {
 func TestFormBinding(t *testing.T) {
 	r, _ := http.NewRequest(POST, "/", strings.NewReader(customerForm))
 	testBindOk(t, r, ApplicationForm)
+	r, _ = http.NewRequest(POST, "/", nil)
+	testBindError(t, r, ApplicationForm)
 }
 
 func TestMultipartFormBinding(t *testing.T) {
@@ -62,18 +106,134 @@ func TestMultipartFormBinding(t *testing.T) {
 
 func TestUnsupportedMediaTypeBinding(t *testing.T) {
 	r, _ := http.NewRequest(POST, "/", strings.NewReader(customerJSON))
-
-	// Unsupported
 	testBindError(t, r, "")
 }
 
+func TestBindFormFunc(t *testing.T) {
+	r, _ := http.NewRequest(POST, "/", strings.NewReader(customerForm))
+	r.Header.Set(ContentType, ApplicationForm)
+	b := new(binder)
+	c := new(customer)
+	if assert.NoError(t, b.bindForm(r, c)) {
+		assertCustomer(t, c)
+	}
+}
+
+func TestBindMultiPartFormFunc(t *testing.T) {
+	body := new(bytes.Buffer)
+	mw := multipart.NewWriter(body)
+	mw.WriteField("id", "1")
+	mw.WriteField("name", "Joe")
+	mw.Close()
+	r, _ := http.NewRequest(POST, "/", body)
+	r.Header.Set(ContentType, mw.FormDataContentType())
+	b := new(binder)
+	c := new(customer)
+	if assert.NoError(t, b.bindMultiPartForm(r, c)) {
+		assertCustomer(t, c)
+	}
+}
+
+func assertCustomer(t *testing.T, c *customer) {
+	assert.Equal(t, 1, c.ID)
+	assert.Equal(t, "Joe", c.Name)
+}
+
+func TestMapForm(t *testing.T) {
+	ts := new(testStruct)
+	mapForm(ts, values)
+	assertTestStruct(t, ts)
+}
+
+func TestSetWithProperType(t *testing.T) {
+	ts := new(testStruct)
+	typ := reflect.TypeOf(ts).Elem()
+	val := reflect.ValueOf(ts).Elem()
+	for i := 0; i < typ.NumField(); i++ {
+		typeField := typ.Field(i)
+		structField := val.Field(i)
+		if !structField.CanSet() {
+			continue
+		}
+		if len(values[typeField.Name]) == 0 {
+			continue
+		}
+		val := values[typeField.Name][0]
+		err := setWithProperType(typeField.Type.Kind(), val, structField)
+		assert.NoError(t, err)
+	}
+	assertTestStruct(t, ts)
+
+	type foo struct {
+		Bar bytes.Buffer
+	}
+	v := &foo{}
+	typ = reflect.TypeOf(v).Elem()
+	val = reflect.ValueOf(v).Elem()
+	assert.Error(t, setWithProperType(typ.Field(0).Type.Kind(), "5", val.Field(0)))
+}
+
+func TestSetFields(t *testing.T) {
+	ts := new(testStruct)
+	val := reflect.ValueOf(ts).Elem()
+	// Int
+	if assert.NoError(t, setIntField("5", 0, val.FieldByName("I"))) {
+		assert.Equal(t, 5, ts.I)
+	}
+	if assert.NoError(t, setIntField("", 0, val.FieldByName("I"))) {
+		assert.Equal(t, 0, ts.I)
+	}
+
+	// Uint
+	if assert.NoError(t, setUintField("10", 0, val.FieldByName("UI"))) {
+		assert.Equal(t, uint(10), ts.UI)
+	}
+	if assert.NoError(t, setUintField("", 0, val.FieldByName("UI"))) {
+		assert.Equal(t, uint(0), ts.UI)
+	}
+
+	// Float
+	if assert.NoError(t, setFloatField("15.5", 0, val.FieldByName("F32"))) {
+		assert.Equal(t, float32(15.5), ts.F32)
+	}
+	if assert.NoError(t, setFloatField("", 0, val.FieldByName("F32"))) {
+		assert.Equal(t, float32(0.0), ts.F32)
+	}
+
+	// Bool
+	if assert.NoError(t, setBoolField("true", val.FieldByName("B"))) {
+		assert.Equal(t, true, ts.B)
+	}
+	if assert.NoError(t, setBoolField("", val.FieldByName("B"))) {
+		assert.Equal(t, false, ts.B)
+	}
+}
+
+func assertTestStruct(t *testing.T, ts *testStruct) {
+	assert.Equal(t, 0, ts.I)
+	assert.Equal(t, int8(8), ts.I8)
+	assert.Equal(t, int16(16), ts.I16)
+	assert.Equal(t, int32(32), ts.I32)
+	assert.Equal(t, int64(64), ts.I64)
+	assert.Equal(t, uint(0), ts.UI)
+	assert.Equal(t, uint8(8), ts.UI8)
+	assert.Equal(t, uint16(16), ts.UI16)
+	assert.Equal(t, uint32(32), ts.UI32)
+	assert.Equal(t, uint64(64), ts.UI64)
+	assert.Equal(t, true, ts.B)
+	assert.Equal(t, float32(32.5), ts.F32)
+	assert.Equal(t, float64(64.5), ts.F64)
+	assert.Equal(t, "test", ts.S)
+	assert.Equal(t, "", ts.GetCantSet())
+}
+
 func testBindOk(t *testing.T, r *http.Request, ct string) {
 	r.Header.Set(ContentType, ct)
-	u := new(customer)
+	c := new(customer)
-	err := new(binder).Bind(r, u)
+	err := new(binder).Bind(r, c)
 	if assert.NoError(t, err) {
-		assert.Equal(t, "1", u.ID)
+		assert.Equal(t, 1, c.ID)
-		assert.Equal(t, "Joe", u.Name)
+		assert.Equal(t, "Joe", c.Name)
 	}
 }
 
@@ -83,7 +243,8 @@ func testBindError(t *testing.T, r *http.Request, ct string) {
 	err := new(binder).Bind(r, u)
 
 	switch {
-	case strings.HasPrefix(ct, ApplicationJSON), strings.HasPrefix(ct, ApplicationXML), strings.HasPrefix(ct, ApplicationForm), strings.HasPrefix(ct, MultipartForm):
+	case strings.HasPrefix(ct, ApplicationJSON), strings.HasPrefix(ct, ApplicationXML),
+		strings.HasPrefix(ct, ApplicationForm), strings.HasPrefix(ct, MultipartForm):
 		if assert.IsType(t, new(HTTPError), err) {
 			assert.Equal(t, http.StatusBadRequest, err.(*HTTPError).code)
 		}

context_test.go

@@ -63,6 +63,16 @@ func TestContext(t *testing.T) {
 	c.Set("user", "Joe")
 	assert.Equal(t, "Joe", c.Get("user"))
 
+	// Bind
+	c.request, _ = http.NewRequest(POST, "/", strings.NewReader(userJSON))
+	c.request.Header.Set(ContentType, ApplicationJSON)
+	u := new(user)
+	err := c.Bind(u)
+	if assert.NoError(t, err) {
+		assert.Equal(t, "1", u.ID)
+		assert.Equal(t, "Joe", u.Name)
+	}
+
 	//--------
 	// Render
 	//--------
@@ -71,7 +81,7 @@ func TestContext(t *testing.T) {
 		templates: template.Must(template.New("hello").Parse("Hello, {{.}}!")),
 	}
 	c.echo.SetRenderer(tpl)
-	err := c.Render(http.StatusOK, "hello", "Joe")
+	err = c.Render(http.StatusOK, "hello", "Joe")
 	if assert.NoError(t, err) {
 		assert.Equal(t, http.StatusOK, rec.Code)
 		assert.Equal(t, "Hello, Joe!", rec.Body.String())

echo_test.go

@@ -12,6 +12,7 @@ import (
 
 	"errors"
 
+	"github.com/labstack/gommon/log"
 	"github.com/stretchr/testify/assert"
 	"golang.org/x/net/websocket"
 )
@@ -39,6 +40,29 @@ func TestEcho(t *testing.T) {
 	// DefaultHTTPErrorHandler
 	e.DefaultHTTPErrorHandler(errors.New("error"), c)
 	assert.Equal(t, http.StatusInternalServerError, rec.Code)
+
+	// Logger
+	l := log.New("test")
+	e.SetLogger(l)
+	assert.Equal(t, l, e.Logger())
+
+	// Autoindex
+	e.AutoIndex(true)
+	assert.True(t, e.autoIndex)
+}
+
+func TestListDir(t *testing.T) {
+	e := New()
+	req, _ := http.NewRequest(GET, "/", nil)
+	rec := httptest.NewRecorder()
+	c := NewContext(req, NewResponse(rec, e), e)
+	fs := http.Dir("_fixture")
+	f, err := fs.Open("images")
+	assert.NoError(t, err)
+	if assert.NoError(t, listDir(f, c)) {
+		assert.Equal(t, TextHTMLCharsetUTF8, rec.Header().Get(ContentType))
+		assert.Equal(t, "<pre>\n<a href=\"walle.png\" style=\"color: #212121;\">walle.png</a>\n</pre>\n", rec.Body.String())
+	}
 }
 
 func TestEchoIndex(t *testing.T) {
@@ -399,6 +423,8 @@ func TestEchoHTTPError(t *testing.T) {
 	he := NewHTTPError(http.StatusBadRequest, m)
 	assert.Equal(t, http.StatusBadRequest, he.Code())
 	assert.Equal(t, m, he.Error())
+	he.SetCode(http.StatusOK)
+	assert.Equal(t, http.StatusOK, he.Code())
 }
 
 func TestEchoServer(t *testing.T) {