Use Go 1.5 vendoring instead of Godeps

Change made by:

- running "gvt fetch" on each of the packages mentioned in
  Godeps/Godeps.json
- `rm -rf Godeps`
- tweaking the build scripts to not mention Godeps
- tweaking the build scripts to test `./lib/...`, `./cmd/...` explicitly
  (to avoid testing vendor)
- tweaking the build scripts to not juggle GOPATH for Godeps and instead
  set GO15VENDOREXPERIMENT.

This also results in some updated packages at the same time I bet.

Building with Go 1.3 and 1.4 still *works* but won't use our vendored
dependencies - the user needs to have the actual packages in their
GOPATH then, which they'll get with a normal "go get". Building with Go
1.6+ will get our vendored dependencies by default even when not using
our build script, which is nice.

By doing this we gain some freedom in that we can pick and choose
manually what to include in vendor, as it's not based on just dependency
analysis of our own code. This is also a risk as we might pick up
dependencies we are unaware of, as the build may work locally with those
packages present in GOPATH. On the other hand the build server will
detect this as it has no packages in it's GOPATH beyond what is included
in the repo.

Recommended tool to manage dependencies is github.com/FiloSottile/gvt.

vendor/github.com/onsi/gomega/ghttp/handlers.go

@@ -0,0 +1,313 @@
+package ghttp
+
+import (
+	"encoding/base64"
+	"encoding/json"
+	"fmt"
+	"io/ioutil"
+	"net/http"
+	"net/url"
+	"reflect"
+
+	"github.com/golang/protobuf/proto"
+	. "github.com/onsi/gomega"
+	"github.com/onsi/gomega/types"
+)
+
+//CombineHandler takes variadic list of handlers and produces one handler
+//that calls each handler in order.
+func CombineHandlers(handlers ...http.HandlerFunc) http.HandlerFunc {
+	return func(w http.ResponseWriter, req *http.Request) {
+		for _, handler := range handlers {
+			handler(w, req)
+		}
+	}
+}
+
+//VerifyRequest returns a handler that verifies that a request uses the specified method to connect to the specified path
+//You may also pass in an optional rawQuery string which is tested against the request's `req.URL.RawQuery`
+//
+//For path, you may pass in a string, in which case strict equality will be applied
+//Alternatively you can pass in a matcher (ContainSubstring("/foo") and MatchRegexp("/foo/[a-f0-9]+") for example)
+func VerifyRequest(method string, path interface{}, rawQuery ...string) http.HandlerFunc {
+	return func(w http.ResponseWriter, req *http.Request) {
+		Ω(req.Method).Should(Equal(method), "Method mismatch")
+		switch p := path.(type) {
+		case types.GomegaMatcher:
+			Ω(req.URL.Path).Should(p, "Path mismatch")
+		default:
+			Ω(req.URL.Path).Should(Equal(path), "Path mismatch")
+		}
+		if len(rawQuery) > 0 {
+			values, err := url.ParseQuery(rawQuery[0])
+			Ω(err).ShouldNot(HaveOccurred(), "Expected RawQuery is malformed")
+
+			Ω(req.URL.Query()).Should(Equal(values), "RawQuery mismatch")
+		}
+	}
+}
+
+//VerifyContentType returns a handler that verifies that a request has a Content-Type header set to the
+//specified value
+func VerifyContentType(contentType string) http.HandlerFunc {
+	return func(w http.ResponseWriter, req *http.Request) {
+		Ω(req.Header.Get("Content-Type")).Should(Equal(contentType))
+	}
+}
+
+//VerifyBasicAuth returns a handler that verifies the request contains a BasicAuth Authorization header
+//matching the passed in username and password
+func VerifyBasicAuth(username string, password string) http.HandlerFunc {
+	return func(w http.ResponseWriter, req *http.Request) {
+		auth := req.Header.Get("Authorization")
+		Ω(auth).ShouldNot(Equal(""), "Authorization header must be specified")
+
+		decoded, err := base64.StdEncoding.DecodeString(auth[6:])
+		Ω(err).ShouldNot(HaveOccurred())
+
+		Ω(string(decoded)).Should(Equal(fmt.Sprintf("%s:%s", username, password)), "Authorization mismatch")
+	}
+}
+
+//VerifyHeader returns a handler that verifies the request contains the passed in headers.
+//The passed in header keys are first canonicalized via http.CanonicalHeaderKey.
+//
+//The request must contain *all* the passed in headers, but it is allowed to have additional headers
+//beyond the passed in set.
+func VerifyHeader(header http.Header) http.HandlerFunc {
+	return func(w http.ResponseWriter, req *http.Request) {
+		for key, values := range header {
+			key = http.CanonicalHeaderKey(key)
+			Ω(req.Header[key]).Should(Equal(values), "Header mismatch for key: %s", key)
+		}
+	}
+}
+
+//VerifyHeaderKV returns a handler that verifies the request contains a header matching the passed in key and values
+//(recall that a `http.Header` is a mapping from string (key) to []string (values))
+//It is a convenience wrapper around `VerifyHeader` that allows you to avoid having to create an `http.Header` object.
+func VerifyHeaderKV(key string, values ...string) http.HandlerFunc {
+	return VerifyHeader(http.Header{key: values})
+}
+
+//VerifyBody returns a handler that verifies that the body of the request matches the passed in byte array.
+//It does this using Equal().
+func VerifyBody(expectedBody []byte) http.HandlerFunc {
+	return CombineHandlers(
+		func(w http.ResponseWriter, req *http.Request) {
+			body, err := ioutil.ReadAll(req.Body)
+			req.Body.Close()
+			Ω(err).ShouldNot(HaveOccurred())
+			Ω(body).Should(Equal(expectedBody), "Body Mismatch")
+		},
+	)
+}
+
+//VerifyJSON returns a handler that verifies that the body of the request is a valid JSON representation
+//matching the passed in JSON string.  It does this using Gomega's MatchJSON method
+//
+//VerifyJSON also verifies that the request's content type is application/json
+func VerifyJSON(expectedJSON string) http.HandlerFunc {
+	return CombineHandlers(
+		VerifyContentType("application/json"),
+		func(w http.ResponseWriter, req *http.Request) {
+			body, err := ioutil.ReadAll(req.Body)
+			req.Body.Close()
+			Ω(err).ShouldNot(HaveOccurred())
+			Ω(body).Should(MatchJSON(expectedJSON), "JSON Mismatch")
+		},
+	)
+}
+
+//VerifyJSONRepresenting is similar to VerifyJSON.  Instead of taking a JSON string, however, it
+//takes an arbitrary JSON-encodable object and verifies that the requests's body is a JSON representation
+//that matches the object
+func VerifyJSONRepresenting(object interface{}) http.HandlerFunc {
+	data, err := json.Marshal(object)
+	Ω(err).ShouldNot(HaveOccurred())
+	return CombineHandlers(
+		VerifyContentType("application/json"),
+		VerifyJSON(string(data)),
+	)
+}
+
+//VerifyForm returns a handler that verifies a request contains the specified form values.
+//
+//The request must contain *all* of the specified values, but it is allowed to have additional
+//form values beyond the passed in set.
+func VerifyForm(values url.Values) http.HandlerFunc {
+	return func(w http.ResponseWriter, r *http.Request) {
+		err := r.ParseForm()
+		Ω(err).ShouldNot(HaveOccurred())
+		for key, vals := range values {
+			Ω(r.Form[key]).Should(Equal(vals), "Form mismatch for key: %s", key)
+		}
+	}
+}
+
+//VerifyFormKV returns a handler that verifies a request contains a form key with the specified values.
+//
+//It is a convenience wrapper around `VerifyForm` that lets you avoid having to create a `url.Values` object.
+func VerifyFormKV(key string, values ...string) http.HandlerFunc {
+	return VerifyForm(url.Values{key: values})
+}
+
+//VerifyProtoRepresenting returns a handler that verifies that the body of the request is a valid protobuf
+//representation of the passed message.
+//
+//VerifyProtoRepresenting also verifies that the request's content type is application/x-protobuf
+func VerifyProtoRepresenting(expected proto.Message) http.HandlerFunc {
+	return CombineHandlers(
+		VerifyContentType("application/x-protobuf"),
+		func(w http.ResponseWriter, req *http.Request) {
+			body, err := ioutil.ReadAll(req.Body)
+			Ω(err).ShouldNot(HaveOccurred())
+			req.Body.Close()
+
+			expectedType := reflect.TypeOf(expected)
+			actualValuePtr := reflect.New(expectedType.Elem())
+
+			actual, ok := actualValuePtr.Interface().(proto.Message)
+			Ω(ok).Should(BeTrue(), "Message value is not a proto.Message")
+
+			err = proto.Unmarshal(body, actual)
+			Ω(err).ShouldNot(HaveOccurred(), "Failed to unmarshal protobuf")
+
+			Ω(actual).Should(Equal(expected), "ProtoBuf Mismatch")
+		},
+	)
+}
+
+func copyHeader(src http.Header, dst http.Header) {
+	for key, value := range src {
+		dst[key] = value
+	}
+}
+
+/*
+RespondWith returns a handler that responds to a request with the specified status code and body
+
+Body may be a string or []byte
+
+Also, RespondWith can be given an optional http.Header.  The headers defined therein will be added to the response headers.
+*/
+func RespondWith(statusCode int, body interface{}, optionalHeader ...http.Header) http.HandlerFunc {
+	return func(w http.ResponseWriter, req *http.Request) {
+		if len(optionalHeader) == 1 {
+			copyHeader(optionalHeader[0], w.Header())
+		}
+		w.WriteHeader(statusCode)
+		switch x := body.(type) {
+		case string:
+			w.Write([]byte(x))
+		case []byte:
+			w.Write(x)
+		default:
+			Ω(body).Should(BeNil(), "Invalid type for body.  Should be string or []byte.")
+		}
+	}
+}
+
+/*
+RespondWithPtr returns a handler that responds to a request with the specified status code and body
+
+Unlike RespondWith, you pass RepondWithPtr a pointer to the status code and body allowing different tests
+to share the same setup but specify different status codes and bodies.
+
+Also, RespondWithPtr can be given an optional http.Header.  The headers defined therein will be added to the response headers.
+Since the http.Header can be mutated after the fact you don't need to pass in a pointer.
+*/
+func RespondWithPtr(statusCode *int, body interface{}, optionalHeader ...http.Header) http.HandlerFunc {
+	return func(w http.ResponseWriter, req *http.Request) {
+		if len(optionalHeader) == 1 {
+			copyHeader(optionalHeader[0], w.Header())
+		}
+		w.WriteHeader(*statusCode)
+		if body != nil {
+			switch x := (body).(type) {
+			case *string:
+				w.Write([]byte(*x))
+			case *[]byte:
+				w.Write(*x)
+			default:
+				Ω(body).Should(BeNil(), "Invalid type for body.  Should be string or []byte.")
+			}
+		}
+	}
+}
+
+/*
+RespondWithJSONEncoded returns a handler that responds to a request with the specified status code and a body
+containing the JSON-encoding of the passed in object
+
+Also, RespondWithJSONEncoded can be given an optional http.Header.  The headers defined therein will be added to the response headers.
+*/
+func RespondWithJSONEncoded(statusCode int, object interface{}, optionalHeader ...http.Header) http.HandlerFunc {
+	data, err := json.Marshal(object)
+	Ω(err).ShouldNot(HaveOccurred())
+
+	var headers http.Header
+	if len(optionalHeader) == 1 {
+		headers = optionalHeader[0]
+	} else {
+		headers = make(http.Header)
+	}
+	if _, found := headers["Content-Type"]; !found {
+		headers["Content-Type"] = []string{"application/json"}
+	}
+	return RespondWith(statusCode, string(data), headers)
+}
+
+/*
+RespondWithJSONEncodedPtr behaves like RespondWithJSONEncoded but takes a pointer
+to a status code and object.
+
+This allows different tests to share the same setup but specify different status codes and JSON-encoded
+objects.
+
+Also, RespondWithJSONEncodedPtr can be given an optional http.Header.  The headers defined therein will be added to the response headers.
+Since the http.Header can be mutated after the fact you don't need to pass in a pointer.
+*/
+func RespondWithJSONEncodedPtr(statusCode *int, object interface{}, optionalHeader ...http.Header) http.HandlerFunc {
+	return func(w http.ResponseWriter, req *http.Request) {
+		data, err := json.Marshal(object)
+		Ω(err).ShouldNot(HaveOccurred())
+		var headers http.Header
+		if len(optionalHeader) == 1 {
+			headers = optionalHeader[0]
+		} else {
+			headers = make(http.Header)
+		}
+		if _, found := headers["Content-Type"]; !found {
+			headers["Content-Type"] = []string{"application/json"}
+		}
+		copyHeader(headers, w.Header())
+		w.WriteHeader(*statusCode)
+		w.Write(data)
+	}
+}
+
+//RespondWithProto returns a handler that responds to a request with the specified status code and a body
+//containing the protobuf serialization of the provided message.
+//
+//Also, RespondWithProto can be given an optional http.Header.  The headers defined therein will be added to the response headers.
+func RespondWithProto(statusCode int, message proto.Message, optionalHeader ...http.Header) http.HandlerFunc {
+	return func(w http.ResponseWriter, req *http.Request) {
+		data, err := proto.Marshal(message)
+		Ω(err).ShouldNot(HaveOccurred())
+
+		var headers http.Header
+		if len(optionalHeader) == 1 {
+			headers = optionalHeader[0]
+		} else {
+			headers = make(http.Header)
+		}
+		if _, found := headers["Content-Type"]; !found {
+			headers["Content-Type"] = []string{"application/x-protobuf"}
+		}
+		copyHeader(headers, w.Header())
+
+		w.WriteHeader(statusCode)
+		w.Write(data)
+	}
+}

vendor/github.com/onsi/gomega/ghttp/protobuf/protobuf.go

@@ -0,0 +1,3 @@
+package protobuf
+
+//go:generate protoc --go_out=. simple_message.proto

vendor/github.com/onsi/gomega/ghttp/protobuf/simple_message.pb.go

@@ -0,0 +1,55 @@
+// Code generated by protoc-gen-go.
+// source: simple_message.proto
+// DO NOT EDIT!
+
+/*
+Package protobuf is a generated protocol buffer package.
+
+It is generated from these files:
+	simple_message.proto
+
+It has these top-level messages:
+	SimpleMessage
+*/
+package protobuf
+
+import proto "github.com/golang/protobuf/proto"
+import fmt "fmt"
+import math "math"
+
+// Reference imports to suppress errors if they are not otherwise used.
+var _ = proto.Marshal
+var _ = fmt.Errorf
+var _ = math.Inf
+
+type SimpleMessage struct {
+	Description      *string `protobuf:"bytes,1,req,name=description" json:"description,omitempty"`
+	Id               *int32  `protobuf:"varint,2,req,name=id" json:"id,omitempty"`
+	Metadata         *string `protobuf:"bytes,3,opt,name=metadata" json:"metadata,omitempty"`
+	XXX_unrecognized []byte  `json:"-"`
+}
+
+func (m *SimpleMessage) Reset()         { *m = SimpleMessage{} }
+func (m *SimpleMessage) String() string { return proto.CompactTextString(m) }
+func (*SimpleMessage) ProtoMessage()    {}
+
+func (m *SimpleMessage) GetDescription() string {
+	if m != nil && m.Description != nil {
+		return *m.Description
+	}
+	return ""
+}
+
+func (m *SimpleMessage) GetId() int32 {
+	if m != nil && m.Id != nil {
+		return *m.Id
+	}
+	return 0
+}
+
+func (m *SimpleMessage) GetMetadata() string {
+	if m != nil && m.Metadata != nil {
+		return *m.Metadata
+	}
+	return ""
+}

vendor/github.com/onsi/gomega/ghttp/protobuf/simple_message.proto

@@ -0,0 +1,9 @@
+syntax = "proto2";
+
+package protobuf;
+
+message SimpleMessage {
+    required string description = 1;
+    required int32 id = 2;
+    optional string metadata = 3;
+}

vendor/github.com/onsi/gomega/ghttp/test_server.go

@@ -0,0 +1,379 @@
+/*
+Package ghttp supports testing HTTP clients by providing a test server (simply a thin wrapper around httptest's server) that supports
+registering multiple handlers.  Incoming requests are not routed between the different handlers
+- rather it is merely the order of the handlers that matters.  The first request is handled by the first
+registered handler, the second request by the second handler, etc.
+
+The intent here is to have each handler *verify* that the incoming request is valid.  To accomplish, ghttp
+also provides a collection of bite-size handlers that each perform one aspect of request verification.  These can
+be composed together and registered with a ghttp server.  The result is an expressive language for describing
+the requests generated by the client under test.
+
+Here's a simple example, note that the server handler is only defined in one BeforeEach and then modified, as required, by the nested BeforeEaches.
+A more comprehensive example is available at https://onsi.github.io/gomega/#_testing_http_clients
+
+	var _ = Describe("A Sprockets Client", func() {
+		var server *ghttp.Server
+		var client *SprocketClient
+		BeforeEach(func() {
+			server = ghttp.NewServer()
+			client = NewSprocketClient(server.URL(), "skywalker", "tk427")
+		})
+
+		AfterEach(func() {
+			server.Close()
+		})
+
+		Describe("fetching sprockets", func() {
+			var statusCode int
+			var sprockets []Sprocket
+			BeforeEach(func() {
+				statusCode = http.StatusOK
+				sprockets = []Sprocket{}
+				server.AppendHandlers(ghttp.CombineHandlers(
+					ghttp.VerifyRequest("GET", "/sprockets"),
+					ghttp.VerifyBasicAuth("skywalker", "tk427"),
+					ghttp.RespondWithJSONEncodedPtr(&statusCode, &sprockets),
+				))
+			})
+
+			Context("when requesting all sprockets", func() {
+				Context("when the response is succesful", func() {
+					BeforeEach(func() {
+						sprockets = []Sprocket{
+							NewSprocket("Alfalfa"),
+							NewSprocket("Banana"),
+						}
+					})
+
+					It("should return the returned sprockets", func() {
+						Ω(client.Sprockets()).Should(Equal(sprockets))
+					})
+				})
+
+				Context("when the response is missing", func() {
+					BeforeEach(func() {
+						statusCode = http.StatusNotFound
+					})
+
+					It("should return an empty list of sprockets", func() {
+						Ω(client.Sprockets()).Should(BeEmpty())
+					})
+				})
+
+				Context("when the response fails to authenticate", func() {
+					BeforeEach(func() {
+						statusCode = http.StatusUnauthorized
+					})
+
+					It("should return an AuthenticationError error", func() {
+						sprockets, err := client.Sprockets()
+						Ω(sprockets).Should(BeEmpty())
+						Ω(err).Should(MatchError(AuthenticationError))
+					})
+				})
+
+				Context("when the response is a server failure", func() {
+					BeforeEach(func() {
+						statusCode = http.StatusInternalServerError
+					})
+
+					It("should return an InternalError error", func() {
+						sprockets, err := client.Sprockets()
+						Ω(sprockets).Should(BeEmpty())
+						Ω(err).Should(MatchError(InternalError))
+					})
+				})
+			})
+
+			Context("when requesting some sprockets", func() {
+				BeforeEach(func() {
+					sprockets = []Sprocket{
+						NewSprocket("Alfalfa"),
+						NewSprocket("Banana"),
+					}
+
+					server.WrapHandler(0, ghttp.VerifyRequest("GET", "/sprockets", "filter=FOOD"))
+				})
+
+				It("should make the request with a filter", func() {
+					Ω(client.Sprockets("food")).Should(Equal(sprockets))
+				})
+			})
+		})
+	})
+*/
+package ghttp
+
+import (
+	"fmt"
+	"io"
+	"io/ioutil"
+	"net/http"
+	"net/http/httptest"
+	"reflect"
+	"regexp"
+	"strings"
+	"sync"
+
+	. "github.com/onsi/gomega"
+)
+
+func new() *Server {
+	return &Server{
+		AllowUnhandledRequests:     false,
+		UnhandledRequestStatusCode: http.StatusInternalServerError,
+		writeLock:                  &sync.Mutex{},
+	}
+}
+
+type routedHandler struct {
+	method     string
+	pathRegexp *regexp.Regexp
+	path       string
+	handler    http.HandlerFunc
+}
+
+// NewServer returns a new `*ghttp.Server` that wraps an `httptest` server.  The server is started automatically.
+func NewServer() *Server {
+	s := new()
+	s.HTTPTestServer = httptest.NewServer(s)
+	return s
+}
+
+// NewUnstartedServer return a new, unstarted, `*ghttp.Server`.  Useful for specifying a custom listener on `server.HTTPTestServer`.
+func NewUnstartedServer() *Server {
+	s := new()
+	s.HTTPTestServer = httptest.NewUnstartedServer(s)
+	return s
+}
+
+// NewTLSServer returns a new `*ghttp.Server` that wraps an `httptest` TLS server.  The server is started automatically.
+func NewTLSServer() *Server {
+	s := new()
+	s.HTTPTestServer = httptest.NewTLSServer(s)
+	return s
+}
+
+type Server struct {
+	//The underlying httptest server
+	HTTPTestServer *httptest.Server
+
+	//Defaults to false.  If set to true, the Server will allow more requests than there are registered handlers.
+	AllowUnhandledRequests bool
+
+	//The status code returned when receiving an unhandled request.
+	//Defaults to http.StatusInternalServerError.
+	//Only applies if AllowUnhandledRequests is true
+	UnhandledRequestStatusCode int
+
+	//If provided, ghttp will log about each request received to the provided io.Writer
+	//Defaults to nil
+	//If you're using Ginkgo, set this to GinkgoWriter to get improved output during failures
+	Writer io.Writer
+
+	receivedRequests []*http.Request
+	requestHandlers  []http.HandlerFunc
+	routedHandlers   []routedHandler
+
+	writeLock *sync.Mutex
+	calls     int
+}
+
+//Start() starts an unstarted ghttp server.  It is a catastrophic error to call Start more than once (thanks, httptest).
+func (s *Server) Start() {
+	s.HTTPTestServer.Start()
+}
+
+//URL() returns a url that will hit the server
+func (s *Server) URL() string {
+	return s.HTTPTestServer.URL
+}
+
+//Addr() returns the address on which the server is listening.
+func (s *Server) Addr() string {
+	return s.HTTPTestServer.Listener.Addr().String()
+}
+
+//Close() should be called at the end of each test.  It spins down and cleans up the test server.
+func (s *Server) Close() {
+	s.writeLock.Lock()
+	defer s.writeLock.Unlock()
+
+	server := s.HTTPTestServer
+	s.HTTPTestServer = nil
+	server.Close()
+}
+
+//ServeHTTP() makes Server an http.Handler
+//When the server receives a request it handles the request in the following order:
+//
+//1. If the request matches a handler registered with RouteToHandler, that handler is called.
+//2. Otherwise, if there are handlers registered via AppendHandlers, those handlers are called in order.
+//3. If all registered handlers have been called then:
+//   a) If AllowUnhandledRequests is true, the request will be handled with response code of UnhandledRequestStatusCode
+//   b) If AllowUnhandledRequests is false, the request will not be handled and the current test will be marked as failed.
+func (s *Server) ServeHTTP(w http.ResponseWriter, req *http.Request) {
+	s.writeLock.Lock()
+	defer func() {
+		e := recover()
+		if e != nil {
+			w.WriteHeader(http.StatusInternalServerError)
+		}
+
+		//If the handler panics GHTTP will silently succeed.  This is bad™.
+		//To catch this case we need to fail the test if the handler has panicked.
+		//However, if the handler is panicking because Ginkgo's causing it to panic (i.e. an asswertion failed)
+		//then we shouldn't double-report the error as this will confuse people.
+
+		//So: step 1, if this is a Ginkgo panic - do nothing, Ginkgo's aware of the failure
+		eAsString, ok := e.(string)
+		if ok && strings.Contains(eAsString, "defer GinkgoRecover()") {
+			return
+		}
+
+		//If we're here, we have to do step 2: assert that the error is nil.  This assertion will
+		//allow us to fail the test suite (note: we can't call Fail since Gomega is not allowed to import Ginkgo).
+		//Since a failed assertion throws a panic, and we are likely in a goroutine, we need to defer within our defer!
+		defer func() {
+			recover()
+		}()
+		Ω(e).Should(BeNil(), "Handler Panicked")
+	}()
+
+	if s.Writer != nil {
+		s.Writer.Write([]byte(fmt.Sprintf("GHTTP Received Request: %s - %s\n", req.Method, req.URL)))
+	}
+
+	s.receivedRequests = append(s.receivedRequests, req)
+	if routedHandler, ok := s.handlerForRoute(req.Method, req.URL.Path); ok {
+		s.writeLock.Unlock()
+		routedHandler(w, req)
+	} else if s.calls < len(s.requestHandlers) {
+		h := s.requestHandlers[s.calls]
+		s.calls++
+		s.writeLock.Unlock()
+		h(w, req)
+	} else {
+		s.writeLock.Unlock()
+		if s.AllowUnhandledRequests {
+			ioutil.ReadAll(req.Body)
+			req.Body.Close()
+			w.WriteHeader(s.UnhandledRequestStatusCode)
+		} else {
+			Ω(req).Should(BeNil(), "Received Unhandled Request")
+		}
+	}
+}
+
+//ReceivedRequests is an array containing all requests received by the server (both handled and unhandled requests)
+func (s *Server) ReceivedRequests() []*http.Request {
+	s.writeLock.Lock()
+	defer s.writeLock.Unlock()
+
+	return s.receivedRequests
+}
+
+//RouteToHandler can be used to register handlers that will always handle requests that match
+//the passed in method and path.
+//
+//The path may be either a string object or a *regexp.Regexp.
+func (s *Server) RouteToHandler(method string, path interface{}, handler http.HandlerFunc) {
+	s.writeLock.Lock()
+	defer s.writeLock.Unlock()
+
+	rh := routedHandler{
+		method:  method,
+		handler: handler,
+	}
+
+	switch p := path.(type) {
+	case *regexp.Regexp:
+		rh.pathRegexp = p
+	case string:
+		rh.path = p
+	default:
+		panic("path must be a string or a regular expression")
+	}
+
+	for i, existingRH := range s.routedHandlers {
+		if existingRH.method == method &&
+			reflect.DeepEqual(existingRH.pathRegexp, rh.pathRegexp) &&
+			existingRH.path == rh.path {
+			s.routedHandlers[i] = rh
+			return
+		}
+	}
+	s.routedHandlers = append(s.routedHandlers, rh)
+}
+
+func (s *Server) handlerForRoute(method string, path string) (http.HandlerFunc, bool) {
+	for _, rh := range s.routedHandlers {
+		if rh.method == method {
+			if rh.pathRegexp != nil {
+				if rh.pathRegexp.Match([]byte(path)) {
+					return rh.handler, true
+				}
+			} else if rh.path == path {
+				return rh.handler, true
+			}
+		}
+	}
+
+	return nil, false
+}
+
+//AppendHandlers will appends http.HandlerFuncs to the server's list of registered handlers.  The first incoming request is handled by the first handler, the second by the second, etc...
+func (s *Server) AppendHandlers(handlers ...http.HandlerFunc) {
+	s.writeLock.Lock()
+	defer s.writeLock.Unlock()
+
+	s.requestHandlers = append(s.requestHandlers, handlers...)
+}
+
+//SetHandler overrides the registered handler at the passed in index with the passed in handler
+//This is useful, for example, when a server has been set up in a shared context, but must be tweaked
+//for a particular test.
+func (s *Server) SetHandler(index int, handler http.HandlerFunc) {
+	s.writeLock.Lock()
+	defer s.writeLock.Unlock()
+
+	s.requestHandlers[index] = handler
+}
+
+//GetHandler returns the handler registered at the passed in index.
+func (s *Server) GetHandler(index int) http.HandlerFunc {
+	s.writeLock.Lock()
+	defer s.writeLock.Unlock()
+
+	return s.requestHandlers[index]
+}
+
+func (s *Server) Reset() {
+	s.writeLock.Lock()
+	defer s.writeLock.Unlock()
+
+	s.HTTPTestServer.CloseClientConnections()
+	s.calls = 0
+	s.receivedRequests = nil
+	s.requestHandlers = nil
+	s.routedHandlers = nil
+}
+
+//WrapHandler combines the passed in handler with the handler registered at the passed in index.
+//This is useful, for example, when a server has been set up in a shared context but must be tweaked
+//for a particular test.
+//
+//If the currently registered handler is A, and the new passed in handler is B then
+//WrapHandler will generate a new handler that first calls A, then calls B, and assign it to index
+func (s *Server) WrapHandler(index int, handler http.HandlerFunc) {
+	existingHandler := s.GetHandler(index)
+	s.SetHandler(index, CombineHandlers(existingHandler, handler))
+}
+
+func (s *Server) CloseClientConnections() {
+	s.writeLock.Lock()
+	defer s.writeLock.Unlock()
+
+	s.HTTPTestServer.CloseClientConnections()
+}

vendor/github.com/onsi/gomega/ghttp/test_server_suite_test.go

@@ -0,0 +1,13 @@
+package ghttp_test
+
+import (
+	. "github.com/onsi/ginkgo"
+	. "github.com/onsi/gomega"
+
+	"testing"
+)
+
+func TestGHTTP(t *testing.T) {
+	RegisterFailHandler(Fail)
+	RunSpecs(t, "GHTTP Suite")
+}