Improve test coverage

Fix all issues uncovered by tests.

Author: raphael

application.go

@@ -148,12 +148,8 @@ func (app *Application) NewHTTPRouterHandle(resName, actName string, h Handler)
 		// Build context
 		gctx, cancel := context.WithCancel(context.Background())
 		defer cancel() // Signal completion of request to any child goroutine
-		gctx = context.WithValue(context.Background(), reqKey, r)
-		gctx = context.WithValue(gctx, respKey, w)
-		gctx = context.WithValue(gctx, paramKey, params)
-		gctx = context.WithValue(gctx, queryKey, query)
-		gctx = context.WithValue(gctx, payloadKey, payload)
-		ctx := &Context{Context: gctx, Logger: logger}
+		ctx := NewContext(gctx, r, w, params, query, payload)
+		ctx.Logger = logger
 
 		// Handle invalid payload
 		handler := middleware
@@ -183,21 +179,21 @@ func (app *Application) NewHTTPRouterHandle(resName, actName string, h Handler)
 func DefaultErrorHandler(c *Context, e error) {
 	status := 500
 	if _, ok := e.(*support.BadRequestError); ok {
-		c.ResponseHeader().Set("Content-Type", "application/json")
+		c.Header().Set("Content-Type", "application/json")
 		status = 400
 	}
 	if err := c.Respond(status, []byte(e.Error())); err != nil {
 		Log.Error("failed to send default error handler response", "err", err)
 	}
 }
 
-// terseerrorhandler behaves like defaulterrorhandler except that it does not set the response
+// TerseErrorHandler behaves like DefaultErrorHandler except that it does not set the response
 // body for internal errors.
 func TerseErrorHandler(c *Context, e error) {
 	status := 500
 	var body []byte
 	if _, ok := e.(*support.BadRequestError); ok {
-		c.ResponseHeader().Set("Content-Type", "application/json")
+		c.Header().Set("Content-Type", "application/json")
 		status = 400
 		body = []byte(e.Error())
 	}

application_test.go

@@ -0,0 +1,222 @@
+package goa_test
+
+import (
+	"fmt"
+	"net/http"
+
+	"github.com/julienschmidt/httprouter"
+	. "github.com/onsi/ginkgo"
+	. "github.com/onsi/gomega"
+	"github.com/raphael/goa"
+)
+
+var _ = Describe("Application", func() {
+	const appName = "foo"
+	var app *goa.Application
+
+	BeforeEach(func() {
+		app = goa.New(appName)
+	})
+
+	Describe("New", func() {
+		It("creates an application", func() {
+			Ω(app).ShouldNot(BeNil())
+		})
+
+		It("initializes the application fields", func() {
+			Ω(app.Name).Should(Equal(appName))
+			Ω(app.Logger).ShouldNot(BeNil())
+			Ω(app.ErrorHandler).ShouldNot(BeNil())
+			Ω(app.Router).ShouldNot(BeNil())
+		})
+	})
+
+	Describe("Use", func() {
+		Context("with a valid middleware", func() {
+			var m goa.Middleware
+
+			BeforeEach(func() {
+				m = goa.RequestID()
+			})
+
+			JustBeforeEach(func() {
+				app.Use(m)
+			})
+
+			It("adds the middleware", func() {
+				Ω(app.Middleware).Should(HaveLen(1))
+				Ω(app.Middleware[0]).Should(BeAssignableToTypeOf(goa.RequestID()))
+			})
+		})
+	})
+
+	Describe("NewHTTPRouterHandle", func() {
+		const resName = "res"
+		const actName = "act"
+		var handler goa.Handler
+		const respStatus = 200
+		var respContent = []byte("response")
+
+		var httpHandle httprouter.Handle
+		var ctx *goa.Context
+
+		JustBeforeEach(func() {
+			httpHandle = app.NewHTTPRouterHandle(resName, actName, handler)
+		})
+
+		BeforeEach(func() {
+			handler = func(c *goa.Context) error {
+				ctx = c
+				c.Respond(respStatus, respContent)
+				return nil
+			}
+		})
+
+		It("creates a handle", func() {
+			Ω(httpHandle).ShouldNot(BeNil())
+		})
+
+		Context("with a request", func() {
+			var rw http.ResponseWriter
+			var r *http.Request
+			var p httprouter.Params
+
+			BeforeEach(func() {
+				var err error
+				r, err = http.NewRequest("GET", "/foo", nil)
+				Ω(err).ShouldNot(HaveOccurred())
+				rw = new(TestResponseWriter)
+				id := httprouter.Param{Key: "id", Value: "42"}
+				query := httprouter.Param{Key: "sort", Value: "asc"}
+				p = httprouter.Params{id, query}
+			})
+
+			JustBeforeEach(func() {
+				httpHandle(rw, r, p)
+			})
+
+			It("creates a handle that handles the request", func() {
+				i, ok := ctx.Get("id")
+				Ω(ok).Should(BeTrue())
+				Ω(i).Should(Equal("42"))
+				s, ok := ctx.Get("sort")
+				Ω(ok).Should(BeTrue())
+				Ω(s).Should(Equal("asc"))
+				tw := rw.(*TestResponseWriter)
+				Ω(tw.Status).Should(Equal(respStatus))
+				Ω(tw.Body).Should(Equal(respContent))
+			})
+
+			Context("and middleware", func() {
+				middlewareCalled := false
+
+				BeforeEach(func() {
+					app.Use(TMiddleware(&middlewareCalled))
+				})
+
+				It("calls the middleware", func() {
+					Ω(middlewareCalled).Should(BeTrue())
+				})
+			})
+
+			Context("and a middleware chain", func() {
+				middlewareCalled := false
+				secondCalled := false
+
+				BeforeEach(func() {
+					app.Use(TMiddleware(&middlewareCalled))
+					app.Use(SecondMiddleware(&middlewareCalled, &secondCalled))
+				})
+
+				It("calls the middleware in the right order", func() {
+					Ω(middlewareCalled).Should(BeTrue())
+					Ω(secondCalled).Should(BeTrue())
+				})
+			})
+
+			Context("with a handler that fails", func() {
+				errorHandlerCalled := false
+				var oldErrorHandler goa.ErrorHandler
+
+				BeforeEach(func() {
+					oldErrorHandler = app.ErrorHandler
+					app.SetErrorHandler(TErrorHandler(&errorHandlerCalled))
+				})
+
+				AfterEach(func() {
+					app.SetErrorHandler(oldErrorHandler)
+				})
+
+				Context("by returning an error", func() {
+					BeforeEach(func() {
+						handler = func(ctx *goa.Context) error {
+							return fmt.Errorf("boom")
+						}
+					})
+
+					It("triggers the error handler", func() {
+						Ω(errorHandlerCalled).Should(BeTrue())
+					})
+				})
+
+				Context("by not handling the request", func() {
+					BeforeEach(func() {
+						handler = func(ctx *goa.Context) error {
+							return nil
+						}
+					})
+
+					It("triggers the error handler", func() {
+						Ω(errorHandlerCalled).Should(BeTrue())
+					})
+				})
+			})
+		})
+	})
+})
+
+func TErrorHandler(witness *bool) goa.ErrorHandler {
+	return func(ctx *goa.Context, err error) {
+		*witness = true
+	}
+}
+
+func TMiddleware(witness *bool) goa.Middleware {
+	return func(h goa.Handler) goa.Handler {
+		return func(ctx *goa.Context) error {
+			*witness = true
+			return h(ctx)
+		}
+	}
+}
+
+func SecondMiddleware(witness1, witness2 *bool) goa.Middleware {
+	return func(h goa.Handler) goa.Handler {
+		return func(ctx *goa.Context) error {
+			if !*witness1 {
+				panic("middleware called in wrong order")
+			}
+			*witness2 = true
+			return h(ctx)
+		}
+	}
+}
+
+type TestResponseWriter struct {
+	ParentHeader http.Header
+	Body         []byte
+	Status       int
+}
+
+func (t *TestResponseWriter) Header() http.Header {
+	return t.ParentHeader
+}
+
+func (t *TestResponseWriter) Write(b []byte) (int, error) {
+	t.Body = append(t.Body, b...)
+	return len(b), nil
+}
+
+func (t *TestResponseWriter) WriteHeader(s int) {
+	t.Status = s
+}

codegen/gen_app/generator_test.go

@@ -250,7 +250,7 @@ func (ctx *GetWidgetContext) OK(resp ID) error {
 	if err != nil {
 		return fmt.Errorf("invalid response: %s", err)
 	}
-	ctx.ResponseHeader().Set("Content-Type", "vnd.rightscale.codegen.test.widgets; charset=utf-8")
+	ctx.Header().Set("Content-Type", "vnd.rightscale.codegen.test.widgets; charset=utf-8")
 	return ctx.JSON(200, r)
 }
 `

codegen/gen_app/writers.go

@@ -397,7 +397,7 @@ func (ctx *{{$ctx.Name}}) {{goify .Name true}}({{$mt := (index $ctx.MediaTypes .
 	if err != nil {
 		return fmt.Errorf("invalid response: %s", err)
 	}
-	ctx.ResponseHeader().Set("Content-Type", "{{$mt.Identifier}}; charset=utf-8")
+	ctx.Header().Set("Content-Type", "{{$mt.Identifier}}; charset=utf-8")
 	return ctx.JSON({{.Status}}, r){{else}}return ctx.Respond({{.Status}}, nil){{end}}
 }
 {{end}}`