Tons of unit tests

.gitignore

@@ -1,2 +1,4 @@
 Godeps/*
 !Godeps/Godeps.json
+coverage.out
+count.out

auth_test.go

@@ -73,6 +73,10 @@ func TestBasicAuthSearchCredential(t *testing.T) {
 	user, found = pairs.searchCredential(authorizationHeader("foo", "bar "))
 	assert.Empty(t, user)
 	assert.False(t, found)
+
+	user, found = pairs.searchCredential("")
+	assert.Empty(t, user)
+	assert.False(t, found)
 }
 
 func TestBasicAuthAuthorizationHeader(t *testing.T) {

binding/binding.go

@@ -50,3 +50,10 @@ func Default(method, contentType string) Binding {
 		}
 	}
 }
+
+func Validate(obj interface{}) error {
+	if err := _validator.ValidateStruct(obj); err != nil {
+		return error(err)
+	}
+	return nil
+}

binding/binding_test.go

@@ -0,0 +1,79 @@
+// Copyright 2014 Manu Martinez-Almeida.  All rights reserved.
+// Use of this source code is governed by a MIT style
+// license that can be found in the LICENSE file.
+
+package binding
+
+import (
+	"bytes"
+	"net/http"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+type FooStruct struct {
+	Foo string `json:"foo" form:"foo" xml:"foo" binding:"required"`
+}
+
+func TestBindingDefault(t *testing.T) {
+	assert.Equal(t, Default("GET", ""), GETForm)
+	assert.Equal(t, Default("GET", MIMEJSON), GETForm)
+
+	assert.Equal(t, Default("POST", MIMEJSON), JSON)
+	assert.Equal(t, Default("PUT", MIMEJSON), JSON)
+
+	assert.Equal(t, Default("POST", MIMEXML), XML)
+	assert.Equal(t, Default("PUT", MIMEXML2), XML)
+
+	assert.Equal(t, Default("POST", MIMEPOSTForm), POSTForm)
+	assert.Equal(t, Default("DELETE", MIMEPOSTForm), POSTForm)
+}
+
+func TestBindingJSON(t *testing.T) {
+	testBinding(t,
+		JSON, "json",
+		"/", "/",
+		`{"foo": "bar"}`, `{"bar": "foo"}`)
+}
+
+func TestBindingPOSTForm(t *testing.T) {
+	testBinding(t,
+		POSTForm, "post_form",
+		"/", "/",
+		"foo=bar", "bar=foo")
+}
+
+func TestBindingGETForm(t *testing.T) {
+	testBinding(t,
+		GETForm, "get_form",
+		"/?foo=bar", "/?bar=foo",
+		"", "")
+}
+
+func TestBindingXML(t *testing.T) {
+	testBinding(t,
+		XML, "xml",
+		"/", "/",
+		"<map><foo>bar</foo></map>", "<map><bar>foo</bar></map>")
+}
+
+func testBinding(t *testing.T, b Binding, name, path, badPath, body, badBody string) {
+	assert.Equal(t, b.Name(), name)
+
+	obj := FooStruct{}
+	req := requestWithBody(path, body)
+	err := b.Bind(req, &obj)
+	assert.NoError(t, err)
+	assert.Equal(t, obj.Foo, "bar")
+
+	obj = FooStruct{}
+	req = requestWithBody(badPath, badBody)
+	err = JSON.Bind(req, &obj)
+	assert.Error(t, err)
+}
+
+func requestWithBody(path, body string) (req *http.Request) {
+	req, _ = http.NewRequest("POST", path, bytes.NewBufferString(body))
+	return
+}

binding/get_form.go

@@ -19,8 +19,5 @@ func (_ getFormBinding) Bind(req *http.Request, obj interface{}) error {
 	if err := mapForm(obj, req.Form); err != nil {
 		return err
 	}
-	if err := _validator.ValidateStruct(obj); err != nil {
-		return error(err)
-	}
-	return nil
+	return Validate(obj)
 }

binding/json.go

@@ -21,8 +21,5 @@ func (_ jsonBinding) Bind(req *http.Request, obj interface{}) error {
 	if err := decoder.Decode(obj); err != nil {
 		return err
 	}
-	if err := _validator.ValidateStruct(obj); err != nil {
-		return error(err)
-	}
-	return nil
+	return Validate(obj)
 }

binding/post_form.go

@@ -19,8 +19,5 @@ func (_ postFormBinding) Bind(req *http.Request, obj interface{}) error {
 	if err := mapForm(obj, req.PostForm); err != nil {
 		return err
 	}
-	if err := _validator.ValidateStruct(obj); err != nil {
-		return error(err)
-	}
-	return nil
+	return Validate(obj)
 }

binding/validate_test.go

@@ -0,0 +1,53 @@
+// Copyright 2014 Manu Martinez-Almeida.  All rights reserved.
+// Use of this source code is governed by a MIT style
+// license that can be found in the LICENSE file.
+
+package binding
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+type struct1 struct {
+	Value float64 `binding:"required"`
+}
+
+type struct2 struct {
+	RequiredValue string `binding:"required"`
+	Value         float64
+}
+
+type struct3 struct {
+	Integer    int
+	String     string
+	BasicSlice []int
+	Boolean    bool
+
+	RequiredInteger       int       `binding:"required"`
+	RequiredString        string    `binding:"required"`
+	RequiredAnotherStruct struct1   `binding:"required"`
+	RequiredBasicSlice    []int     `binding:"required"`
+	RequiredComplexSlice  []struct2 `binding:"required"`
+	RequiredBoolean       bool      `binding:"required"`
+}
+
+func createStruct() struct3 {
+	return struct3{
+		RequiredInteger:       2,
+		RequiredString:        "hello",
+		RequiredAnotherStruct: struct1{1.5},
+		RequiredBasicSlice:    []int{1, 2, 3, 4},
+		RequiredComplexSlice: []struct2{
+			{RequiredValue: "A"},
+			{RequiredValue: "B"},
+		},
+		RequiredBoolean: true,
+	}
+}
+
+func TestValidateGoodObject(t *testing.T) {
+	test := createStruct()
+	assert.Nil(t, Validate(&test))
+}

binding/xml.go

@@ -20,8 +20,5 @@ func (_ xmlBinding) Bind(req *http.Request, obj interface{}) error {
 	if err := decoder.Decode(obj); err != nil {
 		return err
 	}
-	if err := _validator.ValidateStruct(obj); err != nil {
-		return error(err)
-	}
-	return nil
+	return Validate(obj)
 }

context.go

@@ -61,6 +61,9 @@ func (c *Context) reset() {
 
 func (c *Context) Copy() *Context {
 	var cp Context = *c
+	cp.writermem.ResponseWriter = nil
+	cp.Writer = &cp.writermem
+	cp.Input.context = &cp
 	cp.index = AbortIndex
 	cp.handlers = nil
 	return &cp
@@ -161,7 +164,7 @@ func (c *Context) MustGet(key string) interface{} {
 	if value, exists := c.Get(key); exists {
 		return value
 	} else {
-		panic("Key " + key + " does not exist")
+		panic("Key \"" + key + "\" does not exist")
 	}
 }
 

context_test.go

@@ -16,6 +16,11 @@ import (
 	"github.com/stretchr/testify/assert"
 )
 
+// Unit tes TODO
+// func (c *Context) File(filepath string) {
+// func (c *Context) Negotiate(code int, config Negotiate) {
+// BAD case: func (c *Context) Render(code int, render render.Render, obj ...interface{}) {
+
 func createTestContext() (c *Context, w *httptest.ResponseRecorder, r *Engine) {
 	w = httptest.NewRecorder()
 	r = New()
@@ -64,6 +69,25 @@ func TestContextSetGet(t *testing.T) {
 	assert.Panics(t, func() { c.MustGet("no_exist") })
 }
 
+func TestContextCopy(t *testing.T) {
+	c, _, _ := createTestContext()
+	c.index = 2
+	c.Request, _ = http.NewRequest("POST", "/hola", nil)
+	c.handlers = []HandlerFunc{func(c *Context) {}}
+	c.Params = Params{Param{Key: "foo", Value: "bar"}}
+	c.Set("foo", "bar")
+
+	cp := c.Copy()
+	assert.Nil(t, cp.handlers)
+	assert.Equal(t, cp.Request, c.Request)
+	assert.Equal(t, cp.index, AbortIndex)
+	assert.Equal(t, &cp.writermem, cp.Writer.(*responseWriter))
+	assert.Equal(t, cp.Input.context, cp)
+	assert.Equal(t, cp.Keys, c.Keys)
+	assert.Equal(t, cp.Engine, c.Engine)
+	assert.Equal(t, cp.Params, c.Params)
+}
+
 // Tests that the response is serialized as JSON
 // and Content-Type is set to application/json
 func TestContextRenderJSON(t *testing.T) {
@@ -79,7 +103,7 @@ func TestContextRenderJSON(t *testing.T) {
 // and responds with Content-Type set to text/html
 func TestContextRenderHTML(t *testing.T) {
 	c, w, router := createTestContext()
-	templ, _ := template.New("t").Parse(`Hello {{.name}}`)
+	templ := template.Must(template.New("t").Parse(`Hello {{.name}}`))
 	router.SetHTMLTemplate(templ)
 
 	c.HTML(201, "t", H{"name": "alexandernyquist"})
@@ -160,6 +184,7 @@ func TestContextNegotiationFormat(t *testing.T) {
 	c, _, _ := createTestContext()
 	c.Request, _ = http.NewRequest("POST", "", nil)
 
+	assert.Panics(t, func() { c.NegotiateFormat() })
 	assert.Equal(t, c.NegotiateFormat(MIMEJSON, MIMEXML), MIMEJSON)
 	assert.Equal(t, c.NegotiateFormat(MIMEHTML, MIMEJSON), MIMEHTML)
 }
@@ -203,13 +228,19 @@ func TestContextAbortWithStatus(t *testing.T) {
 
 func TestContextError(t *testing.T) {
 	c, _, _ := createTestContext()
+	assert.Nil(t, c.LastError())
+	assert.Empty(t, c.Errors.String())
+
 	c.Error(errors.New("first error"), "some data")
 	assert.Equal(t, c.LastError().Error(), "first error")
 	assert.Len(t, c.Errors, 1)
+	assert.Equal(t, c.Errors.String(), "Error #01: first error\n     Meta: some data\n")
 
 	c.Error(errors.New("second error"), "some data 2")
 	assert.Equal(t, c.LastError().Error(), "second error")
 	assert.Len(t, c.Errors, 2)
+	assert.Equal(t, c.Errors.String(), "Error #01: first error\n     Meta: some data\n"+
+		"Error #02: second error\n     Meta: some data 2\n")
 
 	assert.Equal(t, c.Errors[0].Err, "first error")
 	assert.Equal(t, c.Errors[0].Meta, "some data")

debug_test.go

@@ -10,6 +10,10 @@ import (
 	"github.com/stretchr/testify/assert"
 )
 
+// TODO
+// func debugRoute(httpMethod, absolutePath string, handlers []HandlerFunc) {
+// func debugPrint(format string, values ...interface{}) {
+
 func TestIsDebugging(t *testing.T) {
 	SetMode(DebugMode)
 	assert.True(t, IsDebugging())

errors.go

@@ -43,7 +43,7 @@ func (a errorMsgs) String() string {
 	}
 	var buffer bytes.Buffer
 	for i, msg := range a {
-		text := fmt.Sprintf("Error #%02d: %s \n     Meta: %v\n", (i + 1), msg.Err, msg.Meta)
+		text := fmt.Sprintf("Error #%02d: %s\n     Meta: %v\n", (i + 1), msg.Err, msg.Meta)
 		buffer.WriteString(text)
 	}
 	return buffer.String()

gin.go

@@ -144,6 +144,13 @@ func (engine *Engine) handle(method, path string, handlers []HandlerFunc) {
 	if path[0] != '/' {
 		panic("path must begin with '/'")
 	}
+	if method == "" {
+		panic("HTTP method can not be empty")
+	}
+	if len(handlers) == 0 {
+		panic("there must be at least one handler")
+	}
+
 	root := engine.trees[method]
 	if root == nil {
 		root = new(node)