diff --git a/capability/route.go b/capability/route.go
index 2fe977d..f2ecb31 100644
--- a/capability/route.go
+++ b/capability/route.go
@@ -9,7 +9,7 @@ import (
 
 func NewRoute() *ServerCapabilityRoute {
 	controller := &StaticCapabilityServer{
-		AvailableMethods: []string{"GET", "HEAD"},
+		AvailableMethods: []string{http.GET, http.HEAD},
 	}
 
 	return &ServerCapabilityRoute{Controller: controller}
@@ -19,11 +19,11 @@ type ServerCapabilityRoute struct {
 	Controller ServerResource
 }
 
-func (route *ServerCapabilityRoute) Route(requested *http.RequestLine) http.Request {
-	if requested.Target != "*" {
+func (route *ServerCapabilityRoute) Route(requested http.RequestMessage) http.Request {
+	if requested.Target() != "*" {
 		return nil
-	} else if requested.Method != "OPTIONS" {
-		return clienterror.MethodNotAllowed("OPTIONS")
+	} else if requested.Method() != http.OPTIONS {
+		return clienterror.MethodNotAllowed(http.OPTIONS)
 	}
 
 	return &optionsRequest{Resource: route.Controller}
diff --git a/capability/route_test.go b/capability/route_test.go
index 51f1e34..02c746f 100644
--- a/capability/route_test.go
+++ b/capability/route_test.go
@@ -20,7 +20,7 @@ var _ = Describe("::NewRoute", func() {
 		route := capability.NewRoute()
 		Expect(route.Controller).To(BeEquivalentTo(
 			&capability.StaticCapabilityServer{
-				AvailableMethods: []string{"GET", "HEAD"},
+				AvailableMethods: []string{http.GET, http.HEAD},
 			},
 		))
 	})
@@ -31,7 +31,7 @@ var _ = Describe("ServerCapabilityRoute", func() {
 		var (
 			router        http.Route
 			controller    *ServerCapabilityServerMock
-			requested     *http.RequestLine
+			requested     http.RequestMessage
 			routedRequest http.Request
 		)
 
@@ -40,23 +40,23 @@ var _ = Describe("ServerCapabilityRoute", func() {
 			router = &capability.ServerCapabilityRoute{Controller: controller}
 		})
 
-		Context("when the target is *", func() {
+		Context("when the path is *", func() {
 			It("routes OPTIONS to ServerResource", func() {
-				requested = &http.RequestLine{Method: "OPTIONS", Target: "*"}
+				requested = http.NewOptionsMessage("*")
 				routedRequest = router.Route(requested)
 				routedRequest.Handle(&bufio.Writer{})
 				controller.OptionsShouldHaveBeenCalled()
 			})
 
 			It("returns MethodNotAllowed for any other method", func() {
-				requested = &http.RequestLine{Method: "GET", Target: "*"}
+				requested = http.NewGetMessage("*")
 				routedRequest = router.Route(requested)
-				Expect(routedRequest).To(BeEquivalentTo(clienterror.MethodNotAllowed("OPTIONS")))
+				Expect(routedRequest).To(BeEquivalentTo(clienterror.MethodNotAllowed(http.OPTIONS)))
 			})
 		})
 
-		It("returns nil to pass on any other target", func() {
-			requested = &http.RequestLine{Method: "OPTIONS", Target: "/"}
+		It("returns nil to pass on any other path", func() {
+			requested = http.NewOptionsMessage("/")
 			routedRequest = router.Route(requested)
 			Expect(routedRequest).To(BeNil())
 		})
diff --git a/capability/server_capability.go b/capability/server_capability.go
index 87cd5e5..7efe2aa 100644
--- a/capability/server_capability.go
+++ b/capability/server_capability.go
@@ -5,6 +5,7 @@ import (
 	"strings"
 
 	"github.com/kkrull/gohttp/msg"
+	"github.com/kkrull/gohttp/msg/success"
 )
 
 // Reports on server capabilities that are defined during startup and do not change after that
@@ -13,7 +14,7 @@ type StaticCapabilityServer struct {
 }
 
 func (controller *StaticCapabilityServer) Options(client io.Writer) {
-	msg.WriteStatusLine(client, 200, "OK")
+	msg.WriteStatus(client, success.OKStatus)
 	msg.WriteHeader(client, "Allow", strings.Join(controller.AvailableMethods, ","))
 	msg.WriteContentLengthHeader(client, 0)
 	msg.WriteEndOfMessageHeader(client)
diff --git a/capability/server_capability_test.go b/capability/server_capability_test.go
index 76dd885..7f1bd9b 100644
--- a/capability/server_capability_test.go
+++ b/capability/server_capability_test.go
@@ -4,6 +4,7 @@ import (
 	"bytes"
 
 	"github.com/kkrull/gohttp/capability"
+	"github.com/kkrull/gohttp/http"
 	"github.com/kkrull/gohttp/httptest"
 	. "github.com/onsi/ginkgo"
 	. "github.com/onsi/gomega"
@@ -20,7 +21,7 @@ var _ = Describe("StaticCapabilityServer", func() {
 		BeforeEach(func() {
 			responseBuffer = &bytes.Buffer{}
 			controller = &capability.StaticCapabilityServer{
-				AvailableMethods: []string{"CONNECT", "TRACE"},
+				AvailableMethods: []string{http.CONNECT, http.TRACE},
 			}
 			controller.Options(responseBuffer)
 			response = httptest.ParseResponse(responseBuffer)
@@ -40,14 +41,14 @@ var _ = Describe("StaticCapabilityServer", func() {
 			BeforeEach(func() {
 				responseBuffer = &bytes.Buffer{}
 				controller = &capability.StaticCapabilityServer{
-					AvailableMethods: []string{"OPTIONS"},
+					AvailableMethods: []string{http.OPTIONS},
 				}
 				controller.Options(responseBuffer)
 				response = httptest.ParseResponse(responseBuffer)
 			})
 
 			It("sets Allow to that one method", func() {
-				response.HeaderShould("Allow", Equal("OPTIONS"))
+				response.HeaderShould("Allow", Equal(http.OPTIONS))
 			})
 		})
 
@@ -55,7 +56,7 @@ var _ = Describe("StaticCapabilityServer", func() {
 			BeforeEach(func() {
 				responseBuffer = &bytes.Buffer{}
 				controller = &capability.StaticCapabilityServer{
-					AvailableMethods: []string{"CONNECT", "TRACE"},
+					AvailableMethods: []string{http.CONNECT, http.TRACE},
 				}
 				controller.Options(responseBuffer)
 				response = httptest.ParseResponse(responseBuffer)
diff --git a/fs/directory_listing.go b/fs/directory_listing.go
index 0b77d4d..a0804a2 100644
--- a/fs/directory_listing.go
+++ b/fs/directory_listing.go
@@ -7,6 +7,7 @@ import (
 	"path"
 
 	"github.com/kkrull/gohttp/msg"
+	"github.com/kkrull/gohttp/msg/success"
 )
 
 type DirectoryListing struct {
@@ -22,7 +23,7 @@ func (listing *DirectoryListing) WriteTo(client io.Writer) error {
 }
 
 func (listing *DirectoryListing) WriteHeader(client io.Writer) error {
-	msg.WriteStatusLine(client, 200, "OK")
+	msg.WriteStatus(client, success.OKStatus)
 	msg.WriteContentTypeHeader(client, "text/html")
 
 	listing.body = listing.messageListingFiles()
diff --git a/fs/file_contents.go b/fs/file_contents.go
index ce010ce..0659c12 100644
--- a/fs/file_contents.go
+++ b/fs/file_contents.go
@@ -8,6 +8,7 @@ import (
 	"strconv"
 
 	"github.com/kkrull/gohttp/msg"
+	"github.com/kkrull/gohttp/msg/success"
 )
 
 type FileContents struct {
@@ -21,7 +22,7 @@ func (contents *FileContents) WriteTo(client io.Writer) error {
 }
 
 func (contents *FileContents) WriteHeader(client io.Writer) error {
-	msg.WriteStatusLine(client, 200, "OK")
+	msg.WriteStatus(client, success.OKStatus)
 	contents.writeHeadersDescribingFile(client)
 	msg.WriteEndOfMessageHeader(client)
 	return nil
diff --git a/fs/fs_suite_test.go b/fs/fs_suite_test.go
index 4dcbcd9..8473895 100644
--- a/fs/fs_suite_test.go
+++ b/fs/fs_suite_test.go
@@ -4,6 +4,7 @@ import (
 	"io"
 	"testing"
 
+	"github.com/kkrull/gohttp/http"
 	. "github.com/onsi/ginkgo"
 	. "github.com/onsi/gomega"
 )
@@ -14,7 +15,7 @@ func TestFs(t *testing.T) {
 }
 
 type FileSystemResourceMock struct {
-	getTarget  string
+	getPath    string
 	headTarget string
 }
 
@@ -22,12 +23,12 @@ func (mock *FileSystemResourceMock) Name() string {
 	return "File system mock"
 }
 
-func (mock *FileSystemResourceMock) Get(client io.Writer, target string) {
-	mock.getTarget = target
+func (mock *FileSystemResourceMock) Get(client io.Writer, req http.RequestMessage) {
+	mock.getPath = req.Path()
 }
 
-func (mock *FileSystemResourceMock) GetShouldHaveReceived(target string) {
-	ExpectWithOffset(1, mock.getTarget).To(Equal(target))
+func (mock *FileSystemResourceMock) GetShouldHaveReceived(path string) {
+	ExpectWithOffset(1, mock.getPath).To(Equal(path))
 }
 
 func (mock *FileSystemResourceMock) Head(client io.Writer, target string) {
diff --git a/fs/requests.go b/fs/requests.go
index 4cca831..ea6a02e 100644
--- a/fs/requests.go
+++ b/fs/requests.go
@@ -18,8 +18,8 @@ func (controller *ReadOnlyFileSystem) Name() string {
 	return "Readonly file system"
 }
 
-func (controller *ReadOnlyFileSystem) Get(client io.Writer, target string) {
-	response := controller.determineResponse(target)
+func (controller *ReadOnlyFileSystem) Get(client io.Writer, req http.RequestMessage) {
+	response := controller.determineResponse(req.Path())
 	response.WriteTo(client)
 }
 
@@ -28,18 +28,18 @@ func (controller *ReadOnlyFileSystem) Head(client io.Writer, target string) {
 	response.WriteHeader(client)
 }
 
-func (controller *ReadOnlyFileSystem) determineResponse(requestedTarget string) http.Response {
-	resolvedTarget := path.Join(controller.BaseDirectory, requestedTarget)
-	info, err := os.Stat(resolvedTarget)
+func (controller *ReadOnlyFileSystem) determineResponse(requestedPath string) http.Response {
+	resolvedPath := path.Join(controller.BaseDirectory, requestedPath)
+	info, err := os.Stat(resolvedPath)
 	if err != nil {
-		return &clienterror.NotFound{Target: requestedTarget}
+		return &clienterror.NotFound{Path: requestedPath}
 	} else if info.IsDir() {
-		files, _ := ioutil.ReadDir(resolvedTarget)
+		files, _ := ioutil.ReadDir(resolvedPath)
 		return &DirectoryListing{
 			Files:      readFileNames(files),
-			HrefPrefix: requestedTarget}
+			HrefPrefix: requestedPath}
 	} else {
-		return &FileContents{Filename: resolvedTarget}
+		return &FileContents{Filename: resolvedPath}
 	}
 }
 
diff --git a/fs/requests_test.go b/fs/requests_test.go
index 80beb97..9eda539 100644
--- a/fs/requests_test.go
+++ b/fs/requests_test.go
@@ -7,6 +7,7 @@ import (
 	"path"
 
 	"github.com/kkrull/gohttp/fs"
+	"github.com/kkrull/gohttp/http"
 	"github.com/kkrull/gohttp/httptest"
 	. "github.com/onsi/ginkgo"
 	. "github.com/onsi/gomega"
@@ -28,9 +29,9 @@ var _ = Describe("ReadOnlyFileSystem", func() {
 	})
 
 	Describe("#Get", func() {
-		Context("when the resolved target does not exist", func() {
+		Context("when the resolved path does not exist", func() {
 			BeforeEach(func() {
-				controller.Get(responseBuffer, "/missing.txt")
+				controller.Get(responseBuffer, http.NewGetMessage("/missing.txt"))
 				response = httptest.ParseResponse(responseBuffer)
 			})
 
@@ -48,11 +49,11 @@ var _ = Describe("ReadOnlyFileSystem", func() {
 			})
 		})
 
-		Context("when the target is a readable text file in the base path", func() {
+		Context("when the path is a readable text file in the base path", func() {
 			BeforeEach(func() {
 				existingFile := path.Join(basePath, "readable.txt")
 				Expect(createTextFile(existingFile, "A")).To(Succeed())
-				controller.Get(responseBuffer, "/readable.txt")
+				controller.Get(responseBuffer, http.NewGetMessage("/readable.txt"))
 				response = httptest.ParseResponse(responseBuffer)
 			})
 
@@ -70,40 +71,40 @@ var _ = Describe("ReadOnlyFileSystem", func() {
 			})
 		})
 
-		Context("when the target is a readable file named with a registered extension", func() {
+		Context("when the path is a readable file named with a registered extension", func() {
 			BeforeEach(func() {
 				existingFile := path.Join(basePath, "image.jpeg")
 				Expect(createTextFile(existingFile, "A")).To(Succeed())
 			})
 
 			It("sets Content-Type to the MIME type registered for that extension", func() {
-				controller.Get(responseBuffer, "/image.jpeg")
+				controller.Get(responseBuffer, http.NewGetMessage("/image.jpeg"))
 				response = httptest.ParseResponse(responseBuffer)
 				response.HeaderShould("Content-Type", Equal("image/jpeg"))
 			})
 		})
 
-		Context("when the target is a readable file without an extension", func() {
+		Context("when the path is a readable file without an extension", func() {
 			BeforeEach(func() {
 				existingFile := path.Join(basePath, "assumed-text")
 				Expect(createTextFile(existingFile, "A")).To(Succeed())
 			})
 
 			It("sets Content-Type to text/plain", func() {
-				controller.Get(responseBuffer, "/assumed-text")
+				controller.Get(responseBuffer, http.NewGetMessage("/assumed-text"))
 				response = httptest.ParseResponse(responseBuffer)
 				response.HeaderShould("Content-Type", Equal("text/plain"))
 			})
 		})
 
-		Context("when the target is /", func() {
+		Context("when the path is /", func() {
 			BeforeEach(func() {
 				existingFile := path.Join(basePath, "one")
 				Expect(createTextFile(existingFile, "1")).To(Succeed())
 			})
 
 			It("responds with 200 OK", func() {
-				controller.Get(responseBuffer, "/")
+				controller.Get(responseBuffer, http.NewGetMessage("/"))
 				response = httptest.ParseResponse(responseBuffer)
 				response.StatusShouldBe(200, "OK")
 			})
@@ -117,7 +118,7 @@ var _ = Describe("ReadOnlyFileSystem", func() {
 		)
 
 		BeforeEach(func() {
-			controller.Get(getResponseBuffer, "/missing.txt")
+			controller.Get(getResponseBuffer, http.NewGetMessage("/missing.txt"))
 			getResponse = httptest.ParseResponse(getResponseBuffer)
 
 			controller.Head(responseBuffer, "/missing.txt")
diff --git a/fs/route.go b/fs/route.go
index fa40ef3..524e837 100644
--- a/fs/route.go
+++ b/fs/route.go
@@ -18,13 +18,13 @@ type FileSystemRoute struct {
 	Resource        FileSystemResource
 }
 
-func (route FileSystemRoute) Route(requested *http.RequestLine) http.Request {
-	return http.MakeResourceRequest(requested, route.Resource)
+func (route FileSystemRoute) Route(requested http.RequestMessage) http.Request {
+	return requested.MakeResourceRequest(route.Resource)
 }
 
 // Represents files and directories on the file system
 type FileSystemResource interface {
 	Name() string
-	Get(client io.Writer, target string)
+	Get(client io.Writer, req http.RequestMessage)
 	Head(client io.Writer, target string)
 }
diff --git a/fs/route_test.go b/fs/route_test.go
index 3886e11..213068f 100644
--- a/fs/route_test.go
+++ b/fs/route_test.go
@@ -38,23 +38,23 @@ var _ = Describe("FileSystemRoute", func() {
 
 	Describe("#Route", func() {
 		It("routes GET requests to GetRequest", func() {
-			requested := &http.RequestLine{Method: "GET", Target: "/foo"}
+			requested := http.NewGetMessage("/foo")
 			routedRequest := route.Route(requested)
 			routedRequest.Handle(response)
 			resource.GetShouldHaveReceived("/foo")
 		})
 
 		It("routes HEAD requests to HeadRequest", func() {
-			requested := &http.RequestLine{Method: "HEAD", Target: "/foo"}
+			requested := http.NewHeadMessage("/foo")
 			routedRequest := route.Route(requested)
 			routedRequest.Handle(response)
 			resource.HeadShouldHaveReceived("/foo")
 		})
 
 		It("routes any other method to MethodNotAllowed", func() {
-			requested := &http.RequestLine{Method: "TRACE", Target: "/"}
+			requested := http.NewTraceMessage("/")
 			routedRequest := route.Route(requested)
-			Expect(routedRequest).To(BeEquivalentTo(clienterror.MethodNotAllowed("GET", "HEAD", "OPTIONS")))
+			Expect(routedRequest).To(BeEquivalentTo(clienterror.MethodNotAllowed(http.GET, http.HEAD, http.OPTIONS)))
 		})
 	})
 })
diff --git a/http/messages.go b/http/messages.go
new file mode 100644
index 0000000..77e91e0
--- /dev/null
+++ b/http/messages.go
@@ -0,0 +1,161 @@
+package http
+
+import (
+	"sort"
+
+	"github.com/kkrull/gohttp/msg/clienterror"
+	"github.com/kkrull/gohttp/msg/servererror"
+)
+
+const (
+	CONNECT string = "CONNECT"
+	GET     string = "GET"
+	HEAD    string = "HEAD"
+	OPTIONS string = "OPTIONS"
+	POST    string = "POST"
+	PUT     string = "PUT"
+	TRACE   string = "TRACE"
+)
+
+func NewGetMessage(path string) RequestMessage {
+	return &requestMessage{
+		method: GET,
+		target: path,
+		path:   path,
+	}
+}
+
+func NewHeadMessage(path string) RequestMessage {
+	return &requestMessage{
+		method: HEAD,
+		target: path,
+		path:   path,
+	}
+}
+
+// Creates an OPTIONS request to the specified target, which can either be a path starting with /
+// or an asterisk-form query of the server as a whole (https://tools.ietf.org/html/rfc7230#section-5.3.4).
+func NewOptionsMessage(targetAsteriskOrPath string) RequestMessage {
+	return &requestMessage{
+		method: OPTIONS,
+		target: targetAsteriskOrPath,
+		path:   targetAsteriskOrPath,
+	}
+}
+
+func NewPutMessage(path string) RequestMessage {
+	return &requestMessage{
+		method: PUT,
+		target: path,
+		path:   path,
+	}
+}
+
+func NewTraceMessage(path string) RequestMessage {
+	return &requestMessage{
+		method: TRACE,
+		target: path,
+		path:   path,
+	}
+}
+
+func NewRequestMessage(method, path string) RequestMessage {
+	return &requestMessage{
+		method: method,
+		target: path,
+		path:   path,
+	}
+}
+
+type requestMessage struct {
+	method          string
+	path            string
+	target          string
+	queryParameters []QueryParameter
+}
+
+func (message *requestMessage) Method() string {
+	return message.method
+}
+
+func (message *requestMessage) Path() string {
+	return message.path
+}
+
+func (message *requestMessage) AddQueryFlag(name string) {
+	message.queryParameters = append(message.queryParameters, QueryParameter{Name: name})
+}
+
+func (message *requestMessage) AddQueryParameter(name, value string) {
+	message.queryParameters = append(message.queryParameters, QueryParameter{Name: name, Value: value})
+}
+
+func (message *requestMessage) QueryParameters() []QueryParameter {
+	return message.queryParameters
+}
+
+func (message *requestMessage) Target() string {
+	return message.target
+}
+
+func (message *requestMessage) NotImplemented() Response {
+	return &servererror.NotImplemented{Method: message.method}
+}
+
+func (message *requestMessage) MakeResourceRequest(resource Resource) Request {
+	if message.method == OPTIONS {
+		return &optionsRequest{
+			SupportedMethods: message.supportedMethods(resource),
+		}
+	}
+
+	method := knownMethods[message.method]
+	if method == nil {
+		return message.unknownHttpMethod(resource)
+	}
+
+	request, isSupported := method.MakeRequest(message, resource)
+	if !isSupported {
+		return message.unsupportedMethod(resource)
+	}
+
+	return request
+}
+
+func (message *requestMessage) unknownHttpMethod(resource Resource) Request {
+	return clienterror.MethodNotAllowed(message.supportedMethods(resource)...)
+}
+
+func (message *requestMessage) unsupportedMethod(resource Resource) Request {
+	return clienterror.MethodNotAllowed(message.supportedMethods(resource)...)
+}
+
+func (message *requestMessage) supportedMethods(resource Resource) []string {
+	supported := []string{OPTIONS}
+	for name, method := range knownMethods {
+		imaginaryRequest := &requestMessage{method: name, target: message.target}
+		_, isSupported := method.MakeRequest(imaginaryRequest, resource)
+		if isSupported {
+			supported = append(supported, name)
+		}
+	}
+
+	sort.Strings(supported)
+	return supported
+}
+
+var knownMethods = map[string]Method{
+	GET:  &getMethod{},
+	HEAD: &headMethod{},
+	POST: &postMethod{},
+	PUT:  &putMethod{},
+}
+
+type Method interface {
+	MakeRequest(requested *requestMessage, resource Resource) (request Request, isSupported bool)
+}
+
+// Handles requests of supported HTTP methods for a resource
+type Resource interface {
+	Name() string
+}
diff --git a/http/method_dispatcher.go b/http/method_dispatcher.go
deleted file mode 100644
index 615fd84..0000000
--- a/http/method_dispatcher.go
+++ /dev/null
@@ -1,65 +0,0 @@
-package http
-
-import (
-	"sort"
-
-	"github.com/kkrull/gohttp/msg/clienterror"
-)
-
-func MakeResourceRequest(requested *RequestLine, resource Resource) Request {
-	if requested.Method == "OPTIONS" {
-		return &optionsRequest{
-			SupportedMethods: supportedMethods(requested.Target, resource),
-		}
-	}
-
-	method := knownMethods[requested.Method]
-	if method == nil {
-		return unknownHttpMethod(requested, resource)
-	}
-
-	request := method.MakeRequest(requested, resource)
-	if request == nil {
-		return unsupportedMethod(requested, resource)
-	}
-
-	return request
-}
-
-func unknownHttpMethod(requested *RequestLine, resource Resource) Request {
-	return clienterror.MethodNotAllowed(supportedMethods(requested.Target, resource)...)
-}
-
-func unsupportedMethod(requested *RequestLine, resource Resource) Request {
-	return clienterror.MethodNotAllowed(supportedMethods(requested.Target, resource)...)
-}
-
-func supportedMethods(target string, resource Resource) []string {
-	supported := []string{"OPTIONS"}
-	for name, method := range knownMethods {
-		imaginaryRequest := &RequestLine{Method: name, Target: target}
-		request := method.MakeRequest(imaginaryRequest, resource)
-		if request != nil {
-			supported = append(supported, name)
-		}
-	}
-
-	sort.Strings(supported)
-	return supported
-}
-
-var knownMethods = map[string]Method{
-	"GET":  &getMethod{},
-	"HEAD": &headMethod{},
-	"POST": &postMethod{},
-	"PUT":  &putMethod{},
-}
-
-type Method interface {
-	MakeRequest(requested *RequestLine, resource Resource) Request
-}
-
-// Handles requests of supported HTTP methods for a resource
-type Resource interface {
-	Name() string
-}
diff --git a/http/methods.go b/http/methods.go
index 27013df..2457599 100644
--- a/http/methods.go
+++ b/http/methods.go
@@ -5,46 +5,53 @@ import (
 	"strings"
 
 	"github.com/kkrull/gohttp/msg"
+	"github.com/kkrull/gohttp/msg/success"
 )
 
 /* GET */
 
 type getMethod struct{}
 
-func (method *getMethod) MakeRequest(requested *RequestLine, resource Resource) Request {
+func (method *getMethod) MakeRequest(requested *requestMessage, resource Resource) (request Request, isSupported bool) {
 	supportedResource, ok := resource.(GetResource)
 	if ok {
-		return &getRequest{Resource: supportedResource, Target: requested.Target}
+		return &getRequest{
+			Message:  requested,
+			Resource: supportedResource,
+		}, true
 	}
 
-	return nil
+	return nil, false
 }
 
 type getRequest struct {
+	Message  RequestMessage
 	Resource GetResource
-	Target   string
 }
 
 func (request *getRequest) Handle(client io.Writer) error {
-	request.Resource.Get(client, request.Target)
+	request.Resource.Get(client, request.Message)
 	return nil
 }
 
 type GetResource interface {
-	Get(client io.Writer, target string)
+	Get(client io.Writer, req RequestMessage)
 }
 
 /* HEAD */
 
 type headMethod struct{}
 
-func (*headMethod) MakeRequest(requested *RequestLine, resource Resource) Request {
+func (*headMethod) MakeRequest(requested *requestMessage, resource Resource) (request Request, isSupported bool) {
 	supportedResource, ok := resource.(HeadResource)
 	if ok {
-		return &headRequest{Resource: supportedResource, Target: requested.Target}
+		return &headRequest{
+			Resource: supportedResource,
+			Target:   requested.target,
+		}, true
 	}
 
-	return nil
+	return nil, false
 }
 
 type headRequest struct {
@@ -68,7 +75,7 @@ type optionsRequest struct {
 }
 
 func (request *optionsRequest) Handle(client io.Writer) error {
-	msg.WriteStatusLine(client, 200, "OK")
+	msg.WriteStatus(client, success.OKStatus)
 	msg.WriteContentLengthHeader(client, 0)
 	msg.WriteHeader(client, "Allow", strings.Join(request.SupportedMethods, ","))
 	msg.WriteEndOfMessageHeader(client)
@@ -79,13 +86,16 @@ func (request *optionsRequest) Handle(client io.Writer) error {
 
 type postMethod struct{}
 
-func (*postMethod) MakeRequest(requested *RequestLine, resource Resource) Request {
+func (*postMethod) MakeRequest(requested *requestMessage, resource Resource) (request Request, isSupported bool) {
 	supportedResource, ok := resource.(PostResource)
 	if ok {
-		return &postRequest{Resource: supportedResource, Target: requested.Target}
+		return &postRequest{
+			Resource: supportedResource,
+			Target:   requested.target,
+		}, true
 	}
 
-	return nil
+	return nil, false
 }
 
 type postRequest struct {
@@ -106,13 +116,16 @@ type PostResource interface {
 
 type putMethod struct{}
 
-func (*putMethod) MakeRequest(requested *RequestLine, resource Resource) Request {
+func (*putMethod) MakeRequest(requested *requestMessage, resource Resource) (request Request, isSupported bool) {
 	supportedResource, ok := resource.(PutResource)
 	if ok {
-		return &putRequest{Resource: supportedResource, Target: requested.Target}
+		return &putRequest{
+			Resource: supportedResource,
+			Target:   requested.target,
+		}, true
 	}
 
-	return nil
+	return nil, false
 }
 
 type putRequest struct {
diff --git a/http/parser.go b/http/parser.go
index e621b02..23341e2 100644
--- a/http/parser.go
+++ b/http/parser.go
@@ -10,63 +10,74 @@ import (
 // Parses an HTTP request message one line at a time.
 type LineRequestParser struct{}
 
-func (parser *LineRequestParser) Parse(reader *bufio.Reader) (ok *RequestLine, err Response) {
+func (parser *LineRequestParser) Parse(reader *bufio.Reader) (ok *requestMessage, err Response) {
 	methodObject := &parseMethodObject{reader: reader}
-	return methodObject.Parse()
+	return methodObject.ReadingRequestLine()
 }
 
+//A state machine that parses an HTTP request during the process of reading the request from input
 type parseMethodObject struct {
 	reader *bufio.Reader
 }
 
-func (parser *parseMethodObject) Parse() (ok *RequestLine, err Response) {
+func (parser *parseMethodObject) ReadingRequestLine() (ok *requestMessage, badRequest Response) {
 	requestLine, err := parser.readCRLFLine()
 	if err != nil {
 		return nil, err
 	}
 
-	return parser.doParseRequestLine(requestLine)
+	return parser.parsingRequestLine(requestLine)
 }
 
-func (parser *parseMethodObject) doParseRequestLine(requestLine string) (ok *RequestLine, err Response) {
-	requested, err := parser.parseRequestLine(requestLine)
-	if err != nil {
-		return nil, err
+func (parser *parseMethodObject) parsingRequestLine(requestLine string) (ok *requestMessage, badRequest Response) {
+	const numFieldsInRequestLine = 3
+	fields := strings.Split(requestLine, " ")
+	if len(fields) != numFieldsInRequestLine {
+		return nil, &clienterror.BadRequest{DisplayText: "incorrectly formatted or missing request-line"}
 	}
 
-	return parser.doParseHeaders(requested)
+	return parser.parsingTarget(fields[0], fields[1])
 }
 
-func (parser *parseMethodObject) doParseHeaders(requested *RequestLine) (ok *RequestLine, err Response) {
-	err = parser.parseHeaders()
-	if err != nil {
-		return nil, err
+func (parser *parseMethodObject) parsingTarget(method, target string) (ok *requestMessage, badRequest Response) {
+	path, query, _ := splitTarget(target)
+	requested := &requestMessage{
+		method: method,
+		target: target,
+		path:   path,
 	}
 
-	return requested, nil
+	return parser.parsingQueryString(requested, query)
 }
 
-func (parser *parseMethodObject) parseRequestLine(text string) (ok *RequestLine, badRequest Response) {
-	fields := strings.Split(text, " ")
-	if len(fields) != 3 {
-		return nil, &clienterror.BadRequest{DisplayText: "incorrectly formatted or missing request-line"}
+func (parser *parseMethodObject) parsingQueryString(requested *requestMessage, rawQuery string) (ok *requestMessage, badRequest Response) {
+	if len(rawQuery) == 0 {
+		return parser.readingHeaders(requested)
+	}
+
+	stringParameters := strings.Split(rawQuery, "&")
+	for _, stringParameter := range stringParameters {
+		nameValueFields := strings.Split(stringParameter, "=")
+		if len(nameValueFields) == 1 {
+			requested.AddQueryFlag(nameValueFields[0])
+		} else {
+			decodedValue, _ := PercentDecode(nameValueFields[1])
+			requested.AddQueryParameter(nameValueFields[0], decodedValue)
+		}
 	}
 
-	return &RequestLine{
-		Method: fields[0],
-		Target: fields[1],
-	}, nil
+	return parser.readingHeaders(requested)
 }
 
-func (parser *parseMethodObject) parseHeaders() (badRequest Response) {
+func (parser *parseMethodObject) readingHeaders(requested *requestMessage) (ok *requestMessage, badRequest Response) {
 	isBlankLineBetweenHeadersAndBody := func(line string) bool { return line == "" }
 
 	for {
 		line, err := parser.readCRLFLine()
 		if err != nil {
-			return err
+			return nil, err
 		} else if isBlankLineBetweenHeadersAndBody(line) {
-			return nil
+			return requested, nil
 		}
 	}
 }
@@ -87,3 +98,25 @@ func (parser *parseMethodObject) readCRLFLine() (line string, badRequest Respons
 	trimmed := strings.TrimSuffix(maybeEndsInCR, "\r")
 	return trimmed, nil
 }
+
+func splitTarget(target string) (path, query, fragment string) {
+	splitOnQuery := strings.Split(target, "?")
+	if len(splitOnQuery) == 1 {
+		query = ""
+		path, fragment = extractFragment(splitOnQuery[0])
+		return
+	}
+
+	path = splitOnQuery[0]
+	query, fragment = extractFragment(splitOnQuery[1])
+	return
+}
+
+func extractFragment(target string) (prefix string, fragment string) {
+	fields := strings.Split(target, "#")
+	if len(fields) == 1 {
+		return fields[0], ""
+	} else {
+		return fields[0], fields[1]
+	}
+}
diff --git a/http/parser_test.go b/http/parser_test.go
index 0be030f..8771956 100644
--- a/http/parser_test.go
+++ b/http/parser_test.go
@@ -13,7 +13,7 @@ var _ = Describe("LineRequestParser", func() {
 	Describe("#Parse", func() {
 		var (
 			parser  http.RequestParser
-			request *http.RequestLine
+			request http.RequestMessage
 			err     http.Response
 		)
 
@@ -24,7 +24,7 @@ var _ = Describe("LineRequestParser", func() {
 		Describe("it returns 400 Bad Request", func() {
 			It("for a completely blank request", func() {
 				request, err = parser.Parse(makeReader(""))
-				Expect(err).To(beABadRequestResponse("line in request header not ending in CRLF"))
+				Expect(err).To(beABadRequestResponse("end of input before terminating CRLF"))
 			})
 
 			It("for any line missing CR", func() {
@@ -44,7 +44,7 @@ var _ = Describe("LineRequestParser", func() {
 
 			It("for a request missing an ending CRLF", func() {
 				request, err = parser.Parse(makeReader("GET / HTTP/1.1\r\n"))
-				Expect(err).To(beABadRequestResponse("line in request header not ending in CRLF"))
+				Expect(err).To(beABadRequestResponse("end of input before terminating CRLF"))
 			})
 
 			It("when multiple spaces are separating fields in request-line", func() {
@@ -64,9 +64,7 @@ var _ = Describe("LineRequestParser", func() {
 		})
 
 		Context("given a well-formed request", func() {
-			var (
-				reader *bufio.Reader
-			)
+			var reader *bufio.Reader
 
 			BeforeEach(func() {
 				buffer := bytes.NewBufferString("GET /foo HTTP/1.1\r\nAccept: */*\r\n\r\n")
@@ -74,6 +72,11 @@ var _ = Describe("LineRequestParser", func() {
 				request, err = parser.Parse(reader)
 			})
 
+			It("parses the request-line", func() {
+				Expect(request.Method()).To(Equal(http.GET))
+				Expect(request.Target()).To(Equal("/foo"))
+			})
+
 			It("returns no error", func() {
 				Expect(err).To(BeNil())
 			})
@@ -83,14 +86,91 @@ var _ = Describe("LineRequestParser", func() {
 			})
 		})
 
-		Context("given a well-formed request with query parameters", func() {
+		Context("given a target with no query or fragment", func() {
 			BeforeEach(func() {
-				request, err = parser.Parse(makeReader("GET /foo?one=1 HTTP/1.1\r\n\r\n"))
-				Expect(err).NotTo(HaveOccurred())
+				request, _ = parser.Parse(requestWithTarget("/widget"))
+			})
+
+			It("the path is the full target", func() {
+				Expect(request.Path()).To(Equal("/widget"))
+			})
+			It("there are no query parameters", func() {
+				Expect(request.QueryParameters()).To(BeEmpty())
+			})
+		})
+
+		Context("given a target with a query", func() {
+			It("the path is the part before the ?", func() {
+				request, _ = parser.Parse(requestWithTarget("/widget?field=value"))
+				Expect(request.Path()).To(Equal("/widget"))
+			})
+
+			It("parses the part after the ? into query parameters", func() {
+				request, _ = parser.Parse(requestWithTarget("/widget?field=value"))
+				Expect(request.QueryParameters()).To(
+					ContainElement(http.QueryParameter{Name: "field", Value: "value"}))
+			})
+
+			It("parses parameters without a value into QueryParameter#Name", func() {
+				request, _ = parser.Parse(requestWithTarget("/widget?flag"))
+				Expect(request.QueryParameters()).To(
+					ContainElement(http.QueryParameter{Name: "flag", Value: ""}))
 			})
 
-			XIt("removes the query string from the target")
-			XIt("passes decoded parameters to the routes")
+			It("uses '=' to split a parameter's name and value", func() {
+				request, _ = parser.Parse(requestWithTarget("/widget?field=value"))
+				Expect(request.QueryParameters()).To(
+					ContainElement(http.QueryParameter{Name: "field", Value: "value"}))
+			})
+
+			It("uses '&' to split among multiple parameters", func() {
+				request, _ = parser.Parse(requestWithTarget("/widget?one=1&two=2"))
+				Expect(request.QueryParameters()).To(Equal([]http.QueryParameter{
+					{Name: "one", Value: "1"},
+					{Name: "two", Value: "2"},
+				}))
+			})
+		})
+
+		Context("given a target with a fragment", func() {
+			BeforeEach(func() {
+				request, _ = parser.Parse(requestWithTarget("/widget#section"))
+			})
+
+			It("the path is the part before the '#'", func() {
+				Expect(request.Path()).To(Equal("/widget"))
+			})
+			It("there are no query parameters", func() {
+				Expect(request.QueryParameters()).To(BeEmpty())
+			})
+		})
+
+		Context("given a target with a query and a fragment", func() {
+			BeforeEach(func() {
+				request, _ = parser.Parse(requestWithTarget("/widget?field=value#section"))
+			})
+
+			It("the path is the part before the ?", func() {
+				Expect(request.Path()).To(Equal("/widget"))
+			})
+			It("query parameters are parsed from the part between the ? and the #", func() {
+				Expect(request.QueryParameters()).To(Equal([]http.QueryParameter{
+					{Name: "field", Value: "value"},
+				}))
+			})
+		})
+
+		Context("given a target with percent-encoded query parameters", func() {
+			It("decodes percent-encoded values", func() {
+				request, _ = parser.Parse(requestWithTarget("/widget?less=%3C"))
+				Expect(request.QueryParameters()).To(Equal([]http.QueryParameter{
+					{Name: "less", Value: "<"},
+				}))
+			})
 		})
 	})
 })
+
+func requestWithTarget(target string) *bufio.Reader {
+	return makeReader("GET %s HTTP/1.1\r\n\r\n", target)
+}
diff --git a/http/percent.go b/http/percent.go
new file mode 100644
index 0000000..77d2ec4
--- /dev/null
+++ b/http/percent.go
@@ -0,0 +1,46 @@
+package http
+
+import (
+	"bytes"
+	"fmt"
+	"strconv"
+	"strings"
+)
+
+func PercentDecode(field string) (decoded string, malformed error) {
+	outputBuffer := &bytes.Buffer{}
+	splits := strings.Split(field, "%")
+	unencodedPrefix, hexCodePrefixedSubstrings := splits[0], splits[1:]
+
+	outputBuffer.WriteString(unencodedPrefix)
+	for _, hexCodePlusUnencoded := range hexCodePrefixedSubstrings {
+		if len(hexCodePlusUnencoded) < 2 {
+			return "", UnfinishedPercentEncoding{EnclosingField: field}
+		}
+
+		hexCodeCharacters, unencodedRemainder := splitAfterHexCode(hexCodePlusUnencoded)
+		outputBuffer.WriteByte(decode(hexCodeCharacters))
+		outputBuffer.WriteString(unencodedRemainder)
+	}
+
+	return outputBuffer.String(), nil
+}
+
+func splitAfterHexCode(hexCodePlusUnencoded string) (hexCode string, unencoded string) {
+	return hexCodePlusUnencoded[:2], hexCodePlusUnencoded[2:]
+}
+
+func decode(octetCharacters string) byte {
+	const base16 = 16
+	const uintSizeInBits = 8
+	asciiCode, _ := strconv.ParseInt(octetCharacters, base16, uintSizeInBits)
+	return byte(asciiCode)
+}
+
+type UnfinishedPercentEncoding struct {
+	EnclosingField string
+}
+
+func (invalid UnfinishedPercentEncoding) Error() string {
+	return fmt.Sprintf("%% followed by fewer than 2 characters: %s", invalid.EnclosingField)
+}
diff --git a/http/percent_test.go b/http/percent_test.go
new file mode 100644
index 0000000..90dc081
--- /dev/null
+++ b/http/percent_test.go
@@ -0,0 +1,42 @@
+package http_test
+
+import (
+	"github.com/kkrull/gohttp/http"
+	. "github.com/onsi/ginkgo"
+	. "github.com/onsi/gomega"
+)
+
+var _ = Describe("PercentDecode", func() {
+	It("returns a string unchanged that has no percent triplets in it", func() {
+		Expect(http.PercentDecode("abcd")).To(Equal("abcd"))
+	})
+
+	It("decodes a % triplet into the ASCII character for its hexadecimal code", func() {
+		Expect(http.PercentDecode("%3C")).To(Equal("<"))
+	})
+
+	It("retains characters after a percent triplet", func() {
+		Expect(http.PercentDecode("%3Cabc")).To(Equal("<abc"))
+	})
+
+	It("decodes multiple percent triplets", func() {
+		Expect(http.PercentDecode("%3Ca%3Cb")).To(Equal("<a<b"))
+	})
+
+	It("returns an error when % is followed by no characters", func() {
+		_, err := http.PercentDecode("abc%")
+		Expect(err).To(BeEquivalentTo(http.UnfinishedPercentEncoding{EnclosingField: "abc%"}))
+	})
+
+	It("returns an error when % is followed by 1 character", func() {
+		_, err := http.PercentDecode("abc%1")
+		Expect(err).To(BeEquivalentTo(http.UnfinishedPercentEncoding{EnclosingField: "abc%1"}))
+	})
+})
+
+var _ = Describe("UnfinishedPercentEncoding", func() {
+	It("describes the error and the offending text", func() {
+		err := &http.UnfinishedPercentEncoding{EnclosingField: "abc%"}
+		Expect(err).To(MatchError("% followed by fewer than 2 characters: abc%"))
+	})
+})
diff --git a/http/router.go b/http/router.go
index fec186e..721de86 100644
--- a/http/router.go
+++ b/http/router.go
@@ -2,8 +2,6 @@ package http
 
 import (
 	"bufio"
-
-	"github.com/kkrull/gohttp/msg/servererror"
 )
 
 func NewRouter() *RequestLineRouter {
@@ -37,7 +35,7 @@ func (router RequestLineRouter) RouteRequest(reader *bufio.Reader) (ok Request,
 	return router.routeRequest(requested)
 }
 
-func (router RequestLineRouter) routeRequest(requested *RequestLine) (ok Request, notImplemented Response) {
+func (router RequestLineRouter) routeRequest(requested *requestMessage) (ok Request, notImplemented Response) {
 	for _, route := range router.routes {
 		request := route.Route(requested)
 		if request != nil {
@@ -49,19 +47,22 @@ func (router RequestLineRouter) routeRequest(requested *RequestLine) (ok Request
 }
 
 type RequestParser interface {
-	Parse(reader *bufio.Reader) (ok *RequestLine, err Response)
+	Parse(reader *bufio.Reader) (ok *requestMessage, err Response)
 }
 
-type Route interface {
-	Route(requested *RequestLine) Request
+type RequestMessage interface {
+	Method() string
+	Target() string
+	Path() string
+	QueryParameters() []QueryParameter
+
+	MakeResourceRequest(resource Resource) Request
 }
 
-type RequestLine struct {
-	Method          string
-	Target          string
-	QueryParameters map[string]string
+type Route interface {
+	Route(requested RequestMessage) Request
 }
 
-func (requestLine *RequestLine) NotImplemented() Response {
-	return &servererror.NotImplemented{Method: requestLine.Method}
+type QueryParameter struct {
+	Name, Value string
 }
diff --git a/http/router_test.go b/http/router_test.go
index f744c9b..c193f93 100644
--- a/http/router_test.go
+++ b/http/router_test.go
@@ -49,9 +49,9 @@ var _ = Describe("RequestLineRouter", func() {
 				request, err = router.RouteRequest(makeReader("HEAD /foo HTTP/1.1\r\nAccept: */*\r\n\r\n"))
 			})
 
-			It("tries routing the method and target from the request until it finds a match", func() {
-				unrelatedRoute.ShouldHaveReceived("HEAD", "/foo")
-				matchingRoute.ShouldHaveReceived("HEAD", "/foo")
+			It("tries routing the method and path from the request until it finds a match", func() {
+				unrelatedRoute.ShouldHaveReceived(http.HEAD, "/foo")
+				matchingRoute.ShouldHaveReceived(http.HEAD, "/foo")
 			})
 
 			It("returns the request from the first matching Route", func() {
@@ -62,8 +62,8 @@ var _ = Describe("RequestLineRouter", func() {
 	})
 })
 
-func makeReader(template string, values ...string) *bufio.Reader {
-	text := fmt.Sprintf(template, values)
+func makeReader(template string, values ...interface{}) *bufio.Reader {
+	text := fmt.Sprintf(template, values...)
 	return bufio.NewReader(bytes.NewBufferString(text))
 }
 
diff --git a/httptest/request_message.go b/httptest/request_message.go
new file mode 100644
index 0000000..328bbfc
--- /dev/null
+++ b/httptest/request_message.go
@@ -0,0 +1,47 @@
+package httptest
+
+import (
+	"github.com/kkrull/gohttp/http"
+
+	. "github.com/onsi/gomega"
+)
+
+type RequestMessage struct {
+	MethodReturns string
+	PathReturns   string
+	TargetReturns string
+
+	MakeResourceRequestReturns  http.Request
+	makeResourceRequestReceived http.Resource
+
+	queryParameters []http.QueryParameter
+}
+
+func (message *RequestMessage) Method() string {
+	return message.MethodReturns
+}
+
+func (message *RequestMessage) Path() string {
+	return message.PathReturns
+}
+
+func (message *RequestMessage) Target() string {
+	return message.TargetReturns
+}
+
+func (message *RequestMessage) AddQueryParameter(name string, value string) {
+	message.queryParameters = append(message.queryParameters, http.QueryParameter{Name: name, Value: value})
+}
+
+func (message *RequestMessage) QueryParameters() []http.QueryParameter {
+	return message.queryParameters
+}
+
+func (message *RequestMessage) MakeResourceRequest(resource http.Resource) http.Request {
+	message.makeResourceRequestReceived = resource
+	return message.MakeResourceRequestReturns
+}
+
+func (message *RequestMessage) MakeResourceRequestShouldHaveReceived(resource http.Resource) {
+	ExpectWithOffset(1, message.makeResourceRequestReceived).To(BeIdenticalTo(resource))
+}
diff --git a/main/cmd/factory.go b/main/cmd/factory.go
index b192bfb..c7b529f 100644
--- a/main/cmd/factory.go
+++ b/main/cmd/factory.go
@@ -47,9 +47,10 @@ func (factory *InterruptFactory) TCPServer(contentRootPath string, host string,
 func (factory *InterruptFactory) routerWithAllRoutes(contentRootPath string) http.Router {
 	router := http.NewRouter()
 	router.AddRoute(capability.NewRoute())
-	//router.AddRoute(playground.NewParameterRoute())
+	router.AddRoute(playground.NewParameterRoute())
 	router.AddRoute(playground.NewReadOnlyRoute())
 	router.AddRoute(playground.NewReadWriteRoute())
+	router.AddRoute(playground.NewRedirectRoute())
 	router.AddRoute(teapot.NewRoute())
 	router.AddRoute(fs.NewRoute(contentRootPath))
 	return router
diff --git a/main/cmd/factory_test.go b/main/cmd/factory_test.go
index 11b1d6c..5961b96 100644
--- a/main/cmd/factory_test.go
+++ b/main/cmd/factory_test.go
@@ -91,7 +91,7 @@ var _ = Describe("InterruptFactory", func() {
 			Expect(typedServer.Routes()).To(ContainElement(BeAssignableToTypeOf(capability.NewRoute())))
 		})
 
-		XIt("has a playground route for parameter decoding", func() {
+		It("has a playground route for parameter decoding", func() {
 			Expect(typedServer.Routes()).To(ContainElement(BeAssignableToTypeOf(playground.NewParameterRoute())))
 		})
 
@@ -103,6 +103,10 @@ var _ = Describe("InterruptFactory", func() {
 			Expect(typedServer.Routes()).To(ContainElement(BeAssignableToTypeOf(playground.NewReadWriteRoute())))
 		})
 
+		It("has a playground route for redirects", func() {
+			Expect(typedServer.Routes()).To(ContainElement(BeAssignableToTypeOf(playground.NewRedirectRoute())))
+		})
+
 		It("has a teapot route", func() {
 			Expect(typedServer.Routes()).To(ContainElement(BeAssignableToTypeOf(teapot.NewRoute())))
 		})
diff --git a/mock/http_mocks.go b/mock/http_mocks.go
index e27cbb1..55c9eb7 100644
--- a/mock/http_mocks.go
+++ b/mock/http_mocks.go
@@ -78,23 +78,21 @@ func (mock *Request) VerifyHandle(writer *bufio.Writer) {
 
 type Route struct {
 	RouteReturns   http.Request
-	routeRequested *http.RequestLine
+	routeRequested http.RequestMessage
 }
 
-func (mock *Route) Route(requested *http.RequestLine) http.Request {
+func (mock *Route) Route(requested http.RequestMessage) http.Request {
 	mock.routeRequested = requested
 	return mock.RouteReturns
 }
 
 func (mock *Route) ShouldHaveReceived(method string, target string) {
-	ExpectWithOffset(1, mock.routeRequested).To(BeEquivalentTo(&http.RequestLine{
-		Method: method,
-		Target: target,
-	}))
+	ExpectWithOffset(1, mock.routeRequested.Method()).To(Equal(method))
+	ExpectWithOffset(1, mock.routeRequested.Target()).To(Equal(target))
 }
 
 func (mock *Route) ShouldHaveReceivedParameters(parameters map[string]string) {
-	ExpectWithOffset(1, mock.routeRequested.QueryParameters).To(Equal(parameters))
+	ExpectWithOffset(1, mock.routeRequested.QueryParameters()).To(Equal(parameters))
 }
 
 type Response struct {
diff --git a/msg/clienterror/client_errors.go b/msg/clienterror/client_errors.go
index cea0a5f..618b559 100644
--- a/msg/clienterror/client_errors.go
+++ b/msg/clienterror/client_errors.go
@@ -1,4 +1,3 @@
-// HTTP 4xx Client Error responses from RFC 7231, Section 6.5
 package clienterror
 
 import (
@@ -17,14 +16,14 @@ func (badRequest *BadRequest) WriteTo(client io.Writer) error {
 }
 
 func (badRequest *BadRequest) WriteHeader(client io.Writer) error {
-	msg.WriteStatusLine(client, 400, "Bad Request")
+	msg.WriteStatus(client, BadRequestStatus)
 	//msg.WriteEndOfMessageHeader(client)
 	return nil
 }
 
 type NotFound struct {
-	Target string
-	body   string
+	Path string
+	body string
 }
 
 func (notFound *NotFound) WriteTo(client io.Writer) error {
@@ -34,10 +33,10 @@ func (notFound *NotFound) WriteTo(client io.Writer) error {
 }
 
 func (notFound *NotFound) WriteHeader(client io.Writer) error {
-	msg.WriteStatusLine(client, 404, "Not Found")
+	msg.WriteStatus(client, NotFoundStatus)
 	msg.WriteContentTypeHeader(client, "text/plain")
 
-	notFound.body = fmt.Sprintf("Not found: %s", notFound.Target)
+	notFound.body = fmt.Sprintf("Not found: %s", notFound.Path)
 	msg.WriteContentLengthHeader(client, len(notFound.body))
 	msg.WriteEndOfMessageHeader(client)
 	return nil
diff --git a/msg/clienterror/client_requests.go b/msg/clienterror/client_requests.go
index de74b69..fc055b4 100644
--- a/msg/clienterror/client_requests.go
+++ b/msg/clienterror/client_requests.go
@@ -16,7 +16,7 @@ type methodNotAllowed struct {
 }
 
 func (notAllowed *methodNotAllowed) Handle(client io.Writer) error {
-	msg.WriteStatusLine(client, 405, "Method Not Allowed")
+	msg.WriteStatus(client, MethodNotAllowedStatus)
 	msg.WriteContentLengthHeader(client, 0)
 	msg.WriteHeader(client, "Allow", strings.Join(notAllowed.SupportedMethods, ","))
 	msg.WriteEndOfMessageHeader(client)
diff --git a/msg/clienterror/client_requests_test.go b/msg/clienterror/client_requests_test.go
index 6cdb6c8..6905ddb 100644
--- a/msg/clienterror/client_requests_test.go
+++ b/msg/clienterror/client_requests_test.go
@@ -18,11 +18,11 @@ var _ = Describe("MethodNotAllowed", func() {
 	Describe("#Handle", func() {
 		BeforeEach(func() {
 			response.Reset()
-			request = clienterror.MethodNotAllowed("GET", "HEAD")
+			request = clienterror.MethodNotAllowed(http.GET, http.HEAD)
 			request.Handle(response)
 		})
 
 		It("responds 405 Method Not Allowed", httptest.ShouldHaveNoBody(response, 405, "Method Not Allowed"))
-		It("sets Allow to GET and HEAD", httptest.ShouldAllowMethods(response, "GET", "HEAD"))
+		It("sets Allow to GET and HEAD", httptest.ShouldAllowMethods(response, http.GET, http.HEAD))
 	})
 })
diff --git a/msg/clienterror/doc.go b/msg/clienterror/doc.go
new file mode 100644
index 0000000..410eda8
--- /dev/null
+++ b/msg/clienterror/doc.go
@@ -0,0 +1,2 @@
+// HTTP 4xx Client Error responses from RFC 7231, Section 6.5
+package clienterror
diff --git a/msg/clienterror/status.go b/msg/clienterror/status.go
new file mode 100644
index 0000000..f903783
--- /dev/null
+++ b/msg/clienterror/status.go
@@ -0,0 +1,9 @@
+package clienterror
+
+import "github.com/kkrull/gohttp/msg"
+
+var (
+	BadRequestStatus       = msg.Status{400, "Bad Request"}
+	NotFoundStatus         = msg.Status{404, "Not Found"}
+	MethodNotAllowedStatus = msg.Status{405, "Method Not Allowed"}
+)
diff --git a/msg/message.go b/msg/message.go
index b364712..2c67165 100644
--- a/msg/message.go
+++ b/msg/message.go
@@ -6,8 +6,13 @@ import (
 	"strconv"
 )
 
-func WriteStatusLine(client io.Writer, status int, reason string) {
-	fmt.Fprintf(client, "HTTP/1.1 %d %s\r\n", status, reason)
+func WriteStatus(client io.Writer, status Status) {
+	fmt.Fprintf(client, "HTTP/1.1 %d %s\r\n", status.Code, status.Reason)
+}
+
+type Status struct {
+	Code   uint
+	Reason string
 }
 
 func WriteContentLengthHeader(client io.Writer, numBytes int) {
diff --git a/msg/redirect/doc.go b/msg/redirect/doc.go
new file mode 100644
index 0000000..abe4ac8
--- /dev/null
+++ b/msg/redirect/doc.go
@@ -0,0 +1,3 @@
+// Redirection 3xx responses from https://tools.ietf.org/html/rfc7231#section-6.4
+
+package redirect
diff --git a/msg/redirect/status.go b/msg/redirect/status.go
new file mode 100644
index 0000000..e1dbd38
--- /dev/null
+++ b/msg/redirect/status.go
@@ -0,0 +1,7 @@
+package redirect
+
+import "github.com/kkrull/gohttp/msg"
+
+var (
+	FoundStatus = msg.Status{Code: 302, Reason: "Found"}
+)
diff --git a/msg/servererror/doc.go b/msg/servererror/doc.go
new file mode 100644
index 0000000..804c7fe
--- /dev/null
+++ b/msg/servererror/doc.go
@@ -0,0 +1,2 @@
+// HTTP 5xx Server Error responses from RFC 7231, Section 6.6
+package servererror
diff --git a/msg/servererror/server_errors.go b/msg/servererror/server_errors.go
index b1dc587..26ac6e1 100644
--- a/msg/servererror/server_errors.go
+++ b/msg/servererror/server_errors.go
@@ -1,4 +1,3 @@
-// HTTP 5xx Server Error responses from RFC 7231, Section 6.6
 package servererror
 
 import (
@@ -14,7 +13,7 @@ func (internalError *InternalServerError) WriteTo(client io.Writer) error {
 }
 
 func (internalError *InternalServerError) WriteHeader(client io.Writer) error {
-	msg.WriteStatusLine(client, 500, "Internal Server Error")
+	msg.WriteStatus(client, InternalServerErrorStatus)
 	//msg.WriteEndOfMessageHeader(client)
 	return nil
 }
@@ -28,7 +27,7 @@ func (notImplemented *NotImplemented) WriteTo(client io.Writer) error {
 }
 
 func (notImplemented *NotImplemented) WriteHeader(client io.Writer) error {
-	msg.WriteStatusLine(client, 501, "Not Implemented")
+	msg.WriteStatus(client, NotImplementedStatus)
 	//msg.WriteEndOfMessageHeader(client)
 	return nil
 }
diff --git a/msg/servererror/status.go b/msg/servererror/status.go
new file mode 100644
index 0000000..a4997e0
--- /dev/null
+++ b/msg/servererror/status.go
@@ -0,0 +1,8 @@
+package servererror
+
+import "github.com/kkrull/gohttp/msg"
+
+var (
+	InternalServerErrorStatus = msg.Status{500, "Internal Server Error"}
+	NotImplementedStatus      = msg.Status{501, "Not Implemented"}
+)
diff --git a/msg/success/doc.go b/msg/success/doc.go
new file mode 100644
index 0000000..00cd0f2
--- /dev/null
+++ b/msg/success/doc.go
@@ -0,0 +1,2 @@
+// HTTP 2xx Successful responses from RFC 7231, Section 6.3
+package success
diff --git a/msg/success/status.go b/msg/success/status.go
new file mode 100644
index 0000000..aae517b
--- /dev/null
+++ b/msg/success/status.go
@@ -0,0 +1,5 @@
+package success
+
+import "github.com/kkrull/gohttp/msg"
+
+var OKStatus = msg.Status{200, "OK"}
diff --git a/playground/parameter_route.go b/playground/parameter_route.go
index 6d29cd9..c7bf420 100644
--- a/playground/parameter_route.go
+++ b/playground/parameter_route.go
@@ -1,38 +1,59 @@
 package playground
 
 import (
+	"bytes"
+	"fmt"
 	"io"
 
 	"github.com/kkrull/gohttp/http"
+	"github.com/kkrull/gohttp/msg"
+	"github.com/kkrull/gohttp/msg/success"
 )
 
 func NewParameterRoute() *ParameterRoute {
-	return &ParameterRoute{Decoder: &TheDecoder{}}
+	return &ParameterRoute{Reporter: &AssignmentReporter{}}
 }
 
 type ParameterRoute struct {
-	Decoder ParameterDecoder
+	Reporter ParameterReporter
 }
 
-func (route *ParameterRoute) Route(requested *http.RequestLine) http.Request {
-	if requested.Target != "/parameters" {
+func (route *ParameterRoute) Route(requested http.RequestMessage) http.Request {
+	if requested.Path() != "/parameters" {
 		return nil
 	}
 
-	return http.MakeResourceRequest(requested, route.Decoder)
+	return requested.MakeResourceRequest(route.Reporter)
 }
 
-type ParameterDecoder interface {
+type ParameterReporter interface {
 	Name() string
-	Get(client io.Writer, target string)
+	Get(client io.Writer, req http.RequestMessage)
 }
 
-type TheDecoder struct{}
+// Lists query parameters as simple assignment statements
+type AssignmentReporter struct{}
 
-func (decoder *TheDecoder) Get(client io.Writer, target string) {
-	panic("implement me")
+func (reporter *AssignmentReporter) Name() string {
+	return "Parameter Report"
 }
 
-func (decoder *TheDecoder) Name() string {
-	panic("implement me")
+func (reporter *AssignmentReporter) Get(client io.Writer, req http.RequestMessage) {
+	msg.WriteStatus(client, success.OKStatus)
+	msg.WriteContentTypeHeader(client, "text/plain")
+
+	body := reporter.makeBody(req)
+	msg.WriteContentLengthHeader(client, body.Len())
+	msg.WriteEndOfMessageHeader(client)
+
+	msg.WriteBody(client, body.String())
+}
+
+func (reporter *AssignmentReporter) makeBody(requestMessage http.RequestMessage) *bytes.Buffer {
+	body := &bytes.Buffer{}
+	for _, parameter := range requestMessage.QueryParameters() {
+		fmt.Fprintf(body, "%s = %s\n", parameter.Name, parameter.Value)
+	}
+
+	return body
 }
diff --git a/playground/parameter_route_test.go b/playground/parameter_route_test.go
index 3284572..9d296f1 100644
--- a/playground/parameter_route_test.go
+++ b/playground/parameter_route_test.go
@@ -5,6 +5,7 @@ import (
 
 	"github.com/kkrull/gohttp/http"
 	"github.com/kkrull/gohttp/httptest"
+	"github.com/kkrull/gohttp/mock"
 	"github.com/kkrull/gohttp/msg/clienterror"
 	"github.com/kkrull/gohttp/playground"
 	. "github.com/onsi/ginkgo"
@@ -16,7 +17,7 @@ var _ = Describe("::NewParameterRoute", func() {
 		route := playground.NewParameterRoute()
 		Expect(route).NotTo(BeNil())
 		Expect(route).To(BeEquivalentTo(&playground.ParameterRoute{
-			Decoder: &playground.TheDecoder{},
+			Reporter: &playground.AssignmentReporter{},
 		}))
 	})
 })
@@ -25,37 +26,31 @@ var _ = Describe("ParameterRoute", func() {
 	Describe("#Route", func() {
 		var (
 			router   http.Route
-			decoder  *ParameterDecoderMock
+			reporter *ParameterReporterMock
 			response = &bytes.Buffer{}
 		)
 
 		BeforeEach(func() {
-			decoder = &ParameterDecoderMock{}
-			router = &playground.ParameterRoute{Decoder: decoder}
+			reporter = &ParameterReporterMock{}
+			router = &playground.ParameterRoute{Reporter: reporter}
 			response.Reset()
 		})
 
-		Context("when the target is /parameters", func() {
-			XIt("routes GET to ParameterDecoder#Get with the decoded query parameters", func() {
-				parameters := map[string]string{
-					"one": "1",
-					"two": "2",
-				}
-				requested := &http.RequestLine{
-					Method:          "GET",
-					Target:          "/parameters",
-					QueryParameters: parameters,
+		Context("when the path is /parameters", func() {
+			It("routes GET to ParameterReporter#Get with the decoded query parameters", func() {
+				request := &mock.Request{}
+				requested := &httptest.RequestMessage{
+					PathReturns:                "/parameters",
+					MakeResourceRequestReturns: request,
 				}
 
-				routedRequest := router.Route(requested)
-				Expect(routedRequest).NotTo(BeNil())
-				routedRequest.Handle(response)
-				decoder.GetShouldHaveReceived(parameters)
+				Expect(router.Route(requested)).To(BeIdenticalTo(request))
+				requested.MakeResourceRequestShouldHaveReceived(reporter)
 			})
 
 			Context("when the method is OPTIONS", func() {
 				BeforeEach(func() {
-					requested := &http.RequestLine{Method: "OPTIONS", Target: "/parameters"}
+					requested := http.NewOptionsMessage("/parameters")
 					routedRequest := router.Route(requested)
 					Expect(routedRequest).NotTo(BeNil())
 					routedRequest.Handle(response)
@@ -63,19 +58,97 @@ var _ = Describe("ParameterRoute", func() {
 
 				It("responds 200 OK with no body", httptest.ShouldHaveNoBody(response, 200, "OK"))
 				It("sets Allow to the methods implemented by this type",
-					httptest.ShouldAllowMethods(response, "GET", "OPTIONS"))
+					httptest.ShouldAllowMethods(response, http.GET, http.OPTIONS))
 			})
 
 			It("replies Method Not Allowed on any other method", func() {
-				requested := &http.RequestLine{Method: "TRACE", Target: "/parameters"}
+				requested := http.NewTraceMessage("/parameters")
 				routedRequest := router.Route(requested)
 				Expect(routedRequest).To(BeAssignableToTypeOf(clienterror.MethodNotAllowed()))
 			})
 		})
 
-		It("returns nil for any other target", func() {
-			requested := &http.RequestLine{Method: "GET", Target: "/"}
+		It("returns nil for any other path", func() {
+			requested := http.NewGetMessage("/")
 			Expect(router.Route(requested)).To(BeNil())
 		})
 	})
 })
+
+var _ = Describe("AssignmentReporter", func() {
+	Describe("#Get", func() {
+		var (
+			controller      *playground.AssignmentReporter
+			request         *httptest.RequestMessage
+			responseMessage *httptest.ResponseMessage
+
+			response = &bytes.Buffer{}
+		)
+
+		BeforeEach(func() {
+			response.Reset()
+		})
+
+		Context("given any number of query parameters", func() {
+			BeforeEach(func() {
+				controller = &playground.AssignmentReporter{}
+				request = &httptest.RequestMessage{
+					MethodReturns: http.GET,
+					PathReturns:   "/parameters",
+				}
+
+				controller.Get(response, request)
+				responseMessage = httptest.ParseResponse(response)
+			})
+
+			It("responds 200 OK", func() {
+				responseMessage.StatusShouldBe(200, "OK")
+				responseMessage.ShouldBeWellFormed()
+			})
+			It("sets Content-Type to text/plain", func() {
+				responseMessage.HeaderShould("Content-Type", Equal("text/plain"))
+			})
+		})
+
+		Context("given a request with no query parameters", func() {
+			BeforeEach(func() {
+				controller = &playground.AssignmentReporter{}
+				request = &httptest.RequestMessage{
+					MethodReturns: http.GET,
+					PathReturns:   "/parameters",
+				}
+
+				controller.Get(response, request)
+				responseMessage = httptest.ParseResponse(response)
+			})
+
+			It("sets Content-Length to 0", func() {
+				responseMessage.HeaderShould("Content-Length", Equal("0"))
+			})
+			It("writes no body", func() {
+				responseMessage.BodyShould(BeEmpty())
+			})
+		})
+
+		Context("given a request with 1 or more query parameters", func() {
+			BeforeEach(func() {
+				controller = &playground.AssignmentReporter{}
+				request = &httptest.RequestMessage{
+					MethodReturns: http.GET,
+					PathReturns:   "/parameters",
+				}
+				request.AddQueryParameter("foo", "bar")
+
+				controller.Get(response, request)
+				responseMessage = httptest.ParseResponse(response)
+			})
+
+			It("sets Content-Length", func() {
+				responseMessage.HeaderShould("Content-Length", Not(Equal("0")))
+			})
+			It("lists each parameter and its value in the body", func() {
+				responseMessage.BodyShould(ContainSubstring("foo = bar"))
+			})
+		})
+	})
+})
diff --git a/playground/playground_suite_test.go b/playground/playground_suite_test.go
index ec3df2a..7156846 100644
--- a/playground/playground_suite_test.go
+++ b/playground/playground_suite_test.go
@@ -15,27 +15,15 @@ func TestPlayground(t *testing.T) {
 	RunSpecs(t, "playground")
 }
 
-/* ParameterDecoderMock */
+/* ParameterReporterMock */
 
-type ParameterDecoderMock struct {
-	getParameters map[string]string
-}
-
-func (mock *ParameterDecoderMock) Name() string {
-	return "Parameter Decoder Mock"
-}
+type ParameterReporterMock struct{}
 
-func (mock *ParameterDecoderMock) Get(client io.Writer, target string) {
-	//TODO KDK: Work here to get the parameters and expand the interface
-	//mock.getParameters = map[string]string {
-	//	"two": "2",
-	//	"one": "1",
-	//}
+func (mock *ParameterReporterMock) Name() string {
+	return "Parameter Reporter Mock"
 }
 
-func (mock *ParameterDecoderMock) GetShouldHaveReceived(parameters map[string]string) {
-	ExpectWithOffset(1, mock.getParameters).To(Equal(parameters))
-}
+func (mock *ParameterReporterMock) Get(client io.Writer, req http.RequestMessage) {}
 
 /* ReadOnlyResourceMock */
 
@@ -48,7 +36,7 @@ func (mock *ReadOnlyResourceMock) Name() string {
 	return "Readonly Mock"
 }
 
-func (mock *ReadOnlyResourceMock) Get(client io.Writer, target string) {
+func (mock *ReadOnlyResourceMock) Get(client io.Writer, req http.RequestMessage) {
 	mock.getCalled = true
 }
 
@@ -77,7 +65,7 @@ func (mock *ReadWriteResourceMock) Name() string {
 	return "Read/Write Mock"
 }
 
-func (mock *ReadWriteResourceMock) Get(client io.Writer, target string) {
+func (mock *ReadWriteResourceMock) Get(client io.Writer, req http.RequestMessage) {
 	mock.getCalled = true
 }
 
@@ -111,8 +99,8 @@ func (mock *ReadWriteResourceMock) PutShouldHaveBeenCalled() {
 
 /* Helpers */
 
-func handleRequest(router http.Route, method, target string) {
-	requested := &http.RequestLine{Method: method, Target: target}
+func handleRequest(router http.Route, method, path string) {
+	requested := http.NewRequestMessage(method, path)
 	routedRequest := router.Route(requested)
 	ExpectWithOffset(1, routedRequest).NotTo(BeNil())
 
diff --git a/playground/readonly_route.go b/playground/readonly_route.go
index 524267a..2d47b32 100644
--- a/playground/readonly_route.go
+++ b/playground/readonly_route.go
@@ -14,17 +14,17 @@ type ReadOnlyRoute struct {
 	Resource ReadOnlyResource
 }
 
-func (route *ReadOnlyRoute) Route(requested *http.RequestLine) http.Request {
-	if requested.Target != "/method_options2" {
+func (route *ReadOnlyRoute) Route(requested http.RequestMessage) http.Request {
+	if requested.Path() != "/method_options2" {
 		return nil
 	}
 
-	return http.MakeResourceRequest(requested, route.Resource)
+	return requested.MakeResourceRequest(route.Resource)
 }
 
 type ReadOnlyResource interface {
 	Name() string
-	Get(client io.Writer, target string)
+	Get(client io.Writer, req http.RequestMessage)
 	Head(client io.Writer, target string)
 }
 
@@ -35,8 +35,8 @@ func (controller *ReadableNopResource) Name() string {
 	return "Readonly NOP"
 }
 
-func (controller *ReadableNopResource) Get(client io.Writer, target string) {
-	controller.Head(client, target)
+func (controller *ReadableNopResource) Get(client io.Writer, req http.RequestMessage) {
+	controller.Head(client, req.Path())
 }
 
 func (controller *ReadableNopResource) Head(client io.Writer, target string) {
diff --git a/playground/readonly_route_test.go b/playground/readonly_route_test.go
index 7799868..01d73e5 100644
--- a/playground/readonly_route_test.go
+++ b/playground/readonly_route_test.go
@@ -31,14 +31,14 @@ var _ = Describe("ReadOnlyRoute", func() {
 			router = &playground.ReadOnlyRoute{Resource: resource}
 		})
 
-		Context("when the target is /method_options2", func() {
+		Context("when the path is /method_options2", func() {
 			It("routes GET to Teapot#Get", func() {
-				handleRequest(router, "GET", "/method_options2")
+				handleRequest(router, http.GET, "/method_options2")
 				resource.GetShouldHaveBeenCalled()
 			})
 
 			It("routes HEAD to Teapot#Options", func() {
-				handleRequest(router, "HEAD", "/method_options2")
+				handleRequest(router, http.HEAD, "/method_options2")
 				resource.HeadShouldHaveBeenCalled()
 			})
 
@@ -46,7 +46,7 @@ var _ = Describe("ReadOnlyRoute", func() {
 				var response = &bytes.Buffer{}
 
 				BeforeEach(func() {
-					requested := &http.RequestLine{Method: "OPTIONS", Target: "/method_options2"}
+					requested := http.NewOptionsMessage("/method_options2")
 					routedRequest := router.Route(requested)
 					Expect(routedRequest).NotTo(BeNil())
 
@@ -56,18 +56,18 @@ var _ = Describe("ReadOnlyRoute", func() {
 
 				It("responds 200 OK with no body", httptest.ShouldHaveNoBody(response, 200, "OK"))
 				It("sets Allow to the methods implemented by this type",
-					httptest.ShouldAllowMethods(response, "GET", "HEAD", "OPTIONS"))
+					httptest.ShouldAllowMethods(response, http.GET, http.HEAD, http.OPTIONS))
 			})
 
 			It("returns MethodNotAllowed for any other method", func() {
-				requested := &http.RequestLine{Method: "PUT", Target: "/method_options2"}
+				requested := http.NewPutMessage("/method_options2")
 				routedRequest := router.Route(requested)
-				Expect(routedRequest).To(BeEquivalentTo(clienterror.MethodNotAllowed("GET", "HEAD", "OPTIONS")))
+				Expect(routedRequest).To(BeEquivalentTo(clienterror.MethodNotAllowed(http.GET, http.HEAD, http.OPTIONS)))
 			})
 		})
 
-		It("returns nil on any other target", func() {
-			requested := &http.RequestLine{Method: "GET", Target: "/"}
+		It("returns nil on any other path", func() {
+			requested := http.NewGetMessage("/")
 			routedRequest := router.Route(requested)
 			Expect(routedRequest).To(BeNil())
 		})
@@ -87,7 +87,7 @@ var _ = Describe("ReadableNopResource", func() {
 
 	Describe("#Get", func() {
 		BeforeEach(func() {
-			controller.Get(response, "/")
+			controller.Get(response, http.NewGetMessage("/"))
 		})
 
 		It("responds 200 OK with no body", httptest.ShouldHaveNoBody(response, 200, "OK"))
diff --git a/playground/redirect_route.go b/playground/redirect_route.go
new file mode 100644
index 0000000..4481119
--- /dev/null
+++ b/playground/redirect_route.go
@@ -0,0 +1,44 @@
+package playground
+
+import (
+	"io"
+
+	"github.com/kkrull/gohttp/http"
+	"github.com/kkrull/gohttp/msg"
+	"github.com/kkrull/gohttp/msg/redirect"
+)
+
+func NewRedirectRoute() http.Route {
+	return &RedirectRoute{
+		Resource: &GoBackHomeResource{},
+	}
+}
+
+type RedirectRoute struct {
+	Resource RelocatedResource
+}
+
+func (route *RedirectRoute) Route(requested http.RequestMessage) http.Request {
+	if requested.Path() != "/redirect" {
+		return nil
+	}
+
+	return requested.MakeResourceRequest(route.Resource)
+}
+
+type RelocatedResource interface {
+	Name() string
+}
+
+type GoBackHomeResource struct{}
+
+func (*GoBackHomeResource) Name() string {
+	return "Relocated Resource"
+}
+
+func (*GoBackHomeResource) Get(client io.Writer, req http.RequestMessage) {
+	msg.WriteStatus(client, redirect.FoundStatus)
+	msg.WriteContentLengthHeader(client, 0)
+	msg.WriteHeader(client, "Location", "/")
+	msg.WriteEndOfMessageHeader(client)
+}
diff --git a/playground/redirect_route_test.go b/playground/redirect_route_test.go
new file mode 100644
index 0000000..154fb69
--- /dev/null
+++ b/playground/redirect_route_test.go
@@ -0,0 +1,112 @@
+package playground_test
+
+import (
+	"bytes"
+
+	"github.com/kkrull/gohttp/http"
+	"github.com/kkrull/gohttp/httptest"
+	"github.com/kkrull/gohttp/mock"
+	"github.com/kkrull/gohttp/msg/clienterror"
+	"github.com/kkrull/gohttp/playground"
+	. "github.com/onsi/ginkgo"
+	. "github.com/onsi/gomega"
+)
+
+var _ = Describe("::NewRedirectRoute", func() {
+	It("returns a fully configured RedirectRoute", func() {
+		route := playground.NewRedirectRoute()
+		Expect(route).To(BeAssignableToTypeOf(&playground.RedirectRoute{}))
+		Expect(route).To(BeEquivalentTo(&playground.RedirectRoute{
+			Resource: &playground.GoBackHomeResource{},
+		}))
+	})
+})
+
+var _ = Describe("RedirectRoute", func() {
+	Describe("#Route", func() {
+		var (
+			router   http.Route
+			resource *playground.GoBackHomeResource
+			response = &bytes.Buffer{}
+		)
+
+		BeforeEach(func() {
+			resource = &playground.GoBackHomeResource{}
+			router = &playground.RedirectRoute{Resource: resource}
+			response.Reset()
+		})
+
+		Context("when the path is /redirect", func() {
+			It("routes GET to RelocatedResource#Get", func() {
+				requestMessage := &httptest.RequestMessage{
+					PathReturns:                "/redirect",
+					MakeResourceRequestReturns: &mock.Request{},
+				}
+
+				Expect(router.Route(requestMessage)).To(BeIdenticalTo(requestMessage.MakeResourceRequestReturns))
+			})
+
+			Context("when the method is OPTIONS", func() {
+				BeforeEach(func() {
+					requested := http.NewOptionsMessage("/redirect")
+					routedRequest := router.Route(requested)
+					Expect(routedRequest).NotTo(BeNil())
+					routedRequest.Handle(response)
+				})
+
+				It("responds 200 OK with no body", httptest.ShouldHaveNoBody(response, 200, "OK"))
+				It("sets Allow to the methods implemented by this type",
+					httptest.ShouldAllowMethods(response, http.GET, http.OPTIONS))
+			})
+
+			It("replies Method Not Allowed on any other method", func() {
+				requested := http.NewTraceMessage("/redirect")
+				routedRequest := router.Route(requested)
+				Expect(routedRequest).To(BeAssignableToTypeOf(clienterror.MethodNotAllowed()))
+			})
+		})
+
+		It("returns nil for any other path", func() {
+			requestMessage := http.NewGetMessage("/no-route-for-you")
+			Expect(router.Route(requestMessage)).To(BeNil())
+		})
+	})
+})
+
+var _ = Describe("GoBackHomeResource", func() {
+	Describe("#Get", func() {
+		var (
+			resource        *playground.GoBackHomeResource
+			request         *httptest.RequestMessage
+			responseMessage *httptest.ResponseMessage
+
+			response = &bytes.Buffer{}
+		)
+
+		BeforeEach(func() {
+			response.Reset()
+			resource = &playground.GoBackHomeResource{}
+			request = &httptest.RequestMessage{
+				MethodReturns: http.GET,
+				PathReturns:   "/redirect",
+			}
+
+			resource.Get(response, request)
+			responseMessage = httptest.ParseResponse(response)
+		})
+
+		It("responds 302 Found", func() {
+			responseMessage.StatusShouldBe(302, "Found")
+			responseMessage.ShouldBeWellFormed()
+		})
+		It("Sets Location to /", func() {
+			responseMessage.HeaderShould("Location", Equal("/"))
+		})
+		It("sets Content-Length to 0", func() {
+			responseMessage.HeaderShould("Content-Length", Equal("0"))
+		})
+		It("writes no body", func() {
+			responseMessage.BodyShould(BeEmpty())
+		})
+	})
+})
diff --git a/playground/writable_route.go b/playground/writable_route.go
index 4dbae84..98a7808 100644
--- a/playground/writable_route.go
+++ b/playground/writable_route.go
@@ -5,6 +5,7 @@ import (
 
 	"github.com/kkrull/gohttp/http"
 	"github.com/kkrull/gohttp/msg"
+	"github.com/kkrull/gohttp/msg/success"
 )
 
 func NewReadWriteRoute() *ReadWriteRoute {
@@ -17,17 +18,17 @@ type ReadWriteRoute struct {
 	Resource ReadWriteResource
 }
 
-func (route *ReadWriteRoute) Route(requested *http.RequestLine) http.Request {
-	if requested.Target != "/method_options" {
+func (route *ReadWriteRoute) Route(requested http.RequestMessage) http.Request {
+	if requested.Path() != "/method_options" {
 		return nil
 	}
 
-	return http.MakeResourceRequest(requested, route.Resource)
+	return requested.MakeResourceRequest(route.Resource)
 }
 
 type ReadWriteResource interface {
 	Name() string
-	Get(client io.Writer, target string)
+	Get(client io.Writer, req http.RequestMessage)
 	Head(client io.Writer, target string)
 	Post(client io.Writer, target string)
 	Put(client io.Writer, target string)
@@ -40,8 +41,8 @@ func (controller *ReadWriteNopResource) Name() string {
 	return "Read/Write NOP"
 }
 
-func (controller *ReadWriteNopResource) Get(client io.Writer, target string) {
-	controller.Head(client, target)
+func (controller *ReadWriteNopResource) Get(client io.Writer, req http.RequestMessage) {
+	controller.Head(client, req.Path())
 }
 
 func (controller *ReadWriteNopResource) Head(client io.Writer, target string) {
@@ -57,7 +58,7 @@ func (controller *ReadWriteNopResource) Put(client io.Writer, target string) {
 }
 
 func writeOKWithNoBody(client io.Writer) {
-	msg.WriteStatusLine(client, 200, "OK")
+	msg.WriteStatus(client, success.OKStatus)
 	msg.WriteContentLengthHeader(client, 0)
 	msg.WriteEndOfMessageHeader(client)
 }
diff --git a/playground/writable_route_test.go b/playground/writable_route_test.go
index 24c3a0c..4bff57b 100644
--- a/playground/writable_route_test.go
+++ b/playground/writable_route_test.go
@@ -31,14 +31,14 @@ var _ = Describe("ReadWriteRoute", func() {
 			router = &playground.ReadWriteRoute{Resource: resource}
 		})
 
-		Context("when the target is /method_options", func() {
+		Context("when the path is /method_options", func() {
 			It("routes GET to Teapot#Get", func() {
-				handleRequest(router, "GET", "/method_options")
+				handleRequest(router, http.GET, "/method_options")
 				resource.GetShouldHaveBeenCalled()
 			})
 
 			It("routes HEAD to Teapot#Head", func() {
-				handleRequest(router, "HEAD", "/method_options")
+				handleRequest(router, http.HEAD, "/method_options")
 				resource.HeadShouldHaveBeenCalled()
 			})
 
@@ -46,7 +46,7 @@ var _ = Describe("ReadWriteRoute", func() {
 				var response = &bytes.Buffer{}
 
 				BeforeEach(func() {
-					requested := &http.RequestLine{Method: "OPTIONS", Target: "/method_options"}
+					requested := http.NewOptionsMessage("/method_options")
 					routedRequest := router.Route(requested)
 					Expect(routedRequest).NotTo(BeNil())
 
@@ -56,28 +56,28 @@ var _ = Describe("ReadWriteRoute", func() {
 
 				It("responds 200 OK with no body", httptest.ShouldHaveNoBody(response, 200, "OK"))
 				It("sets Allow to the methods implemented by this type",
-					httptest.ShouldAllowMethods(response, "GET", "HEAD", "OPTIONS", "POST", "PUT"))
+					httptest.ShouldAllowMethods(response, http.GET, http.HEAD, http.OPTIONS, http.POST, http.PUT))
 			})
 
 			It("routes POST to Teapot#Post", func() {
-				handleRequest(router, "POST", "/method_options")
+				handleRequest(router, http.POST, "/method_options")
 				resource.PostShouldHaveBeenCalled()
 			})
 
 			It("routes PUT to Teapot#Put", func() {
-				handleRequest(router, "PUT", "/method_options")
+				handleRequest(router, http.PUT, "/method_options")
 				resource.PutShouldHaveBeenCalled()
 			})
 
 			It("returns MethodNotAllowed for any other method", func() {
-				requested := &http.RequestLine{Method: "TRACE", Target: "/method_options"}
+				requested := http.NewTraceMessage("/method_options")
 				routedRequest := router.Route(requested)
-				Expect(routedRequest).To(BeEquivalentTo(clienterror.MethodNotAllowed("GET", "HEAD", "OPTIONS", "POST", "PUT")))
+				Expect(routedRequest).To(BeEquivalentTo(clienterror.MethodNotAllowed(http.GET, http.HEAD, http.OPTIONS, http.POST, http.PUT)))
 			})
 		})
 
-		It("returns nil on any other target", func() {
-			requested := &http.RequestLine{Method: "GET", Target: "/"}
+		It("returns nil on any other path", func() {
+			requested := http.NewGetMessage("/")
 			routedRequest := router.Route(requested)
 			Expect(routedRequest).To(BeNil())
 		})
@@ -97,7 +97,7 @@ var _ = Describe("ReadWriteNopResource", func() {
 
 	Describe("#Get", func() {
 		BeforeEach(func() {
-			controller.Get(response, "/")
+			controller.Get(response, http.NewGetMessage("/"))
 		})
 
 		It("responds 200 OK with no body", httptest.ShouldHaveNoBody(response, 200, "OK"))
diff --git a/teapot/requests.go b/teapot/requests.go
index 4bd6614..1300941 100644
--- a/teapot/requests.go
+++ b/teapot/requests.go
@@ -3,7 +3,9 @@ package teapot
 import (
 	"io"
 
+	"github.com/kkrull/gohttp/http"
 	"github.com/kkrull/gohttp/msg"
+	"github.com/kkrull/gohttp/msg/success"
 )
 
 // Responds as a teapot that is aware of its own identity
@@ -13,8 +15,8 @@ func (teapot *IdentityTeapot) Name() string {
 	return "teapot"
 }
 
-func (teapot *IdentityTeapot) RespondsTo(target string) bool {
-	switch target {
+func (teapot *IdentityTeapot) RespondsTo(path string) bool {
+	switch path {
 	case "/coffee", "/tea":
 		return true
 	default:
@@ -22,13 +24,13 @@ func (teapot *IdentityTeapot) RespondsTo(target string) bool {
 	}
 }
 
-func (teapot *IdentityTeapot) Get(client io.Writer, target string) {
+func (teapot *IdentityTeapot) Get(client io.Writer, req http.RequestMessage) {
 	var beverageRequestHandlers = map[string]func(writer io.Writer){
 		"/coffee": teapot.getCoffee,
 		"/tea":    teapot.getTea,
 	}
 
-	handler := beverageRequestHandlers[target]
+	handler := beverageRequestHandlers[req.Path()]
 	handler(client)
 }
 
@@ -39,14 +41,15 @@ func (teapot *IdentityTeapot) getCoffee(client io.Writer) {
 }
 
 func writeHeaders(client io.Writer, body string) {
-	msg.WriteStatusLine(client, 418, "I'm a teapot")
+	teapotStatus := msg.Status{Code: 418, Reason: "I'm a teapot"}
+	msg.WriteStatus(client, teapotStatus)
 	msg.WriteContentTypeHeader(client, "text/plain")
 	msg.WriteContentLengthHeader(client, len(body))
 	msg.WriteEndOfMessageHeader(client)
 }
 
 func (teapot *IdentityTeapot) getTea(client io.Writer) {
-	msg.WriteStatusLine(client, 200, "OK")
+	msg.WriteStatus(client, success.OKStatus)
 	msg.WriteContentLengthHeader(client, 0)
 	msg.WriteEndOfMessageHeader(client)
 }
diff --git a/teapot/requests_test.go b/teapot/requests_test.go
index a023501..601fb48 100644
--- a/teapot/requests_test.go
+++ b/teapot/requests_test.go
@@ -3,6 +3,7 @@ package teapot_test
 import (
 	"bytes"
 
+	"github.com/kkrull/gohttp/http"
 	"github.com/kkrull/gohttp/httptest"
 	"github.com/kkrull/gohttp/teapot"
 	. "github.com/onsi/ginkgo"
@@ -29,12 +30,12 @@ var _ = Describe("IdentityTeapot", func() {
 	})
 
 	Describe("#Get", func() {
-		Context("when the target is /coffee", func() {
+		Context("when the path is /coffee", func() {
 			BeforeEach(func() {
 				responseBuffer = &bytes.Buffer{}
 				theTeapot = &teapot.IdentityTeapot{}
 
-				theTeapot.Get(responseBuffer, "/coffee")
+				theTeapot.Get(responseBuffer, http.NewGetMessage("/coffee"))
 				response = httptest.ParseResponse(responseBuffer)
 			})
 
@@ -55,12 +56,12 @@ var _ = Describe("IdentityTeapot", func() {
 			})
 		})
 
-		Context("when the target is /tea", func() {
+		Context("when the path is /tea", func() {
 			BeforeEach(func() {
 				responseBuffer = &bytes.Buffer{}
 				theTeapot = &teapot.IdentityTeapot{}
 
-				theTeapot.Get(responseBuffer, "/tea")
+				theTeapot.Get(responseBuffer, http.NewGetMessage("/tea"))
 				response = httptest.ParseResponse(responseBuffer)
 			})
 
diff --git a/teapot/route.go b/teapot/route.go
index 6f368e2..8d80d3b 100644
--- a/teapot/route.go
+++ b/teapot/route.go
@@ -15,16 +15,16 @@ type Route struct {
 	Teapot Teapot
 }
 
-func (route *Route) Route(requested *http.RequestLine) http.Request {
-	if !route.Teapot.RespondsTo(requested.Target) {
+func (route *Route) Route(requested http.RequestMessage) http.Request {
+	if !route.Teapot.RespondsTo(requested.Path()) {
 		return nil
 	}
 
-	return http.MakeResourceRequest(requested, route.Teapot)
+	return requested.MakeResourceRequest(route.Teapot)
 }
 
 type Teapot interface {
 	Name() string
-	Get(client io.Writer, target string)
-	RespondsTo(target string) bool
+	Get(client io.Writer, req http.RequestMessage)
+	RespondsTo(path string) bool
 }
diff --git a/teapot/route_test.go b/teapot/route_test.go
index 6e94933..46c4e41 100644
--- a/teapot/route_test.go
+++ b/teapot/route_test.go
@@ -14,36 +14,36 @@ var _ = Describe("teapotRoute", func() {
 	var (
 		router        http.Route
 		teapotMock    *TeapotMock
-		requested     *http.RequestLine
+		requested     http.RequestMessage
 		routedRequest http.Request
 	)
 
 	Describe("#Route", func() {
-		Context("when the target is a resource that the teapot can respond to", func() {
+		Context("when the path is a resource that the teapot can respond to", func() {
 			BeforeEach(func() {
-				teapotMock = &TeapotMock{RespondsToTarget: "/caffeine"}
+				teapotMock = &TeapotMock{RespondsToPath: "/caffeine"}
 				router = &teapot.Route{Teapot: teapotMock}
 			})
 
-			It("routes GET requests to that target to the teapot", func() {
-				requested = &http.RequestLine{Method: "GET", Target: "/caffeine"}
+			It("routes GET requests to that path to the teapot", func() {
+				requested = http.NewGetMessage("/caffeine")
 				routedRequest = router.Route(requested)
 				routedRequest.Handle(&bufio.Writer{})
 				teapotMock.GetShouldHaveReceived("/caffeine")
 			})
 
 			It("returns MethodNotAllowed for any other method", func() {
-				requested := &http.RequestLine{Method: "TRACE", Target: "/caffeine"}
+				requested := http.NewTraceMessage("/caffeine")
 				routedRequest := router.Route(requested)
-				Expect(routedRequest).To(BeEquivalentTo(clienterror.MethodNotAllowed("GET", "OPTIONS")))
+				Expect(routedRequest).To(BeEquivalentTo(clienterror.MethodNotAllowed(http.GET, http.OPTIONS)))
 			})
 		})
 
-		It("passes on any other target", func() {
+		It("passes on any other path", func() {
 			teapotMock = &TeapotMock{}
 			router = &teapot.Route{Teapot: teapotMock}
 
-			requested = &http.RequestLine{Method: "GET", Target: "/file.txt"}
+			requested = http.NewGetMessage("/file.txt")
 			routedRequest = router.Route(requested)
 			Expect(routedRequest).To(BeNil())
 		})
diff --git a/teapot/teapot_suite_test.go b/teapot/teapot_suite_test.go
index bdae47e..3fe06d8 100644
--- a/teapot/teapot_suite_test.go
+++ b/teapot/teapot_suite_test.go
@@ -4,6 +4,7 @@ import (
 	"io"
 	"testing"
 
+	"github.com/kkrull/gohttp/http"
 	. "github.com/onsi/ginkgo"
 	. "github.com/onsi/gomega"
 )
@@ -14,22 +15,22 @@ func TestTeapot(t *testing.T) {
 }
 
 type TeapotMock struct {
-	RespondsToTarget string
-	getTarget        string
+	RespondsToPath string
+	getPath        string
 }
 
 func (mock *TeapotMock) Name() string {
 	return "teapot mock"
 }
 
-func (mock *TeapotMock) RespondsTo(target string) bool {
-	return mock.RespondsToTarget == target
+func (mock *TeapotMock) RespondsTo(path string) bool {
+	return mock.RespondsToPath == path
 }
 
-func (mock *TeapotMock) Get(client io.Writer, target string) {
-	mock.getTarget = target
+func (mock *TeapotMock) Get(client io.Writer, req http.RequestMessage) {
+	mock.getPath = req.Path()
 }
 
-func (mock *TeapotMock) GetShouldHaveReceived(target string) {
-	ExpectWithOffset(1, mock.getTarget).To(Equal(target))
+func (mock *TeapotMock) GetShouldHaveReceived(path string) {
+	ExpectWithOffset(1, mock.getPath).To(Equal(path))
 }