Add support for string types

- strings are now generated as two fields for length and string itself
- aliases are now sorted by name to prevent generating different code
- dependencies are now managed by dep
- binapi files are regenerated using VPP 19.01-rc0~622-g7b01e9e8
- old stats binary api has been deprecated and removed from VPP

Change-Id: Ieb8515c73021339a45f407386f8e3d87dcf4469e
Signed-off-by: Ondrej Fabry <ofabry@cisco.com>

80 files changed, 0 insertions, 8294 deletions

diff --git a/vendor/github.com/onsi/gomega/format/format_suite_test.go b/vendor/github.com/onsi/gomega/format/format_suite_test.go
deleted file mode 100644
index 8e65a95..0000000
--- a/vendor/github.com/onsi/gomega/format/format_suite_test.go
+++ /dev/null
@@ -1,13 +0,0 @@
-package format_test
-
-import (
-	. "github.com/onsi/ginkgo"
-	. "github.com/onsi/gomega"
-
-	"testing"
-)
-
-func TestFormat(t *testing.T) {
-	RegisterFailHandler(Fail)
-	RunSpecs(t, "Format Suite")
-}
diff --git a/vendor/github.com/onsi/gomega/format/format_test.go b/vendor/github.com/onsi/gomega/format/format_test.go
deleted file mode 100644
index a1a9031..0000000
--- a/vendor/github.com/onsi/gomega/format/format_test.go
+++ /dev/null
@@ -1,590 +0,0 @@
-package format_test
-
-import (
-	"fmt"
-	"strings"
-	"time"
-
-	. "github.com/onsi/ginkgo"
-	. "github.com/onsi/gomega"
-	. "github.com/onsi/gomega/format"
-	"github.com/onsi/gomega/types"
-)
-
-//recursive struct
-
-type StringAlias string
-type ByteAlias []byte
-type IntAlias int
-
-type AStruct struct {
-	Exported string
-}
-
-type SimpleStruct struct {
-	Name        string
-	Enumeration int
-	Veritas     bool
-	Data        []byte
-	secret      uint32
-}
-
-type ComplexStruct struct {
-	Strings      []string
-	SimpleThings []*SimpleStruct
-	DataMaps     map[int]ByteAlias
-}
-
-type SecretiveStruct struct {
-	boolValue      bool
-	intValue       int
-	uintValue      uint
-	uintptrValue   uintptr
-	floatValue     float32
-	complexValue   complex64
-	chanValue      chan bool
-	funcValue      func()
-	pointerValue   *int
-	sliceValue     []string
-	byteSliceValue []byte
-	stringValue    string
-	arrValue       [3]int
-	byteArrValue   [3]byte
-	mapValue       map[string]int
-	structValue    AStruct
-	interfaceValue interface{}
-}
-
-type GoStringer struct {
-}
-
-func (g GoStringer) GoString() string {
-	return "go-string"
-}
-
-func (g GoStringer) String() string {
-	return "string"
-}
-
-type Stringer struct {
-}
-
-func (g Stringer) String() string {
-	return "string"
-}
-
-type ctx struct {
-}
-
-func (c *ctx) Deadline() (deadline time.Time, ok bool) {
-	return time.Time{}, false
-}
-
-func (c *ctx) Done() <-chan struct{} {
-	return nil
-}
-
-func (c *ctx) Err() error {
-	return nil
-}
-
-func (c *ctx) Value(key interface{}) interface{} {
-	return nil
-}
-
-var _ = Describe("Format", func() {
-	match := func(typeRepresentation string, valueRepresentation string, args ...interface{}) types.GomegaMatcher {
-		if len(args) > 0 {
-			valueRepresentation = fmt.Sprintf(valueRepresentation, args...)
-		}
-		return Equal(fmt.Sprintf("%s<%s>: %s", Indent, typeRepresentation, valueRepresentation))
-	}
-
-	matchRegexp := func(typeRepresentation string, valueRepresentation string, args ...interface{}) types.GomegaMatcher {
-		if len(args) > 0 {
-			valueRepresentation = fmt.Sprintf(valueRepresentation, args...)
-		}
-		return MatchRegexp(fmt.Sprintf("%s<%s>: %s", Indent, typeRepresentation, valueRepresentation))
-	}
-
-	hashMatchingRegexp := func(entries ...string) string {
-		entriesSwitch := "(" + strings.Join(entries, "|") + ")"
-		arr := make([]string, len(entries))
-		for i := range arr {
-			arr[i] = entriesSwitch
-		}
-		return "{" + strings.Join(arr, ", ") + "}"
-	}
-
-	Describe("Message", func() {
-		Context("with only an actual value", func() {
-			It("should print out an indented formatted representation of the value and the message", func() {
-				Ω(Message(3, "to be three.")).Should(Equal("Expected\n    <int>: 3\nto be three."))
-			})
-		})
-
-		Context("with an actual and an expected value", func() {
-			It("should print out an indented formatted representatino of both values, and the message", func() {
-				Ω(Message(3, "to equal", 4)).Should(Equal("Expected\n    <int>: 3\nto equal\n    <int>: 4"))
-			})
-		})
-	})
-
-	Describe("MessageWithDiff", func() {
-		It("shows the exact point where two long strings differ", func() {
-			stringWithB := "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaabaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
-			stringWithZ := "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaazaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
-
-			Ω(MessageWithDiff(stringWithB, "to equal", stringWithZ)).Should(Equal(expectedLongStringFailureMessage))
-		})
-
-		It("truncates the start of long strings that differ only at their end", func() {
-			stringWithB := "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaab"
-			stringWithZ := "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaz"
-
-			Ω(MessageWithDiff(stringWithB, "to equal", stringWithZ)).Should(Equal(expectedTruncatedStartStringFailureMessage))
-		})
-
-		It("truncates the start of long strings that differ only in length", func() {
-			smallString := "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
-			largeString := "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
-
-			Ω(MessageWithDiff(largeString, "to equal", smallString)).Should(Equal(expectedTruncatedStartSizeFailureMessage))
-			Ω(MessageWithDiff(smallString, "to equal", largeString)).Should(Equal(expectedTruncatedStartSizeSwappedFailureMessage))
-		})
-
-		It("truncates the end of long strings that differ only at their start", func() {
-			stringWithB := "baaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
-			stringWithZ := "zaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
-
-			Ω(MessageWithDiff(stringWithB, "to equal", stringWithZ)).Should(Equal(expectedTruncatedEndStringFailureMessage))
-		})
-	})
-
-	Describe("IndentString", func() {
-		It("should indent the string", func() {
-			Ω(IndentString("foo\n  bar\nbaz", 2)).Should(Equal("        foo\n          bar\n        baz"))
-		})
-	})
-
-	Describe("Object", func() {
-		Describe("formatting boolean values", func() {
-			It("should give the type and format values correctly", func() {
-				Ω(Object(true, 1)).Should(match("bool", "true"))
-				Ω(Object(false, 1)).Should(match("bool", "false"))
-			})
-		})
-
-		Describe("formatting numbers", func() {
-			It("should give the type and format values correctly", func() {
-				Ω(Object(int(3), 1)).Should(match("int", "3"))
-				Ω(Object(int8(3), 1)).Should(match("int8", "3"))
-				Ω(Object(int16(3), 1)).Should(match("int16", "3"))
-				Ω(Object(int32(3), 1)).Should(match("int32", "3"))
-				Ω(Object(int64(3), 1)).Should(match("int64", "3"))
-
-				Ω(Object(uint(3), 1)).Should(match("uint", "3"))
-				Ω(Object(uint8(3), 1)).Should(match("uint8", "3"))
-				Ω(Object(uint16(3), 1)).Should(match("uint16", "3"))
-				Ω(Object(uint32(3), 1)).Should(match("uint32", "3"))
-				Ω(Object(uint64(3), 1)).Should(match("uint64", "3"))
-			})
-
-			It("should handle uintptr differently", func() {
-				Ω(Object(uintptr(3), 1)).Should(match("uintptr", "0x3"))
-			})
-		})
-
-		Describe("formatting channels", func() {
-			It("should give the type and format values correctly", func() {
-				c := make(chan<- bool, 3)
-				c <- true
-				c <- false
-				Ω(Object(c, 1)).Should(match("chan<- bool | len:2, cap:3", "%v", c))
-			})
-		})
-
-		Describe("formatting strings", func() {
-			It("should give the type and format values correctly", func() {
-				s := "a\nb\nc"
-				Ω(Object(s, 1)).Should(match("string", `a
-    b
-    c`))
-			})
-		})
-
-		Describe("formatting []byte slices", func() {
-			Context("when the slice is made of printable bytes", func() {
-				It("should present it as string", func() {
-					b := []byte("a b c")
-					Ω(Object(b, 1)).Should(matchRegexp(`\[\]uint8 \| len:5, cap:\d+`, `a b c`))
-				})
-			})
-			Context("when the slice contains non-printable bytes", func() {
-				It("should present it as slice", func() {
-					b := []byte("a b c\n\x01\x02\x03\xff\x1bH")
-					Ω(Object(b, 1)).Should(matchRegexp(`\[\]uint8 \| len:12, cap:\d+`, `\[97, 32, 98, 32, 99, 10, 1, 2, 3, 255, 27, 72\]`))
-				})
-			})
-		})
-
-		Describe("formatting functions", func() {
-			It("should give the type and format values correctly", func() {
-				f := func(a string, b []int) ([]byte, error) {
-					return []byte("abc"), nil
-				}
-				Ω(Object(f, 1)).Should(match("func(string, []int) ([]uint8, error)", "%v", f))
-			})
-		})
-
-		Describe("formatting pointers", func() {
-			It("should give the type and dereference the value to format it correctly", func() {
-				a := 3
-				Ω(Object(&a, 1)).Should(match(fmt.Sprintf("*int | %p", &a), "3"))
-			})
-
-			Context("when there are pointers to pointers...", func() {
-				It("should recursively deference the pointer until it gets to a value", func() {
-					a := 3
-					var b *int
-					var c **int
-					var d ***int
-					b = &a
-					c = &b
-					d = &c
-
-					Ω(Object(d, 1)).Should(match(fmt.Sprintf("***int | %p", d), "3"))
-				})
-			})
-
-			Context("when the pointer points to nil", func() {
-				It("should say nil and not explode", func() {
-					var a *AStruct
-					Ω(Object(a, 1)).Should(match("*format_test.AStruct | 0x0", "nil"))
-				})
-			})
-		})
-
-		Describe("formatting arrays", func() {
-			It("should give the type and format values correctly", func() {
-				w := [3]string{"Jed Bartlet", "Toby Ziegler", "CJ Cregg"}
-				Ω(Object(w, 1)).Should(match("[3]string", `["Jed Bartlet", "Toby Ziegler", "CJ Cregg"]`))
-			})
-
-			Context("with byte arrays", func() {
-				It("should give the type and format values correctly", func() {
-					w := [3]byte{17, 28, 19}
-					Ω(Object(w, 1)).Should(match("[3]uint8", `[17, 28, 19]`))
-				})
-			})
-		})
-
-		Describe("formatting slices", func() {
-			It("should include the length and capacity in the type information", func() {
-				s := make([]bool, 3, 4)
-				Ω(Object(s, 1)).Should(match("[]bool | len:3, cap:4", "[false, false, false]"))
-			})
-
-			Context("when the slice contains long entries", func() {
-				It("should format the entries with newlines", func() {
-					w := []string{"Josiah Edward Bartlet", "Toby Ziegler", "CJ Cregg"}
-					expected := `[
-        "Josiah Edward Bartlet",
-        "Toby Ziegler",
-        "CJ Cregg",
-    ]`
-					Ω(Object(w, 1)).Should(match("[]string | len:3, cap:3", expected))
-				})
-			})
-		})
-
-		Describe("formatting maps", func() {
-			It("should include the length in the type information", func() {
-				m := make(map[int]bool, 5)
-				m[3] = true
-				m[4] = false
-				Ω(Object(m, 1)).Should(matchRegexp(`map\[int\]bool \| len:2`, hashMatchingRegexp("3: true", "4: false")))
-			})
-
-			Context("when the slice contains long entries", func() {
-				It("should format the entries with newlines", func() {
-					m := map[string][]byte{}
-					m["Josiah Edward Bartlet"] = []byte("Martin Sheen")
-					m["Toby Ziegler"] = []byte("Richard Schiff")
-					m["CJ Cregg"] = []byte("Allison Janney")
-					expected := `{
-        ("Josiah Edward Bartlet": "Martin Sheen"|"Toby Ziegler": "Richard Schiff"|"CJ Cregg": "Allison Janney"),
-        ("Josiah Edward Bartlet": "Martin Sheen"|"Toby Ziegler": "Richard Schiff"|"CJ Cregg": "Allison Janney"),
-        ("Josiah Edward Bartlet": "Martin Sheen"|"Toby Ziegler": "Richard Schiff"|"CJ Cregg": "Allison Janney"),
-    }`
-					Ω(Object(m, 1)).Should(matchRegexp(`map\[string\]\[\]uint8 \| len:3`, expected))
-				})
-			})
-		})
-
-		Describe("formatting structs", func() {
-			It("should include the struct name and the field names", func() {
-				s := SimpleStruct{
-					Name:        "Oswald",
-					Enumeration: 17,
-					Veritas:     true,
-					Data:        []byte("datum"),
-					secret:      1983,
-				}
-
-				Ω(Object(s, 1)).Should(match("format_test.SimpleStruct", `{Name: "Oswald", Enumeration: 17, Veritas: true, Data: "datum", secret: 1983}`))
-			})
-
-			Context("when the struct contains long entries", func() {
-				It("should format the entries with new lines", func() {
-					s := &SimpleStruct{
-						Name:        "Mithrandir Gandalf Greyhame",
-						Enumeration: 2021,
-						Veritas:     true,
-						Data:        []byte("wizard"),
-						secret:      3,
-					}
-
-					Ω(Object(s, 1)).Should(match(fmt.Sprintf("*format_test.SimpleStruct | %p", s), `{
-        Name: "Mithrandir Gandalf Greyhame",
-        Enumeration: 2021,
-        Veritas: true,
-        Data: "wizard",
-        secret: 3,
-    }`))
-				})
-			})
-		})
-
-		Describe("formatting nil values", func() {
-			It("should print out nil", func() {
-				Ω(Object(nil, 1)).Should(match("nil", "nil"))
-				var typedNil *AStruct
-				Ω(Object(typedNil, 1)).Should(match("*format_test.AStruct | 0x0", "nil"))
-				var c chan<- bool
-				Ω(Object(c, 1)).Should(match("chan<- bool | len:0, cap:0", "nil"))
-				var s []string
-				Ω(Object(s, 1)).Should(match("[]string | len:0, cap:0", "nil"))
-				var m map[string]bool
-				Ω(Object(m, 1)).Should(match("map[string]bool | len:0", "nil"))
-			})
-		})
-
-		Describe("formatting aliased types", func() {
-			It("should print out the correct alias type", func() {
-				Ω(Object(StringAlias("alias"), 1)).Should(match("format_test.StringAlias", `alias`))
-				Ω(Object(ByteAlias("alias"), 1)).Should(matchRegexp(`format_test\.ByteAlias \| len:5, cap:\d+`, `alias`))
-				Ω(Object(IntAlias(3), 1)).Should(match("format_test.IntAlias", "3"))
-			})
-		})
-
-		Describe("handling nested things", func() {
-			It("should produce a correctly nested representation", func() {
-				s := ComplexStruct{
-					Strings: []string{"lots", "of", "short", "strings"},
-					SimpleThings: []*SimpleStruct{
-						{"short", 7, true, []byte("succinct"), 17},
-						{"something longer", 427, true, []byte("designed to wrap around nicely"), 30},
-					},
-					DataMaps: map[int]ByteAlias{
-						17:   ByteAlias("some substantially longer chunks of data"),
-						1138: ByteAlias("that should make things wrap"),
-					},
-				}
-				expected := `{
-        Strings: \["lots", "of", "short", "strings"\],
-        SimpleThings: \[
-            {Name: "short", Enumeration: 7, Veritas: true, Data: "succinct", secret: 17},
-            {
-                Name: "something longer",
-                Enumeration: 427,
-                Veritas: true,
-                Data: "designed to wrap around nicely",
-                secret: 30,
-            },
-        \],
-        DataMaps: {
-            (17: "some substantially longer chunks of data"|1138: "that should make things wrap"),
-            (17: "some substantially longer chunks of data"|1138: "that should make things wrap"),
-        },
-    }`
-				Ω(Object(s, 1)).Should(matchRegexp(`format_test\.ComplexStruct`, expected))
-			})
-		})
-
-		Describe("formatting times", func() {
-			It("should format time as RFC3339", func() {
-				t := time.Date(2016, 10, 31, 9, 57, 23, 12345, time.UTC)
-				Ω(Object(t, 1)).Should(match("time.Time", `2016-10-31T09:57:23.000012345Z`))
-			})
-		})
-	})
-
-	Describe("Handling unexported fields in structs", func() {
-		It("should handle all the various types correctly", func() {
-			a := int(5)
-			s := SecretiveStruct{
-				boolValue:      true,
-				intValue:       3,
-				uintValue:      4,
-				uintptrValue:   5,
-				floatValue:     6.0,
-				complexValue:   complex(5.0, 3.0),
-				chanValue:      make(chan bool, 2),
-				funcValue:      func() {},
-				pointerValue:   &a,
-				sliceValue:     []string{"string", "slice"},
-				byteSliceValue: []byte("bytes"),
-				stringValue:    "a string",
-				arrValue:       [3]int{11, 12, 13},
-				byteArrValue:   [3]byte{17, 20, 32},
-				mapValue:       map[string]int{"a key": 20, "b key": 30},
-				structValue:    AStruct{"exported"},
-				interfaceValue: map[string]int{"a key": 17},
-			}
-
-			expected := fmt.Sprintf(`{
-        boolValue: true,
-        intValue: 3,
-        uintValue: 4,
-        uintptrValue: 0x5,
-        floatValue: 6,
-        complexValue: \(5\+3i\),
-        chanValue: %p,
-        funcValue: %p,
-        pointerValue: 5,
-        sliceValue: \["string", "slice"\],
-        byteSliceValue: "bytes",
-        stringValue: "a string",
-        arrValue: \[11, 12, 13\],
-        byteArrValue: \[17, 20, 32\],
-        mapValue: %s,
-        structValue: {Exported: "exported"},
-        interfaceValue: {"a key": 17},
-    }`, s.chanValue, s.funcValue, hashMatchingRegexp(`"a key": 20`, `"b key": 30`))
-
-			Ω(Object(s, 1)).Should(matchRegexp(`format_test\.SecretiveStruct`, expected))
-		})
-	})
-
-	Describe("Handling interfaces", func() {
-		It("should unpack the interface", func() {
-			outerHash := map[string]interface{}{}
-			innerHash := map[string]int{}
-
-			innerHash["inner"] = 3
-			outerHash["integer"] = 2
-			outerHash["map"] = innerHash
-
-			expected := hashMatchingRegexp(`"integer": 2`, `"map": {"inner": 3}`)
-			Ω(Object(outerHash, 1)).Should(matchRegexp(`map\[string\]interface {} \| len:2`, expected))
-		})
-	})
-
-	Describe("Handling recursive things", func() {
-		It("should not go crazy...", func() {
-			m := map[string]interface{}{}
-			m["integer"] = 2
-			m["map"] = m
-			Ω(Object(m, 1)).Should(ContainSubstring("..."))
-		})
-
-		It("really should not go crazy...", func() {
-			type complexKey struct {
-				Value map[interface{}]int
-			}
-
-			complexObject := complexKey{}
-			complexObject.Value = make(map[interface{}]int)
-
-			complexObject.Value[&complexObject] = 2
-			Ω(Object(complexObject, 1)).Should(ContainSubstring("..."))
-		})
-	})
-
-	Describe("When instructed to use the Stringer representation", func() {
-		BeforeEach(func() {
-			UseStringerRepresentation = true
-		})
-
-		AfterEach(func() {
-			UseStringerRepresentation = false
-		})
-
-		Context("when passed a GoStringer", func() {
-			It("should use what GoString() returns", func() {
-				Ω(Object(GoStringer{}, 1)).Should(ContainSubstring("<format_test.GoStringer>: go-string"))
-			})
-		})
-
-		Context("when passed a stringer", func() {
-			It("should use what String() returns", func() {
-				Ω(Object(Stringer{}, 1)).Should(ContainSubstring("<format_test.Stringer>: string"))
-			})
-		})
-	})
-
-	Describe("Printing a context.Context field", func() {
-
-		type structWithContext struct {
-			Context Ctx
-			Value   string
-		}
-
-		context := ctx{}
-		objWithContext := structWithContext{Value: "some-value", Context: &context}
-
-		It("Suppresses the content by default", func() {
-			Ω(Object(objWithContext, 1)).Should(ContainSubstring("<suppressed context>"))
-		})
-
-		It("Doesn't supress the context if it's the object being printed", func() {
-			Ω(Object(context, 1)).ShouldNot(MatchRegexp("^.*<suppressed context>$"))
-		})
-
-		Context("PrintContextObjects is set", func() {
-			BeforeEach(func() {
-				PrintContextObjects = true
-			})
-
-			AfterEach(func() {
-				PrintContextObjects = false
-			})
-
-			It("Prints the context", func() {
-				Ω(Object(objWithContext, 1)).ShouldNot(ContainSubstring("<suppressed context>"))
-			})
-		})
-	})
-})
-
-var expectedLongStringFailureMessage = strings.TrimSpace(`
-Expected
-    <string>: "...aaaaabaaaaa..."
-to equal               |
-    <string>: "...aaaaazaaaaa..."
-`)
-var expectedTruncatedEndStringFailureMessage = strings.TrimSpace(`
-Expected
-    <string>: "baaaaa..."
-to equal       |
-    <string>: "zaaaaa..."
-`)
-var expectedTruncatedStartStringFailureMessage = strings.TrimSpace(`
-Expected
-    <string>: "...aaaaab"
-to equal               |
-    <string>: "...aaaaaz"
-`)
-var expectedTruncatedStartSizeFailureMessage = strings.TrimSpace(`
-Expected
-    <string>: "...aaaaaa"
-to equal               |
-    <string>: "...aaaaa"
-`)
-var expectedTruncatedStartSizeSwappedFailureMessage = strings.TrimSpace(`
-Expected
-    <string>: "...aaaa"
-to equal              |
-    <string>: "...aaaaa"
-`)
diff --git a/vendor/github.com/onsi/gomega/gbytes/buffer.go b/vendor/github.com/onsi/gomega/gbytes/buffer.go
deleted file mode 100644
index 8775b86..0000000
--- a/vendor/github.com/onsi/gomega/gbytes/buffer.go
+++ /dev/null
@@ -1,229 +0,0 @@
-/*
-Package gbytes provides a buffer that supports incrementally detecting input.
-
-You use gbytes.Buffer with the gbytes.Say matcher.  When Say finds a match, it fastforwards the buffer's read cursor to the end of that match.
-
-Subsequent matches against the buffer will only operate against data that appears *after* the read cursor.
-
-The read cursor is an opaque implementation detail that you cannot access.  You should use the Say matcher to sift through the buffer.  You can always
-access the entire buffer's contents with Contents().
-
-*/
-package gbytes
-
-import (
-	"errors"
-	"fmt"
-	"io"
-	"regexp"
-	"sync"
-	"time"
-)
-
-/*
-gbytes.Buffer implements an io.Writer and can be used with the gbytes.Say matcher.
-
-You should only use a gbytes.Buffer in test code.  It stores all writes in an in-memory buffer - behavior that is inappropriate for production code!
-*/
-type Buffer struct {
-	contents     []byte
-	readCursor   uint64
-	lock         *sync.Mutex
-	detectCloser chan interface{}
-	closed       bool
-}
-
-/*
-NewBuffer returns a new gbytes.Buffer
-*/
-func NewBuffer() *Buffer {
-	return &Buffer{
-		lock: &sync.Mutex{},
-	}
-}
-
-/*
-BufferWithBytes returns a new gbytes.Buffer seeded with the passed in bytes
-*/
-func BufferWithBytes(bytes []byte) *Buffer {
-	return &Buffer{
-		lock:     &sync.Mutex{},
-		contents: bytes,
-	}
-}
-
-/*
-Write implements the io.Writer interface
-*/
-func (b *Buffer) Write(p []byte) (n int, err error) {
-	b.lock.Lock()
-	defer b.lock.Unlock()
-
-	if b.closed {
-		return 0, errors.New("attempt to write to closed buffer")
-	}
-
-	b.contents = append(b.contents, p...)
-	return len(p), nil
-}
-
-/*
-Read implements the io.Reader interface. It advances the
-cursor as it reads.
-
-Returns an error if called after Close.
-*/
-func (b *Buffer) Read(d []byte) (int, error) {
-	b.lock.Lock()
-	defer b.lock.Unlock()
-
-	if b.closed {
-		return 0, errors.New("attempt to read from closed buffer")
-	}
-
-	if uint64(len(b.contents)) <= b.readCursor {
-		return 0, io.EOF
-	}
-
-	n := copy(d, b.contents[b.readCursor:])
-	b.readCursor += uint64(n)
-
-	return n, nil
-}
-
-/*
-Close signifies that the buffer will no longer be written to
-*/
-func (b *Buffer) Close() error {
-	b.lock.Lock()
-	defer b.lock.Unlock()
-
-	b.closed = true
-
-	return nil
-}
-
-/*
-Closed returns true if the buffer has been closed
-*/
-func (b *Buffer) Closed() bool {
-	b.lock.Lock()
-	defer b.lock.Unlock()
-
-	return b.closed
-}
-
-/*
-Contents returns all data ever written to the buffer.
-*/
-func (b *Buffer) Contents() []byte {
-	b.lock.Lock()
-	defer b.lock.Unlock()
-
-	contents := make([]byte, len(b.contents))
-	copy(contents, b.contents)
-	return contents
-}
-
-/*
-Detect takes a regular expression and returns a channel.
-
-The channel will receive true the first time data matching the regular expression is written to the buffer.
-The channel is subsequently closed and the buffer's read-cursor is fast-forwarded to just after the matching region.
-
-You typically don't need to use Detect and should use the ghttp.Say matcher instead.  Detect is useful, however, in cases where your code must
-be branch and handle different outputs written to the buffer.
-
-For example, consider a buffer hooked up to the stdout of a client library.  You may (or may not, depending on state outside of your control) need to authenticate the client library.
-
-You could do something like:
-
-select {
-case <-buffer.Detect("You are not logged in"):
-	//log in
-case <-buffer.Detect("Success"):
-	//carry on
-case <-time.After(time.Second):
-	//welp
-}
-buffer.CancelDetects()
-
-You should always call CancelDetects after using Detect.  This will close any channels that have not detected and clean up the goroutines that were spawned to support them.
-
-Finally, you can pass detect a format string followed by variadic arguments.  This will construct the regexp using fmt.Sprintf.
-*/
-func (b *Buffer) Detect(desired string, args ...interface{}) chan bool {
-	formattedRegexp := desired
-	if len(args) > 0 {
-		formattedRegexp = fmt.Sprintf(desired, args...)
-	}
-	re := regexp.MustCompile(formattedRegexp)
-
-	b.lock.Lock()
-	defer b.lock.Unlock()
-
-	if b.detectCloser == nil {
-		b.detectCloser = make(chan interface{})
-	}
-
-	closer := b.detectCloser
-	response := make(chan bool)
-	go func() {
-		ticker := time.NewTicker(10 * time.Millisecond)
-		defer ticker.Stop()
-		defer close(response)
-		for {
-			select {
-			case <-ticker.C:
-				b.lock.Lock()
-				data, cursor := b.contents[b.readCursor:], b.readCursor
-				loc := re.FindIndex(data)
-				b.lock.Unlock()
-
-				if loc != nil {
-					response <- true
-					b.lock.Lock()
-					newCursorPosition := cursor + uint64(loc[1])
-					if newCursorPosition >= b.readCursor {
-						b.readCursor = newCursorPosition
-					}
-					b.lock.Unlock()
-					return
-				}
-			case <-closer:
-				return
-			}
-		}
-	}()
-
-	return response
-}
-
-/*
-CancelDetects cancels any pending detects and cleans up their goroutines.  You should always call this when you're done with a set of Detect channels.
-*/
-func (b *Buffer) CancelDetects() {
-	b.lock.Lock()
-	defer b.lock.Unlock()
-
-	close(b.detectCloser)
-	b.detectCloser = nil
-}
-
-func (b *Buffer) didSay(re *regexp.Regexp) (bool, []byte) {
-	b.lock.Lock()
-	defer b.lock.Unlock()
-
-	unreadBytes := b.contents[b.readCursor:]
-	copyOfUnreadBytes := make([]byte, len(unreadBytes))
-	copy(copyOfUnreadBytes, unreadBytes)
-
-	loc := re.FindIndex(unreadBytes)
-
-	if loc != nil {
-		b.readCursor += uint64(loc[1])
-		return true, copyOfUnreadBytes
-	} else {
-		return false, copyOfUnreadBytes
-	}
-}
diff --git a/vendor/github.com/onsi/gomega/gbytes/buffer_test.go b/vendor/github.com/onsi/gomega/gbytes/buffer_test.go
deleted file mode 100644
index b111138..0000000
--- a/vendor/github.com/onsi/gomega/gbytes/buffer_test.go
+++ /dev/null
@@ -1,158 +0,0 @@
-package gbytes_test
-
-import (
-	"io"
-	"time"
-
-	. "github.com/onsi/gomega/gbytes"
-
-	. "github.com/onsi/ginkgo"
-	. "github.com/onsi/gomega"
-)
-
-var _ = Describe("Buffer", func() {
-	var buffer *Buffer
-
-	BeforeEach(func() {
-		buffer = NewBuffer()
-	})
-
-	Describe("dumping the entire contents of the buffer", func() {
-		It("should return everything that's been written", func() {
-			buffer.Write([]byte("abc"))
-			buffer.Write([]byte("def"))
-			Ω(buffer.Contents()).Should(Equal([]byte("abcdef")))
-
-			Ω(buffer).Should(Say("bcd"))
-			Ω(buffer.Contents()).Should(Equal([]byte("abcdef")))
-		})
-	})
-
-	Describe("creating a buffer with bytes", func() {
-		It("should create the buffer with the cursor set to the beginning", func() {
-			buffer := BufferWithBytes([]byte("abcdef"))
-			Ω(buffer.Contents()).Should(Equal([]byte("abcdef")))
-			Ω(buffer).Should(Say("abc"))
-			Ω(buffer).ShouldNot(Say("abc"))
-			Ω(buffer).Should(Say("def"))
-		})
-	})
-
-	Describe("reading from a buffer", func() {
-		It("should read the current contents of the buffer", func() {
-			buffer := BufferWithBytes([]byte("abcde"))
-
-			dest := make([]byte, 3)
-			n, err := buffer.Read(dest)
-			Ω(err).ShouldNot(HaveOccurred())
-			Ω(n).Should(Equal(3))
-			Ω(string(dest)).Should(Equal("abc"))
-
-			dest = make([]byte, 3)
-			n, err = buffer.Read(dest)
-			Ω(err).ShouldNot(HaveOccurred())
-			Ω(n).Should(Equal(2))
-			Ω(string(dest[:n])).Should(Equal("de"))
-
-			n, err = buffer.Read(dest)
-			Ω(err).Should(Equal(io.EOF))
-			Ω(n).Should(Equal(0))
-		})
-
-		Context("after the buffer has been closed", func() {
-			It("returns an error", func() {
-				buffer := BufferWithBytes([]byte("abcde"))
-
-				buffer.Close()
-
-				dest := make([]byte, 3)
-				n, err := buffer.Read(dest)
-				Ω(err).Should(HaveOccurred())
-				Ω(n).Should(Equal(0))
-			})
-		})
-	})
-
-	Describe("detecting regular expressions", func() {
-		It("should fire the appropriate channel when the passed in pattern matches, then close it", func(done Done) {
-			go func() {
-				time.Sleep(10 * time.Millisecond)
-				buffer.Write([]byte("abcde"))
-			}()
-
-			A := buffer.Detect("%s", "a.c")
-			B := buffer.Detect("def")
-
-			var gotIt bool
-			select {
-			case gotIt = <-A:
-			case <-B:
-				Fail("should not have gotten here")
-			}
-
-			Ω(gotIt).Should(BeTrue())
-			Eventually(A).Should(BeClosed())
-
-			buffer.Write([]byte("f"))
-			Eventually(B).Should(Receive())
-			Eventually(B).Should(BeClosed())
-
-			close(done)
-		})
-
-		It("should fast-forward the buffer upon detection", func(done Done) {
-			buffer.Write([]byte("abcde"))
-			<-buffer.Detect("abc")
-			Ω(buffer).ShouldNot(Say("abc"))
-			Ω(buffer).Should(Say("de"))
-			close(done)
-		})
-
-		It("should only fast-forward the buffer when the channel is read, and only if doing so would not rewind it", func(done Done) {
-			buffer.Write([]byte("abcde"))
-			A := buffer.Detect("abc")
-			time.Sleep(20 * time.Millisecond) //give the goroutine a chance to detect and write to the channel
-			Ω(buffer).Should(Say("abcd"))
-			<-A
-			Ω(buffer).ShouldNot(Say("d"))
-			Ω(buffer).Should(Say("e"))
-			Eventually(A).Should(BeClosed())
-			close(done)
-		})
-
-		It("should be possible to cancel a detection", func(done Done) {
-			A := buffer.Detect("abc")
-			B := buffer.Detect("def")
-			buffer.CancelDetects()
-			buffer.Write([]byte("abcdef"))
-			Eventually(A).Should(BeClosed())
-			Eventually(B).Should(BeClosed())
-
-			Ω(buffer).Should(Say("bcde"))
-			<-buffer.Detect("f")
-			close(done)
-		})
-	})
-
-	Describe("closing the buffer", func() {
-		It("should error when further write attempts are made", func() {
-			_, err := buffer.Write([]byte("abc"))
-			Ω(err).ShouldNot(HaveOccurred())
-
-			buffer.Close()
-
-			_, err = buffer.Write([]byte("def"))
-			Ω(err).Should(HaveOccurred())
-
-			Ω(buffer.Contents()).Should(Equal([]byte("abc")))
-		})
-
-		It("should be closed", func() {
-			Ω(buffer.Closed()).Should(BeFalse())
-
-			buffer.Close()
-
-			Ω(buffer.Closed()).Should(BeTrue())
-		})
-	})
-})
diff --git a/vendor/github.com/onsi/gomega/gbytes/gbuffer_suite_test.go b/vendor/github.com/onsi/gomega/gbytes/gbuffer_suite_test.go
deleted file mode 100644
index 3a7dc06..0000000
--- a/vendor/github.com/onsi/gomega/gbytes/gbuffer_suite_test.go
+++ /dev/null
@@ -1,13 +0,0 @@
-package gbytes_test
-
-import (
-	. "github.com/onsi/ginkgo"
-	. "github.com/onsi/gomega"
-
-	"testing"
-)
-
-func TestGbytes(t *testing.T) {
-	RegisterFailHandler(Fail)
-	RunSpecs(t, "Gbytes Suite")
-}
diff --git a/vendor/github.com/onsi/gomega/gbytes/say_matcher.go b/vendor/github.com/onsi/gomega/gbytes/say_matcher.go
deleted file mode 100644
index cbc266c..0000000
--- a/vendor/github.com/onsi/gomega/gbytes/say_matcher.go
+++ /dev/null
@@ -1,105 +0,0 @@
-package gbytes
-
-import (
-	"fmt"
-	"regexp"
-
-	"github.com/onsi/gomega/format"
-)
-
-//Objects satisfying the BufferProvider can be used with the Say matcher.
-type BufferProvider interface {
-	Buffer() *Buffer
-}
-
-/*
-Say is a Gomega matcher that operates on gbytes.Buffers:
-
-	Ω(buffer).Should(Say("something"))
-
-will succeed if the unread portion of the buffer matches the regular expression "something".
-
-When Say succeeds, it fast forwards the gbytes.Buffer's read cursor to just after the succesful match.
-Thus, subsequent calls to Say will only match against the unread portion of the buffer
-
-Say pairs very well with Eventually.  To assert that a buffer eventually receives data matching "[123]-star" within 3 seconds you can:
-
-	Eventually(buffer, 3).Should(Say("[123]-star"))
-
-Ditto with consistently.  To assert that a buffer does not receive data matching "never-see-this" for 1 second you can:
-
-	Consistently(buffer, 1).ShouldNot(Say("never-see-this"))
-
-In addition to bytes.Buffers, Say can operate on objects that implement the gbytes.BufferProvider interface.
-In such cases, Say simply operates on the *gbytes.Buffer returned by Buffer()
-
-If the buffer is closed, the Say matcher will tell Eventually to abort.
-*/
-func Say(expected string, args ...interface{}) *sayMatcher {
-	formattedRegexp := expected
-	if len(args) > 0 {
-		formattedRegexp = fmt.Sprintf(expected, args...)
-	}
-	return &sayMatcher{
-		re: regexp.MustCompile(formattedRegexp),
-	}
-}
-
-type sayMatcher struct {
-	re              *regexp.Regexp
-	receivedSayings []byte
-}
-
-func (m *sayMatcher) buffer(actual interface{}) (*Buffer, bool) {
-	var buffer *Buffer
-
-	switch x := actual.(type) {
-	case *Buffer:
-		buffer = x
-	case BufferProvider:
-		buffer = x.Buffer()
-	default:
-		return nil, false
-	}
-
-	return buffer, true
-}
-
-func (m *sayMatcher) Match(actual interface{}) (success bool, err error) {
-	buffer, ok := m.buffer(actual)
-	if !ok {
-		return false, fmt.Errorf("Say must be passed a *gbytes.Buffer or BufferProvider.  Got:\n%s", format.Object(actual, 1))
-	}
-
-	didSay, sayings := buffer.didSay(m.re)
-	m.receivedSayings = sayings
-
-	return didSay, nil
-}
-
-func (m *sayMatcher) FailureMessage(actual interface{}) (message string) {
-	return fmt.Sprintf(
-		"Got stuck at:\n%s\nWaiting for:\n%s",
-		format.IndentString(string(m.receivedSayings), 1),
-		format.IndentString(m.re.String(), 1),
-	)
-}
-
-func (m *sayMatcher) NegatedFailureMessage(actual interface{}) (message string) {
-	return fmt.Sprintf(
-		"Saw:\n%s\nWhich matches the unexpected:\n%s",
-		format.IndentString(string(m.receivedSayings), 1),
-		format.IndentString(m.re.String(), 1),
-	)
-}
-
-func (m *sayMatcher) MatchMayChangeInTheFuture(actual interface{}) bool {
-	switch x := actual.(type) {
-	case *Buffer:
-		return !x.Closed()
-	case BufferProvider:
-		return !x.Buffer().Closed()
-	default:
-		return true
-	}
-}
diff --git a/vendor/github.com/onsi/gomega/gbytes/say_matcher_test.go b/vendor/github.com/onsi/gomega/gbytes/say_matcher_test.go
deleted file mode 100644
index 63fb3b3..0000000
--- a/vendor/github.com/onsi/gomega/gbytes/say_matcher_test.go
+++ /dev/null
@@ -1,163 +0,0 @@
-package gbytes_test
-
-import (
-	. "github.com/onsi/gomega/gbytes"
-	"time"
-
-	. "github.com/onsi/ginkgo"
-	. "github.com/onsi/gomega"
-)
-
-type speaker struct {
-	buffer *Buffer
-}
-
-func (s *speaker) Buffer() *Buffer {
-	return s.buffer
-}
-
-var _ = Describe("SayMatcher", func() {
-	var buffer *Buffer
-
-	BeforeEach(func() {
-		buffer = NewBuffer()
-		buffer.Write([]byte("abc"))
-	})
-
-	Context("when actual is not a gexec Buffer, or a BufferProvider", func() {
-		It("should error", func() {
-			failures := InterceptGomegaFailures(func() {
-				Ω("foo").Should(Say("foo"))
-			})
-			Ω(failures[0]).Should(ContainSubstring("*gbytes.Buffer"))
-		})
-	})
-
-	Context("when a match is found", func() {
-		It("should succeed", func() {
-			Ω(buffer).Should(Say("abc"))
-		})
-
-		It("should support printf-like formatting", func() {
-			Ω(buffer).Should(Say("a%sc", "b"))
-		})
-
-		It("should use a regular expression", func() {
-			Ω(buffer).Should(Say("a.c"))
-		})
-
-		It("should fastforward the buffer", func() {
-			buffer.Write([]byte("def"))
-			Ω(buffer).Should(Say("abcd"))
-			Ω(buffer).Should(Say("ef"))
-			Ω(buffer).ShouldNot(Say("[a-z]"))
-		})
-	})
-
-	Context("when no match is found", func() {
-		It("should not error", func() {
-			Ω(buffer).ShouldNot(Say("def"))
-		})
-
-		Context("when the buffer is closed", func() {
-			BeforeEach(func() {
-				buffer.Close()
-			})
-
-			It("should abort an eventually", func() {
-				t := time.Now()
-				failures := InterceptGomegaFailures(func() {
-					Eventually(buffer).Should(Say("def"))
-				})
-				Eventually(buffer).ShouldNot(Say("def"))
-				Ω(time.Since(t)).Should(BeNumerically("<", 500*time.Millisecond))
-				Ω(failures).Should(HaveLen(1))
-
-				t = time.Now()
-				Eventually(buffer).Should(Say("abc"))
-				Ω(time.Since(t)).Should(BeNumerically("<", 500*time.Millisecond))
-			})
-
-			It("should abort a consistently", func() {
-				t := time.Now()
-				Consistently(buffer, 2.0).ShouldNot(Say("def"))
-				Ω(time.Since(t)).Should(BeNumerically("<", 500*time.Millisecond))
-			})
-
-			It("should not error with a synchronous matcher", func() {
-				Ω(buffer).ShouldNot(Say("def"))
-				Ω(buffer).Should(Say("abc"))
-			})
-		})
-	})
-
-	Context("when a positive match fails", func() {
-		It("should report where it got stuck", func() {
-			Ω(buffer).Should(Say("abc"))
-			buffer.Write([]byte("def"))
-			failures := InterceptGomegaFailures(func() {
-				Ω(buffer).Should(Say("abc"))
-			})
-			Ω(failures[0]).Should(ContainSubstring("Got stuck at:"))
-			Ω(failures[0]).Should(ContainSubstring("def"))
-		})
-	})
-
-	Context("when a negative match fails", func() {
-		It("should report where it got stuck", func() {
-			failures := InterceptGomegaFailures(func() {
-				Ω(buffer).ShouldNot(Say("abc"))
-			})
-			Ω(failures[0]).Should(ContainSubstring("Saw:"))
-			Ω(failures[0]).Should(ContainSubstring("Which matches the unexpected:"))
-			Ω(failures[0]).Should(ContainSubstring("abc"))
-		})
-	})
-
-	Context("when a match is not found", func() {
-		It("should not fastforward the buffer", func() {
-			Ω(buffer).ShouldNot(Say("def"))
-			Ω(buffer).Should(Say("abc"))
-		})
-	})
-
-	Context("a nice real-life example", func() {
-		It("should behave well", func() {
-			Ω(buffer).Should(Say("abc"))
-			go func() {
-				time.Sleep(10 * time.Millisecond)
-				buffer.Write([]byte("def"))
-			}()
-			Ω(buffer).ShouldNot(Say("def"))
-			Eventually(buffer).Should(Say("def"))
-		})
-	})
-
-	Context("when actual is a BufferProvider", func() {
-		It("should use actual's buffer", func() {
-			s := &speaker{
-				buffer: NewBuffer(),
-			}
-
-			Ω(s).ShouldNot(Say("abc"))
-
-			s.Buffer().Write([]byte("abc"))
-			Ω(s).Should(Say("abc"))
-		})
-
-		It("should abort an eventually", func() {
-			s := &speaker{
-				buffer: NewBuffer(),
-			}
-
-			s.buffer.Close()
-
-			t := time.Now()
-			failures := InterceptGomegaFailures(func() {
-				Eventually(s).Should(Say("def"))
-			})
-			Ω(failures).Should(HaveLen(1))
-			Ω(time.Since(t)).Should(BeNumerically("<", 500*time.Millisecond))
-		})
-	})
-})
diff --git a/vendor/github.com/onsi/gomega/gexec/_fixture/firefly/main.go b/vendor/github.com/onsi/gomega/gexec/_fixture/firefly/main.go
deleted file mode 100644
index 16091c2..0000000
--- a/vendor/github.com/onsi/gomega/gexec/_fixture/firefly/main.go
+++ /dev/null
@@ -1,36 +0,0 @@
-package main
-
-import (
-	"fmt"
-	"math/rand"
-	"os"
-	"strconv"
-	"time"
-)
-
-var outQuote = "We've done the impossible, and that makes us mighty."
-var errQuote = "Ah, curse your sudden but inevitable betrayal!"
-
-var randomQuotes = []string{
-	"Can we maybe vote on the whole murdering people issue?",
-	"I swear by my pretty floral bonnet, I will end you.",
-	"My work's illegal, but at least it's honest.",
-}
-
-func main() {
-	fmt.Fprintln(os.Stdout, outQuote)
-	fmt.Fprintln(os.Stderr, errQuote)
-
-	randomIndex := rand.New(rand.NewSource(time.Now().UnixNano())).Intn(len(randomQuotes))
-
-	time.Sleep(100 * time.Millisecond)
-
-	fmt.Fprintln(os.Stdout, randomQuotes[randomIndex])
-
-	if len(os.Args) == 2 {
-		exitCode, _ := strconv.Atoi(os.Args[1])
-		os.Exit(exitCode)
-	} else {
-		os.Exit(randomIndex)
-	}
-}
diff --git a/vendor/github.com/onsi/gomega/gexec/build.go b/vendor/github.com/onsi/gomega/gexec/build.go
deleted file mode 100644
index d11b2fd..0000000
--- a/vendor/github.com/onsi/gomega/gexec/build.go
+++ /dev/null
@@ -1,99 +0,0 @@
-package gexec
-
-import (
-	"errors"
-	"fmt"
-	"io/ioutil"
-	"os"
-	"os/exec"
-	"path"
-	"path/filepath"
-	"runtime"
-	"sync"
-)
-
-var (
-	mu     sync.Mutex
-	tmpDir string
-)
-
-/*
-Build uses go build to compile the package at packagePath.  The resulting binary is saved off in a temporary directory.
-A path pointing to this binary is returned.
-
-Build uses the $GOPATH set in your environment.  It passes the variadic args on to `go build`.
-*/
-func Build(packagePath string, args ...string) (compiledPath string, err error) {
-	return doBuild(os.Getenv("GOPATH"), packagePath, nil, args...)
-}
-
-/*
-BuildWithEnvironment is identical to Build but allows you to specify env vars to be set at build time.
-*/
-func BuildWithEnvironment(packagePath string, env []string, args ...string) (compiledPath string, err error) {
-	return doBuild(os.Getenv("GOPATH"), packagePath, env, args...)
-}
-
-/*
-BuildIn is identical to Build but allows you to specify a custom $GOPATH (the first argument).
-*/
-func BuildIn(gopath string, packagePath string, args ...string) (compiledPath string, err error) {
-	return doBuild(gopath, packagePath, nil, args...)
-}
-
-func doBuild(gopath, packagePath string, env []string, args ...string) (compiledPath string, err error) {
-	tmpDir, err := temporaryDirectory()
-	if err != nil {
-		return "", err
-	}
-
-	if len(gopath) == 0 {
-		return "", errors.New("$GOPATH not provided when building " + packagePath)
-	}
-
-	executable := filepath.Join(tmpDir, path.Base(packagePath))
-	if runtime.GOOS == "windows" {
-		executable = executable + ".exe"
-	}
-
-	cmdArgs := append([]string{"build"}, args...)
-	cmdArgs = append(cmdArgs, "-o", executable, packagePath)
-
-	build := exec.Command("go", cmdArgs...)
-	build.Env = append([]string{"GOPATH=" + gopath}, os.Environ()...)
-	build.Env = append(build.Env, env...)
-
-	output, err := build.CombinedOutput()
-	if err != nil {
-		return "", fmt.Errorf("Failed to build %s:\n\nError:\n%s\n\nOutput:\n%s", packagePath, err, string(output))
-	}
-
-	return executable, nil
-}
-
-/*
-You should call CleanupBuildArtifacts before your test ends to clean up any temporary artifacts generated by
-gexec. In Ginkgo this is typically done in an AfterSuite callback.
-*/
-func CleanupBuildArtifacts() {
-	mu.Lock()
-	defer mu.Unlock()
-	if tmpDir != "" {
-		os.RemoveAll(tmpDir)
-		tmpDir = ""
-	}
-}
-
-func temporaryDirectory() (string, error) {
-	var err error
-	mu.Lock()
-	defer mu.Unlock()
-	if tmpDir == "" {
-		tmpDir, err = ioutil.TempDir("", "gexec_artifacts")
-		if err != nil {
-			return "", err
-		}
-	}
-
-	return ioutil.TempDir(tmpDir, "g")
-}
diff --git a/vendor/github.com/onsi/gomega/gexec/build_test.go b/vendor/github.com/onsi/gomega/gexec/build_test.go
deleted file mode 100644
index 8df0790..0000000
--- a/vendor/github.com/onsi/gomega/gexec/build_test.go
+++ /dev/null
@@ -1,59 +0,0 @@
-package gexec_test
-
-import (
-	"os"
-
-	. "github.com/onsi/ginkgo"
-	. "github.com/onsi/gomega"
-	"github.com/onsi/gomega/gexec"
-)
-
-var packagePath = "./_fixture/firefly"
-
-var _ = Describe(".Build", func() {
-	Context("when there have been previous calls to Build", func() {
-		BeforeEach(func() {
-			_, err := gexec.Build(packagePath)
-			Ω(err).ShouldNot(HaveOccurred())
-		})
-
-		It("compiles the specified package", func() {
-			compiledPath, err := gexec.Build(packagePath)
-			Ω(err).ShouldNot(HaveOccurred())
-			Ω(compiledPath).Should(BeAnExistingFile())
-		})
-
-		Context("and CleanupBuildArtifacts has been called", func() {
-			BeforeEach(func() {
-				gexec.CleanupBuildArtifacts()
-			})
-
-			It("compiles the specified package", func() {
-				var err error
-				fireflyPath, err = gexec.Build(packagePath)
-				Ω(err).ShouldNot(HaveOccurred())
-				Ω(fireflyPath).Should(BeAnExistingFile())
-			})
-		})
-	})
-})
-
-var _ = Describe(".BuildWithEnvironment", func() {
-	var err error
-	env := []string{
-		"GOOS=linux",
-		"GOARCH=amd64",
-	}
-
-	It("compiles the specified package with the specified env vars", func() {
-		compiledPath, err := gexec.BuildWithEnvironment(packagePath, env)
-		Ω(err).ShouldNot(HaveOccurred())
-		Ω(compiledPath).Should(BeAnExistingFile())
-	})
-
-	It("returns the environment to a good state", func() {
-		_, err = gexec.BuildWithEnvironment(packagePath, env)
-		Ω(err).ShouldNot(HaveOccurred())
-		Ω(os.Environ()).ShouldNot(ContainElement("GOOS=linux"))
-	})
-})
diff --git a/vendor/github.com/onsi/gomega/gexec/exit_matcher.go b/vendor/github.com/onsi/gomega/gexec/exit_matcher.go
deleted file mode 100644
index e6f4329..0000000
--- a/vendor/github.com/onsi/gomega/gexec/exit_matcher.go
+++ /dev/null
@@ -1,88 +0,0 @@
-package gexec
-
-import (
-	"fmt"
-
-	"github.com/onsi/gomega/format"
-)
-
-/*
-The Exit matcher operates on a session:
-
-	Ω(session).Should(Exit(<optional status code>))
-
-Exit passes if the session has already exited.
-
-If no status code is provided, then Exit will succeed if the session has exited regardless of exit code.
-Otherwise, Exit will only succeed if the process has exited with the provided status code.
-
-Note that the process must have already exited.  To wait for a process to exit, use Eventually:
-
-	Eventually(session, 3).Should(Exit(0))
-*/
-func Exit(optionalExitCode ...int) *exitMatcher {
-	exitCode := -1
-	if len(optionalExitCode) > 0 {
-		exitCode = optionalExitCode[0]
-	}
-
-	return &exitMatcher{
-		exitCode: exitCode,
-	}
-}
-
-type exitMatcher struct {
-	exitCode       int
-	didExit        bool
-	actualExitCode int
-}
-
-type Exiter interface {
-	ExitCode() int
-}
-
-func (m *exitMatcher) Match(actual interface{}) (success bool, err error) {
-	exiter, ok := actual.(Exiter)
-	if !ok {
-		return false, fmt.Errorf("Exit must be passed a gexec.Exiter (Missing method ExitCode() int) Got:\n%s", format.Object(actual, 1))
-	}
-
-	m.actualExitCode = exiter.ExitCode()
-
-	if m.actualExitCode == -1 {
-		return false, nil
-	}
-
-	if m.exitCode == -1 {
-		return true, nil
-	}
-	return m.exitCode == m.actualExitCode, nil
-}
-
-func (m *exitMatcher) FailureMessage(actual interface{}) (message string) {
-	if m.actualExitCode == -1 {
-		return "Expected process to exit.  It did not."
-	} else {
-		return format.Message(m.actualExitCode, "to match exit code:", m.exitCode)
-	}
-}
-
-func (m *exitMatcher) NegatedFailureMessage(actual interface{}) (message string) {
-	if m.actualExitCode == -1 {
-		return "you really shouldn't be able to see this!"
-	} else {
-		if m.exitCode == -1 {
-			return "Expected process not to exit.  It did."
-		} else {
-			return format.Message(m.actualExitCode, "not to match exit code:", m.exitCode)
-		}
-	}
-}
-
-func (m *exitMatcher) MatchMayChangeInTheFuture(actual interface{}) bool {
-	session, ok := actual.(*Session)
-	if ok {
-		return session.ExitCode() == -1
-	}
-	return true
-}
diff --git a/vendor/github.com/onsi/gomega/gexec/exit_matcher_test.go b/vendor/github.com/onsi/gomega/gexec/exit_matcher_test.go
deleted file mode 100644
index 79615dd..0000000
--- a/vendor/github.com/onsi/gomega/gexec/exit_matcher_test.go
+++ /dev/null
@@ -1,113 +0,0 @@
-package gexec_test
-
-import (
-	. "github.com/onsi/gomega/gexec"
-	"os/exec"
-	"time"
-
-	. "github.com/onsi/ginkgo"
-	. "github.com/onsi/gomega"
-)
-
-type NeverExits struct{}
-
-func (e NeverExits) ExitCode() int {
-	return -1
-}
-
-var _ = Describe("ExitMatcher", func() {
-	var command *exec.Cmd
-	var session *Session
-
-	BeforeEach(func() {
-		var err error
-		command = exec.Command(fireflyPath, "0")
-		session, err = Start(command, nil, nil)
-		Ω(err).ShouldNot(HaveOccurred())
-	})
-
-	Describe("when passed something that is an Exiter", func() {
-		It("should act normally", func() {
-			failures := InterceptGomegaFailures(func() {
-				Ω(NeverExits{}).Should(Exit())
-			})
-
-			Ω(failures[0]).Should(ContainSubstring("Expected process to exit.  It did not."))
-		})
-	})
-
-	Describe("when passed something that is not an Exiter", func() {
-		It("should error", func() {
-			failures := InterceptGomegaFailures(func() {
-				Ω("aardvark").Should(Exit())
-			})
-
-			Ω(failures[0]).Should(ContainSubstring("Exit must be passed a gexec.Exiter"))
-		})
-	})
-
-	Context("with no exit code", func() {
-		It("should say the right things when it fails", func() {
-			Ω(session).ShouldNot(Exit())
-
-			failures := InterceptGomegaFailures(func() {
-				Ω(session).Should(Exit())
-			})
-
-			Ω(failures[0]).Should(ContainSubstring("Expected process to exit.  It did not."))
-
-			Eventually(session).Should(Exit())
-
-			Ω(session).Should(Exit())
-
-			failures = InterceptGomegaFailures(func() {
-				Ω(session).ShouldNot(Exit())
-			})
-
-			Ω(failures[0]).Should(ContainSubstring("Expected process not to exit.  It did."))
-		})
-	})
-
-	Context("with an exit code", func() {
-		It("should say the right things when it fails", func() {
-			Ω(session).ShouldNot(Exit(0))
-			Ω(session).ShouldNot(Exit(1))
-
-			failures := InterceptGomegaFailures(func() {
-				Ω(session).Should(Exit(0))
-			})
-
-			Ω(failures[0]).Should(ContainSubstring("Expected process to exit.  It did not."))
-
-			Eventually(session).Should(Exit(0))
-
-			Ω(session).Should(Exit(0))
-
-			failures = InterceptGomegaFailures(func() {
-				Ω(session).Should(Exit(1))
-			})
-
-			Ω(failures[0]).Should(ContainSubstring("to match exit code:"))
-
-			Ω(session).ShouldNot(Exit(1))
-
-			failures = InterceptGomegaFailures(func() {
-				Ω(session).ShouldNot(Exit(0))
-			})
-
-			Ω(failures[0]).Should(ContainSubstring("not to match exit code:"))
-		})
-	})
-
-	Describe("bailing out early", func() {
-		It("should bail out early once the process exits", func() {
-			t := time.Now()
-
-			failures := InterceptGomegaFailures(func() {
-				Eventually(session).Should(Exit(1))
-			})
-			Ω(time.Since(t)).Should(BeNumerically("<=", 500*time.Millisecond))
-			Ω(failures).Should(HaveLen(1))
-		})
-	})
-})
diff --git a/vendor/github.com/onsi/gomega/gexec/gexec_suite_test.go b/vendor/github.com/onsi/gomega/gexec/gexec_suite_test.go
deleted file mode 100644
index 87672aa..0000000
--- a/vendor/github.com/onsi/gomega/gexec/gexec_suite_test.go
+++ /dev/null
@@ -1,26 +0,0 @@
-package gexec_test
-
-import (
-	. "github.com/onsi/ginkgo"
-	. "github.com/onsi/gomega"
-	"github.com/onsi/gomega/gexec"
-
-	"testing"
-)
-
-var fireflyPath string
-
-func TestGexec(t *testing.T) {
-	BeforeSuite(func() {
-		var err error
-		fireflyPath, err = gexec.Build("./_fixture/firefly")
-		Ω(err).ShouldNot(HaveOccurred())
-	})
-
-	AfterSuite(func() {
-		gexec.CleanupBuildArtifacts()
-	})
-
-	RegisterFailHandler(Fail)
-	RunSpecs(t, "Gexec Suite")
-}
diff --git a/vendor/github.com/onsi/gomega/gexec/prefixed_writer.go b/vendor/github.com/onsi/gomega/gexec/prefixed_writer.go
deleted file mode 100644
index 05e695a..0000000
--- a/vendor/github.com/onsi/gomega/gexec/prefixed_writer.go
+++ /dev/null
@@ -1,53 +0,0 @@
-package gexec
-
-import (
-	"io"
-	"sync"
-)
-
-/*
-PrefixedWriter wraps an io.Writer, emiting the passed in prefix at the beginning of each new line.
-This can be useful when running multiple gexec.Sessions concurrently - you can prefix the log output of each
-session by passing in a PrefixedWriter:
-
-gexec.Start(cmd, NewPrefixedWriter("[my-cmd] ", GinkgoWriter), NewPrefixedWriter("[my-cmd] ", GinkgoWriter))
-*/
-type PrefixedWriter struct {
-	prefix        []byte
-	writer        io.Writer
-	lock          *sync.Mutex
-	atStartOfLine bool
-}
-
-func NewPrefixedWriter(prefix string, writer io.Writer) *PrefixedWriter {
-	return &PrefixedWriter{
-		prefix:        []byte(prefix),
-		writer:        writer,
-		lock:          &sync.Mutex{},
-		atStartOfLine: true,
-	}
-}
-
-func (w *PrefixedWriter) Write(b []byte) (int, error) {
-	w.lock.Lock()
-	defer w.lock.Unlock()
-
-	toWrite := []byte{}
-
-	for _, c := range b {
-		if w.atStartOfLine {
-			toWrite = append(toWrite, w.prefix...)
-		}
-
-		toWrite = append(toWrite, c)
-
-		w.atStartOfLine = c == '\n'
-	}
-
-	_, err := w.writer.Write(toWrite)
-	if err != nil {
-		return 0, err
-	}
-
-	return len(b), nil
-}
diff --git a/vendor/github.com/onsi/gomega/gexec/prefixed_writer_test.go b/vendor/github.com/onsi/gomega/gexec/prefixed_writer_test.go
deleted file mode 100644
index 8657d0c..0000000
--- a/vendor/github.com/onsi/gomega/gexec/prefixed_writer_test.go
+++ /dev/null
@@ -1,43 +0,0 @@
-package gexec_test
-
-import (
-	"bytes"
-
-	. "github.com/onsi/gomega/gexec"
-
-	. "github.com/onsi/ginkgo"
-	. "github.com/onsi/gomega"
-)
-
-var _ = Describe("PrefixedWriter", func() {
-	var buffer *bytes.Buffer
-	var writer *PrefixedWriter
-	BeforeEach(func() {
-		buffer = &bytes.Buffer{}
-		writer = NewPrefixedWriter("[p]", buffer)
-	})
-
-	It("should emit the prefix on newlines", func() {
-		writer.Write([]byte("abc"))
-		writer.Write([]byte("def\n"))
-		writer.Write([]byte("hij\n"))
-		writer.Write([]byte("\n\n"))
-		writer.Write([]byte("klm\n\nnop"))
-		writer.Write([]byte(""))
-		writer.Write([]byte("qrs"))
-		writer.Write([]byte("\ntuv\nwx"))
-		writer.Write([]byte("yz\n\n"))
-
-		Ω(buffer.String()).Should(Equal(`[p]abcdef
-[p]hij
-[p]
-[p]
-[p]klm
-[p]
-[p]nopqrs
-[p]tuv
-[p]wxyz
-[p]
-`))
-	})
-})
diff --git a/vendor/github.com/onsi/gomega/gexec/session.go b/vendor/github.com/onsi/gomega/gexec/session.go
deleted file mode 100644
index 387a72c..0000000
--- a/vendor/github.com/onsi/gomega/gexec/session.go
+++ /dev/null
@@ -1,305 +0,0 @@
-/*
-Package gexec provides support for testing external processes.
-*/
-package gexec
-
-import (
-	"io"
-	"os"
-	"os/exec"
-	"reflect"
-	"sync"
-	"syscall"
-
-	. "github.com/onsi/gomega"
-	"github.com/onsi/gomega/gbytes"
-)
-
-const INVALID_EXIT_CODE = 254
-
-type Session struct {
-	//The wrapped command
-	Command *exec.Cmd
-
-	//A *gbytes.Buffer connected to the command's stdout
-	Out *gbytes.Buffer
-
-	//A *gbytes.Buffer connected to the command's stderr
-	Err *gbytes.Buffer
-
-	//A channel that will close when the command exits
-	Exited <-chan struct{}
-
-	lock     *sync.Mutex
-	exitCode int
-}
-
-/*
-Start starts the passed-in *exec.Cmd command.  It wraps the command in a *gexec.Session.
-
-The session pipes the command's stdout and stderr to two *gbytes.Buffers available as properties on the session: session.Out and session.Err.
-These buffers can be used with the gbytes.Say matcher to match against unread output:
-
-	Ω(session.Out).Should(gbytes.Say("foo-out"))
-	Ω(session.Err).Should(gbytes.Say("foo-err"))
-
-In addition, Session satisfies the gbytes.BufferProvider interface and provides the stdout *gbytes.Buffer.  This allows you to replace the first line, above, with:
-
-	Ω(session).Should(gbytes.Say("foo-out"))
-
-When outWriter and/or errWriter are non-nil, the session will pipe stdout and/or stderr output both into the session *gybtes.Buffers and to the passed-in outWriter/errWriter.
-This is useful for capturing the process's output or logging it to screen.  In particular, when using Ginkgo it can be convenient to direct output to the GinkgoWriter:
-
-	session, err := Start(command, GinkgoWriter, GinkgoWriter)
-
-This will log output when running tests in verbose mode, but - otherwise - will only log output when a test fails.
-
-The session wrapper is responsible for waiting on the *exec.Cmd command.  You *should not* call command.Wait() yourself.
-Instead, to assert that the command has exited you can use the gexec.Exit matcher:
-
-	Ω(session).Should(gexec.Exit())
-
-When the session exits it closes the stdout and stderr gbytes buffers.  This will short circuit any
-Eventuallys waiting for the buffers to Say something.
-*/
-func Start(command *exec.Cmd, outWriter io.Writer, errWriter io.Writer) (*Session, error) {
-	exited := make(chan struct{})
-
-	session := &Session{
-		Command:  command,
-		Out:      gbytes.NewBuffer(),
-		Err:      gbytes.NewBuffer(),
-		Exited:   exited,
-		lock:     &sync.Mutex{},
-		exitCode: -1,
-	}
-
-	var commandOut, commandErr io.Writer
-
-	commandOut, commandErr = session.Out, session.Err
-
-	if outWriter != nil && !reflect.ValueOf(outWriter).IsNil() {
-		commandOut = io.MultiWriter(commandOut, outWriter)
-	}
-
-	if errWriter != nil && !reflect.ValueOf(errWriter).IsNil() {
-		commandErr = io.MultiWriter(commandErr, errWriter)
-	}
-
-	command.Stdout = commandOut
-	command.Stderr = commandErr
-
-	err := command.Start()
-	if err == nil {
-		go session.monitorForExit(exited)
-		trackedSessionsMutex.Lock()
-		defer trackedSessionsMutex.Unlock()
-		trackedSessions = append(trackedSessions, session)
-	}
-
-	return session, err
-}
-
-/*
-Buffer implements the gbytes.BufferProvider interface and returns s.Out
-This allows you to make gbytes.Say matcher assertions against stdout without having to reference .Out:
-
-	Eventually(session).Should(gbytes.Say("foo"))
-*/
-func (s *Session) Buffer() *gbytes.Buffer {
-	return s.Out
-}
-
-/*
-ExitCode returns the wrapped command's exit code.  If the command hasn't exited yet, ExitCode returns -1.
-
-To assert that the command has exited it is more convenient to use the Exit matcher:
-
-	Eventually(s).Should(gexec.Exit())
-
-When the process exits because it has received a particular signal, the exit code will be 128+signal-value
-(See http://www.tldp.org/LDP/abs/html/exitcodes.html and http://man7.org/linux/man-pages/man7/signal.7.html)
-
-*/
-func (s *Session) ExitCode() int {
-	s.lock.Lock()
-	defer s.lock.Unlock()
-	return s.exitCode
-}
-
-/*
-Wait waits until the wrapped command exits.  It can be passed an optional timeout.
-If the command does not exit within the timeout, Wait will trigger a test failure.
-
-Wait returns the session, making it possible to chain:
-
-	session.Wait().Out.Contents()
-
-will wait for the command to exit then return the entirety of Out's contents.
-
-Wait uses eventually under the hood and accepts the same timeout/polling intervals that eventually does.
-*/
-func (s *Session) Wait(timeout ...interface{}) *Session {
-	EventuallyWithOffset(1, s, timeout...).Should(Exit())
-	return s
-}
-
-/*
-Kill sends the running command a SIGKILL signal.  It does not wait for the process to exit.
-
-If the command has already exited, Kill returns silently.
-
-The session is returned to enable chaining.
-*/
-func (s *Session) Kill() *Session {
-	if s.ExitCode() != -1 {
-		return s
-	}
-	s.Command.Process.Kill()
-	return s
-}
-
-/*
-Interrupt sends the running command a SIGINT signal.  It does not wait for the process to exit.
-
-If the command has already exited, Interrupt returns silently.
-
-The session is returned to enable chaining.
-*/
-func (s *Session) Interrupt() *Session {
-	return s.Signal(syscall.SIGINT)
-}
-
-/*
-Terminate sends the running command a SIGTERM signal.  It does not wait for the process to exit.
-
-If the command has already exited, Terminate returns silently.
-
-The session is returned to enable chaining.
-*/
-func (s *Session) Terminate() *Session {
-	return s.Signal(syscall.SIGTERM)
-}
-
-/*
-Signal sends the running command the passed in signal.  It does not wait for the process to exit.
-
-If the command has already exited, Signal returns silently.
-
-The session is returned to enable chaining.
-*/
-func (s *Session) Signal(signal os.Signal) *Session {
-	if s.ExitCode() != -1 {
-		return s
-	}
-	s.Command.Process.Signal(signal)
-	return s
-}
-
-func (s *Session) monitorForExit(exited chan<- struct{}) {
-	err := s.Command.Wait()
-	s.lock.Lock()
-	s.Out.Close()
-	s.Err.Close()
-	status := s.Command.ProcessState.Sys().(syscall.WaitStatus)
-	if status.Signaled() {
-		s.exitCode = 128 + int(status.Signal())
-	} else {
-		exitStatus := status.ExitStatus()
-		if exitStatus == -1 && err != nil {
-			s.exitCode = INVALID_EXIT_CODE
-		}
-		s.exitCode = exitStatus
-	}
-	s.lock.Unlock()
-
-	close(exited)
-}
-
-var trackedSessions = []*Session{}
-var trackedSessionsMutex = &sync.Mutex{}
-
-/*
-Kill sends a SIGKILL signal to all the processes started by Run, and waits for them to exit.
-The timeout specified is applied to each process killed.
-
-If any of the processes already exited, KillAndWait returns silently.
-*/
-func KillAndWait(timeout ...interface{}) {
-	trackedSessionsMutex.Lock()
-	defer trackedSessionsMutex.Unlock()
-	for _, session := range trackedSessions {
-		session.Kill().Wait(timeout...)
-	}
-	trackedSessions = []*Session{}
-}
-
-/*
-Kill sends a SIGTERM signal to all the processes started by Run, and waits for them to exit.
-The timeout specified is applied to each process killed.
-
-If any of the processes already exited, TerminateAndWait returns silently.
-*/
-func TerminateAndWait(timeout ...interface{}) {
-	trackedSessionsMutex.Lock()
-	defer trackedSessionsMutex.Unlock()
-	for _, session := range trackedSessions {
-		session.Terminate().Wait(timeout...)
-	}
-}
-
-/*
-Kill sends a SIGKILL signal to all the processes started by Run.
-It does not wait for the processes to exit.
-
-If any of the processes already exited, Kill returns silently.
-*/
-func Kill() {
-	trackedSessionsMutex.Lock()
-	defer trackedSessionsMutex.Unlock()
-	for _, session := range trackedSessions {
-		session.Kill()
-	}
-}
-
-/*
-Terminate sends a SIGTERM signal to all the processes started by Run.
-It does not wait for the processes to exit.
-
-If any of the processes already exited, Terminate returns silently.
-*/
-func Terminate() {
-	trackedSessionsMutex.Lock()
-	defer trackedSessionsMutex.Unlock()
-	for _, session := range trackedSessions {
-		session.Terminate()
-	}
-}
-
-/*
-Signal sends the passed in signal to all the processes started by Run.
-It does not wait for the processes to exit.
-
-If any of the processes already exited, Signal returns silently.
-*/
-func Signal(signal os.Signal) {
-	trackedSessionsMutex.Lock()
-	defer trackedSessionsMutex.Unlock()
-	for _, session := range trackedSessions {
-		session.Signal(signal)
-	}
-}
-
-/*
-Interrupt sends the SIGINT signal to all the processes started by Run.
-It does not wait for the processes to exit.
-
-If any of the processes already exited, Interrupt returns silently.
-*/
-func Interrupt() {
-	trackedSessionsMutex.Lock()
-	defer trackedSessionsMutex.Unlock()
-	for _, session := range trackedSessions {
-		session.Interrupt()
-	}
-}
diff --git a/vendor/github.com/onsi/gomega/gexec/session_test.go b/vendor/github.com/onsi/gomega/gexec/session_test.go
deleted file mode 100644
index b7841a0..0000000
--- a/vendor/github.com/onsi/gomega/gexec/session_test.go
+++ /dev/null
@@ -1,351 +0,0 @@
-package gexec_test
-
-import (
-	"os/exec"
-	"syscall"
-	"time"
-
-	. "github.com/onsi/gomega/gbytes"
-	. "github.com/onsi/gomega/gexec"
-
-	. "github.com/onsi/ginkgo"
-	. "github.com/onsi/gomega"
-)
-
-var _ = Describe("Session", func() {
-	var command *exec.Cmd
-	var session *Session
-
-	var outWriter, errWriter *Buffer
-
-	BeforeEach(func() {
-		outWriter = nil
-		errWriter = nil
-	})
-
-	JustBeforeEach(func() {
-		command = exec.Command(fireflyPath)
-		var err error
-		session, err = Start(command, outWriter, errWriter)
-		Ω(err).ShouldNot(HaveOccurred())
-	})
-
-	Context("running a command", func() {
-		It("should start the process", func() {
-			Ω(command.Process).ShouldNot(BeNil())
-		})
-
-		It("should wrap the process's stdout and stderr with gbytes buffers", func(done Done) {
-			Eventually(session.Out).Should(Say("We've done the impossible, and that makes us mighty"))
-			Eventually(session.Err).Should(Say("Ah, curse your sudden but inevitable betrayal!"))
-			defer session.Out.CancelDetects()
-
-			select {
-			case <-session.Out.Detect("Can we maybe vote on the whole murdering people issue"):
-				Eventually(session).Should(Exit(0))
-			case <-session.Out.Detect("I swear by my pretty floral bonnet, I will end you."):
-				Eventually(session).Should(Exit(1))
-			case <-session.Out.Detect("My work's illegal, but at least it's honest."):
-				Eventually(session).Should(Exit(2))
-			}
-
-			close(done)
-		})
-
-		It("should satisfy the gbytes.BufferProvider interface, passing Stdout", func() {
-			Eventually(session).Should(Say("We've done the impossible, and that makes us mighty"))
-			Eventually(session).Should(Exit())
-		})
-	})
-
-	Describe("providing the exit code", func() {
-		It("should provide the app's exit code", func() {
-			Ω(session.ExitCode()).Should(Equal(-1))
-
-			Eventually(session).Should(Exit())
-			Ω(session.ExitCode()).Should(BeNumerically(">=", 0))
-			Ω(session.ExitCode()).Should(BeNumerically("<", 3))
-		})
-	})
-
-	Describe("wait", func() {
-		It("should wait till the command exits", func() {
-			Ω(session.ExitCode()).Should(Equal(-1))
-			Ω(session.Wait().ExitCode()).Should(BeNumerically(">=", 0))
-			Ω(session.Wait().ExitCode()).Should(BeNumerically("<", 3))
-		})
-	})
-
-	Describe("exited", func() {
-		It("should close when the command exits", func() {
-			Eventually(session.Exited).Should(BeClosed())
-			Ω(session.ExitCode()).ShouldNot(Equal(-1))
-		})
-	})
-
-	Describe("kill", func() {
-		It("should kill the command and don't wait for it to exit", func() {
-			session, err := Start(exec.Command("sleep", "10000000"), GinkgoWriter, GinkgoWriter)
-			Ω(err).ShouldNot(HaveOccurred())
-
-			session.Kill()
-			Ω(session).ShouldNot(Exit(), "Should not exit immediately...")
-			Eventually(session).Should(Exit(128 + 9))
-		})
-	})
-
-	Describe("interrupt", func() {
-		It("should interrupt the command", func() {
-			session, err := Start(exec.Command("sleep", "10000000"), GinkgoWriter, GinkgoWriter)
-			Ω(err).ShouldNot(HaveOccurred())
-
-			session.Interrupt()
-			Ω(session).ShouldNot(Exit(), "Should not exit immediately...")
-			Eventually(session).Should(Exit(128 + 2))
-		})
-	})
-
-	Describe("terminate", func() {
-		It("should terminate the command", func() {
-			session, err := Start(exec.Command("sleep", "10000000"), GinkgoWriter, GinkgoWriter)
-			Ω(err).ShouldNot(HaveOccurred())
-
-			session.Terminate()
-			Ω(session).ShouldNot(Exit(), "Should not exit immediately...")
-			Eventually(session).Should(Exit(128 + 15))
-		})
-	})
-
-	Describe("signal", func() {
-		It("should send the signal to the command", func() {
-			session, err := Start(exec.Command("sleep", "10000000"), GinkgoWriter, GinkgoWriter)
-			Ω(err).ShouldNot(HaveOccurred())
-
-			session.Signal(syscall.SIGABRT)
-			Ω(session).ShouldNot(Exit(), "Should not exit immediately...")
-			Eventually(session).Should(Exit(128 + 6))
-		})
-	})
-
-	Context("tracking sessions", func() {
-		BeforeEach(func() {
-			KillAndWait()
-		})
-
-		Describe("kill", func() {
-			It("should kill all the started sessions", func() {
-				session1, err := Start(exec.Command("sleep", "10000000"), GinkgoWriter, GinkgoWriter)
-				Ω(err).ShouldNot(HaveOccurred())
-
-				session2, err := Start(exec.Command("sleep", "10000000"), GinkgoWriter, GinkgoWriter)
-				Ω(err).ShouldNot(HaveOccurred())
-
-				session3, err := Start(exec.Command("sleep", "10000000"), GinkgoWriter, GinkgoWriter)
-				Ω(err).ShouldNot(HaveOccurred())
-
-				Kill()
-
-				Eventually(session1).Should(Exit(128 + 9))
-				Eventually(session2).Should(Exit(128 + 9))
-				Eventually(session3).Should(Exit(128 + 9))
-			})
-
-			It("should not wait for exit", func() {
-				session1, err := Start(exec.Command("sleep", "10000000"), GinkgoWriter, GinkgoWriter)
-				Ω(err).ShouldNot(HaveOccurred())
-
-				Kill()
-				Ω(session1).ShouldNot(Exit(), "Should not exit immediately...")
-
-				Eventually(session1).Should(Exit(128 + 9))
-			})
-
-			It("should not track unstarted sessions", func() {
-				_, err := Start(exec.Command("does not exist", "10000000"), GinkgoWriter, GinkgoWriter)
-				Ω(err).Should(HaveOccurred())
-
-				session2, err := Start(exec.Command("sleep", "10000000"), GinkgoWriter, GinkgoWriter)
-				Ω(err).ShouldNot(HaveOccurred())
-
-				session3, err := Start(exec.Command("sleep", "10000000"), GinkgoWriter, GinkgoWriter)
-				Ω(err).ShouldNot(HaveOccurred())
-
-				Kill()
-
-				Eventually(session2).Should(Exit(128 + 9))
-				Eventually(session3).Should(Exit(128 + 9))
-			})
-
-		})
-
-		Describe("killAndWait", func() {
-			It("should kill all the started sessions and wait for them to finish", func() {
-				session1, err := Start(exec.Command("sleep", "10000000"), GinkgoWriter, GinkgoWriter)
-				Ω(err).ShouldNot(HaveOccurred())
-
-				session2, err := Start(exec.Command("sleep", "10000000"), GinkgoWriter, GinkgoWriter)
-				Ω(err).ShouldNot(HaveOccurred())
-
-				session3, err := Start(exec.Command("sleep", "10000000"), GinkgoWriter, GinkgoWriter)
-				Ω(err).ShouldNot(HaveOccurred())
-
-				KillAndWait()
-				Ω(session1).Should(Exit(128+9), "Should have exited")
-				Ω(session2).Should(Exit(128+9), "Should have exited")
-				Ω(session3).Should(Exit(128+9), "Should have exited")
-			})
-		})
-
-		Describe("terminate", func() {
-			It("should terminate all the started sessions", func() {
-				session1, err := Start(exec.Command("sleep", "10000000"), GinkgoWriter, GinkgoWriter)
-				Ω(err).ShouldNot(HaveOccurred())
-
-				session2, err := Start(exec.Command("sleep", "10000000"), GinkgoWriter, GinkgoWriter)
-				Ω(err).ShouldNot(HaveOccurred())
-
-				session3, err := Start(exec.Command("sleep", "10000000"), GinkgoWriter, GinkgoWriter)
-				Ω(err).ShouldNot(HaveOccurred())
-
-				Terminate()
-
-				Eventually(session1).Should(Exit(128 + 15))
-				Eventually(session2).Should(Exit(128 + 15))
-				Eventually(session3).Should(Exit(128 + 15))
-			})
-
-			It("should not wait for exit", func() {
-				session1, err := Start(exec.Command("sleep", "10000000"), GinkgoWriter, GinkgoWriter)
-				Ω(err).ShouldNot(HaveOccurred())
-
-				Terminate()
-
-				Ω(session1).ShouldNot(Exit(), "Should not exit immediately...")
-			})
-		})
-
-		Describe("terminateAndWait", func() {
-			It("should terminate all the started sessions, and wait for them to exit", func() {
-				session1, err := Start(exec.Command("sleep", "10000000"), GinkgoWriter, GinkgoWriter)
-				Ω(err).ShouldNot(HaveOccurred())
-
-				session2, err := Start(exec.Command("sleep", "10000000"), GinkgoWriter, GinkgoWriter)
-				Ω(err).ShouldNot(HaveOccurred())
-
-				session3, err := Start(exec.Command("sleep", "10000000"), GinkgoWriter, GinkgoWriter)
-				Ω(err).ShouldNot(HaveOccurred())
-
-				TerminateAndWait()
-
-				Ω(session1).Should(Exit(128+15), "Should have exited")
-				Ω(session2).Should(Exit(128+15), "Should have exited")
-				Ω(session3).Should(Exit(128+15), "Should have exited")
-			})
-		})
-
-		Describe("signal", func() {
-			It("should signal all the started sessions", func() {
-				session1, err := Start(exec.Command("sleep", "10000000"), GinkgoWriter, GinkgoWriter)
-				Ω(err).ShouldNot(HaveOccurred())
-
-				session2, err := Start(exec.Command("sleep", "10000000"), GinkgoWriter, GinkgoWriter)
-				Ω(err).ShouldNot(HaveOccurred())
-
-				session3, err := Start(exec.Command("sleep", "10000000"), GinkgoWriter, GinkgoWriter)
-				Ω(err).ShouldNot(HaveOccurred())
-
-				Signal(syscall.SIGABRT)
-
-				Eventually(session1).Should(Exit(128 + 6))
-				Eventually(session2).Should(Exit(128 + 6))
-				Eventually(session3).Should(Exit(128 + 6))
-			})
-
-			It("should not wait", func() {
-				session1, err := Start(exec.Command("sleep", "10000000"), GinkgoWriter, GinkgoWriter)
-				Ω(err).ShouldNot(HaveOccurred())
-
-				Signal(syscall.SIGABRT)
-
-				Ω(session1).ShouldNot(Exit(), "Should not exit immediately...")
-			})
-		})
-
-		Describe("interrupt", func() {
-			It("should interrupt all the started sessions, and not wait", func() {
-				session1, err := Start(exec.Command("sleep", "10000000"), GinkgoWriter, GinkgoWriter)
-				Ω(err).ShouldNot(HaveOccurred())
-
-				session2, err := Start(exec.Command("sleep", "10000000"), GinkgoWriter, GinkgoWriter)
-				Ω(err).ShouldNot(HaveOccurred())
-
-				session3, err := Start(exec.Command("sleep", "10000000"), GinkgoWriter, GinkgoWriter)
-				Ω(err).ShouldNot(HaveOccurred())
-
-				Interrupt()
-
-				Eventually(session1).Should(Exit(128 + 2))
-				Eventually(session2).Should(Exit(128 + 2))
-				Eventually(session3).Should(Exit(128 + 2))
-			})
-
-			It("should not wait", func() {
-				session1, err := Start(exec.Command("sleep", "10000000"), GinkgoWriter, GinkgoWriter)
-				Ω(err).ShouldNot(HaveOccurred())
-
-				Interrupt()
-
-				Ω(session1).ShouldNot(Exit(), "Should not exit immediately...")
-			})
-		})
-	})
-
-	Context("when the command exits", func() {
-		It("should close the buffers", func() {
-			Eventually(session).Should(Exit())
-
-			Ω(session.Out.Closed()).Should(BeTrue())
-			Ω(session.Err.Closed()).Should(BeTrue())
-
-			Ω(session.Out).Should(Say("We've done the impossible, and that makes us mighty"))
-		})
-
-		var So = It
-
-		So("this means that eventually should short circuit", func() {
-			t := time.Now()
-			failures := InterceptGomegaFailures(func() {
-				Eventually(session).Should(Say("blah blah blah blah blah"))
-			})
-			Ω(time.Since(t)).Should(BeNumerically("<=", 500*time.Millisecond))
-			Ω(failures).Should(HaveLen(1))
-		})
-	})
-
-	Context("when wrapping out and err", func() {
-		BeforeEach(func() {
-			outWriter = NewBuffer()
-			errWriter = NewBuffer()
-		})
-
-		It("should route to both the provided writers and the gbytes buffers", func() {
-			Eventually(session.Out).Should(Say("We've done the impossible, and that makes us mighty"))
-			Eventually(session.Err).Should(Say("Ah, curse your sudden but inevitable betrayal!"))
-
-			Ω(outWriter.Contents()).Should(ContainSubstring("We've done the impossible, and that makes us mighty"))
-			Ω(errWriter.Contents()).Should(ContainSubstring("Ah, curse your sudden but inevitable betrayal!"))
-
-			Eventually(session).Should(Exit())
-
-			Ω(outWriter.Contents()).Should(Equal(session.Out.Contents()))
-			Ω(errWriter.Contents()).Should(Equal(session.Err.Contents()))
-		})
-	})
-
-	Describe("when the command fails to start", func() {
-		It("should return an error", func() {
-			_, err := Start(exec.Command("agklsjdfas"), nil, nil)
-			Ω(err).Should(HaveOccurred())
-		})
-	})
-})
diff --git a/vendor/github.com/onsi/gomega/ghttp/handlers.go b/vendor/github.com/onsi/gomega/ghttp/handlers.go
deleted file mode 100644
index 63ff691..0000000
--- a/vendor/github.com/onsi/gomega/ghttp/handlers.go
+++ /dev/null
@@ -1,313 +0,0 @@
-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)
-	}
-}
diff --git a/vendor/github.com/onsi/gomega/ghttp/protobuf/protobuf.go b/vendor/github.com/onsi/gomega/ghttp/protobuf/protobuf.go
deleted file mode 100644
index b2972bc..0000000
--- a/vendor/github.com/onsi/gomega/ghttp/protobuf/protobuf.go
+++ /dev/null
@@ -1,3 +0,0 @@
-package protobuf
-
-//go:generate protoc --go_out=. simple_message.proto
diff --git a/vendor/github.com/onsi/gomega/ghttp/protobuf/simple_message.pb.go b/vendor/github.com/onsi/gomega/ghttp/protobuf/simple_message.pb.go
deleted file mode 100644
index c55a484..0000000
--- a/vendor/github.com/onsi/gomega/ghttp/protobuf/simple_message.pb.go
+++ /dev/null
@@ -1,55 +0,0 @@
-// 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 ""
-}
diff --git a/vendor/github.com/onsi/gomega/ghttp/protobuf/simple_message.proto b/vendor/github.com/onsi/gomega/ghttp/protobuf/simple_message.proto
deleted file mode 100644
index 35b7145..0000000
--- a/vendor/github.com/onsi/gomega/ghttp/protobuf/simple_message.proto
+++ /dev/null
@@ -1,9 +0,0 @@
-syntax = "proto2";
-
-package protobuf;
-
-message SimpleMessage {
-    required string description = 1;
-    required int32 id = 2;
-    optional string metadata = 3;
-}
diff --git a/vendor/github.com/onsi/gomega/ghttp/test_server.go b/vendor/github.com/onsi/gomega/ghttp/test_server.go
deleted file mode 100644
index 40d92de..0000000
--- a/vendor/github.com/onsi/gomega/ghttp/test_server.go
+++ /dev/null
@@ -1,381 +0,0 @@
-/*
-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()
-	server := s.HTTPTestServer
-	s.HTTPTestServer = nil
-	s.writeLock.Unlock()
-
-	if server != 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 assertion 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()
-}
diff --git a/vendor/github.com/onsi/gomega/ghttp/test_server_suite_test.go b/vendor/github.com/onsi/gomega/ghttp/test_server_suite_test.go
deleted file mode 100644
index 7c12360..0000000
--- a/vendor/github.com/onsi/gomega/ghttp/test_server_suite_test.go
+++ /dev/null
@@ -1,13 +0,0 @@
-package ghttp_test
-
-import (
-	. "github.com/onsi/ginkgo"
-	. "github.com/onsi/gomega"
-
-	"testing"
-)
-
-func TestGHTTP(t *testing.T) {
-	RegisterFailHandler(Fail)
-	RunSpecs(t, "GHTTP Suite")
-}
diff --git a/vendor/github.com/onsi/gomega/ghttp/test_server_test.go b/vendor/github.com/onsi/gomega/ghttp/test_server_test.go
deleted file mode 100644
index 88b3246..0000000
--- a/vendor/github.com/onsi/gomega/ghttp/test_server_test.go
+++ /dev/null
@@ -1,1089 +0,0 @@
-package ghttp_test
-
-import (
-	"bytes"
-	"io"
-	"io/ioutil"
-	"net/http"
-	"net/url"
-	"regexp"
-
-	"github.com/golang/protobuf/proto"
-	"github.com/onsi/gomega/gbytes"
-	"github.com/onsi/gomega/ghttp/protobuf"
-
-	. "github.com/onsi/ginkgo"
-	. "github.com/onsi/gomega"
-	. "github.com/onsi/gomega/ghttp"
-)
-
-var _ = Describe("TestServer", func() {
-	var (
-		resp *http.Response
-		err  error
-		s    *Server
-	)
-
-	BeforeEach(func() {
-		s = NewServer()
-	})
-
-	AfterEach(func() {
-		s.Close()
-	})
-
-	Describe("Resetting the server", func() {
-		BeforeEach(func() {
-			s.RouteToHandler("GET", "/", func(w http.ResponseWriter, req *http.Request) {})
-			s.AppendHandlers(func(w http.ResponseWriter, req *http.Request) {})
-			http.Get(s.URL() + "/")
-
-			Ω(s.ReceivedRequests()).Should(HaveLen(1))
-		})
-
-		It("clears all handlers and call counts", func() {
-			s.Reset()
-			Ω(s.ReceivedRequests()).Should(HaveLen(0))
-			Ω(func() { s.GetHandler(0) }).Should(Panic())
-		})
-	})
-
-	Describe("closing client connections", func() {
-		It("closes", func() {
-			s.RouteToHandler("GET", "/",
-				func(w http.ResponseWriter, req *http.Request) {
-					io.WriteString(w, req.RemoteAddr)
-				},
-			)
-			client := http.Client{Transport: &http.Transport{DisableKeepAlives: true}}
-			resp, err := client.Get(s.URL())
-			Ω(err).ShouldNot(HaveOccurred())
-			Ω(resp.StatusCode).Should(Equal(200))
-
-			body, err := ioutil.ReadAll(resp.Body)
-			resp.Body.Close()
-			Ω(err).ShouldNot(HaveOccurred())
-
-			s.CloseClientConnections()
-
-			resp, err = client.Get(s.URL())
-			Ω(err).ShouldNot(HaveOccurred())
-			Ω(resp.StatusCode).Should(Equal(200))
-
-			body2, err := ioutil.ReadAll(resp.Body)
-			resp.Body.Close()
-			Ω(err).ShouldNot(HaveOccurred())
-
-			Ω(body2).ShouldNot(Equal(body))
-		})
-	})
-
-	Describe("closing server mulitple times", func() {
-		It("should not fail", func() {
-			s.Close()
-			Ω(s.Close).ShouldNot(Panic())
-		})
-	})
-
-	Describe("allowing unhandled requests", func() {
-		Context("when true", func() {
-			BeforeEach(func() {
-				s.AllowUnhandledRequests = true
-				s.UnhandledRequestStatusCode = http.StatusForbidden
-				resp, err = http.Get(s.URL() + "/foo")
-				Ω(err).ShouldNot(HaveOccurred())
-			})
-
-			It("should allow unhandled requests and respond with the passed in status code", func() {
-				Ω(err).ShouldNot(HaveOccurred())
-				Ω(resp.StatusCode).Should(Equal(http.StatusForbidden))
-
-				data, err := ioutil.ReadAll(resp.Body)
-				Ω(err).ShouldNot(HaveOccurred())
-				Ω(data).Should(BeEmpty())
-			})
-
-			It("should record the requests", func() {
-				Ω(s.ReceivedRequests()).Should(HaveLen(1))
-				Ω(s.ReceivedRequests()[0].URL.Path).Should(Equal("/foo"))
-			})
-		})
-
-		Context("when false", func() {
-			It("should fail when attempting a request", func() {
-				failures := InterceptGomegaFailures(func() {
-					http.Get(s.URL() + "/foo")
-				})
-
-				Ω(failures[0]).Should(ContainSubstring("Received Unhandled Request"))
-			})
-		})
-	})
-
-	Describe("Managing Handlers", func() {
-		var called []string
-		BeforeEach(func() {
-			called = []string{}
-			s.RouteToHandler("GET", "/routed", func(w http.ResponseWriter, req *http.Request) {
-				called = append(called, "r1")
-			})
-			s.RouteToHandler("POST", regexp.MustCompile(`/routed\d`), func(w http.ResponseWriter, req *http.Request) {
-				called = append(called, "r2")
-			})
-			s.AppendHandlers(func(w http.ResponseWriter, req *http.Request) {
-				called = append(called, "A")
-			}, func(w http.ResponseWriter, req *http.Request) {
-				called = append(called, "B")
-			})
-		})
-
-		It("should prefer routed handlers if there is a match", func() {
-			http.Get(s.URL() + "/routed")
-			http.Post(s.URL()+"/routed7", "application/json", nil)
-			http.Get(s.URL() + "/foo")
-			http.Get(s.URL() + "/routed")
-			http.Post(s.URL()+"/routed9", "application/json", nil)
-			http.Get(s.URL() + "/bar")
-
-			failures := InterceptGomegaFailures(func() {
-				http.Get(s.URL() + "/foo")
-				http.Get(s.URL() + "/routed/not/a/match")
-				http.Get(s.URL() + "/routed7")
-				http.Post(s.URL()+"/routed", "application/json", nil)
-			})
-
-			Ω(failures[0]).Should(ContainSubstring("Received Unhandled Request"))
-			Ω(failures).Should(HaveLen(4))
-
-			http.Post(s.URL()+"/routed3", "application/json", nil)
-
-			Ω(called).Should(Equal([]string{"r1", "r2", "A", "r1", "r2", "B", "r2"}))
-		})
-
-		It("should override routed handlers when reregistered", func() {
-			s.RouteToHandler("GET", "/routed", func(w http.ResponseWriter, req *http.Request) {
-				called = append(called, "r3")
-			})
-			s.RouteToHandler("POST", regexp.MustCompile(`/routed\d`), func(w http.ResponseWriter, req *http.Request) {
-				called = append(called, "r4")
-			})
-
-			http.Get(s.URL() + "/routed")
-			http.Post(s.URL()+"/routed7", "application/json", nil)
-
-			Ω(called).Should(Equal([]string{"r3", "r4"}))
-		})
-
-		It("should call the appended handlers, in order, as requests come in", func() {
-			http.Get(s.URL() + "/foo")
-			Ω(called).Should(Equal([]string{"A"}))
-
-			http.Get(s.URL() + "/foo")
-			Ω(called).Should(Equal([]string{"A", "B"}))
-
-			failures := InterceptGomegaFailures(func() {
-				http.Get(s.URL() + "/foo")
-			})
-
-			Ω(failures[0]).Should(ContainSubstring("Received Unhandled Request"))
-		})
-
-		Describe("Overwriting an existing handler", func() {
-			BeforeEach(func() {
-				s.SetHandler(0, func(w http.ResponseWriter, req *http.Request) {
-					called = append(called, "C")
-				})
-			})
-
-			It("should override the specified handler", func() {
-				http.Get(s.URL() + "/foo")
-				http.Get(s.URL() + "/foo")
-				Ω(called).Should(Equal([]string{"C", "B"}))
-			})
-		})
-
-		Describe("Getting an existing handler", func() {
-			It("should return the handler func", func() {
-				s.GetHandler(1)(nil, nil)
-				Ω(called).Should(Equal([]string{"B"}))
-			})
-		})
-
-		Describe("Wrapping an existing handler", func() {
-			BeforeEach(func() {
-				s.WrapHandler(0, func(w http.ResponseWriter, req *http.Request) {
-					called = append(called, "C")
-				})
-			})
-
-			It("should wrap the existing handler in a new handler", func() {
-				http.Get(s.URL() + "/foo")
-				http.Get(s.URL() + "/foo")
-				Ω(called).Should(Equal([]string{"A", "C", "B"}))
-			})
-		})
-	})
-
-	Describe("When a handler fails", func() {
-		BeforeEach(func() {
-			s.UnhandledRequestStatusCode = http.StatusForbidden //just to be clear that 500s aren't coming from unhandled requests
-		})
-
-		Context("because the handler has panicked", func() {
-			BeforeEach(func() {
-				s.AppendHandlers(func(w http.ResponseWriter, req *http.Request) {
-					panic("bam")
-				})
-			})
-
-			It("should respond with a 500 and make a failing assertion", func() {
-				var resp *http.Response
-				var err error
-
-				failures := InterceptGomegaFailures(func() {
-					resp, err = http.Get(s.URL())
-				})
-
-				Ω(err).ShouldNot(HaveOccurred())
-				Ω(resp.StatusCode).Should(Equal(http.StatusInternalServerError))
-				Ω(failures).Should(ConsistOf(ContainSubstring("Handler Panicked")))
-			})
-		})
-
-		Context("because an assertion has failed", func() {
-			BeforeEach(func() {
-				s.AppendHandlers(func(w http.ResponseWriter, req *http.Request) {
-					// Ω(true).Should(BeFalse()) <-- would be nice to do it this way, but the test just can't be written this way
-
-					By("We're cheating a bit here -- we're throwing a GINKGO_PANIC which simulates a failed assertion")
-					panic(GINKGO_PANIC)
-				})
-			})
-
-			It("should respond with a 500 and *not* make a failing assertion, instead relying on Ginkgo to have already been notified of the error", func() {
-				resp, err := http.Get(s.URL())
-
-				Ω(err).ShouldNot(HaveOccurred())
-				Ω(resp.StatusCode).Should(Equal(http.StatusInternalServerError))
-			})
-		})
-	})
-
-	Describe("Logging to the Writer", func() {
-		var buf *gbytes.Buffer
-		BeforeEach(func() {
-			buf = gbytes.NewBuffer()
-			s.Writer = buf
-			s.AppendHandlers(func(w http.ResponseWriter, req *http.Request) {})
-			s.AppendHandlers(func(w http.ResponseWriter, req *http.Request) {})
-		})
-
-		It("should write to the buffer when a request comes in", func() {
-			http.Get(s.URL() + "/foo")
-			Ω(buf).Should(gbytes.Say("GHTTP Received Request: GET - /foo\n"))
-
-			http.Post(s.URL()+"/bar", "", nil)
-			Ω(buf).Should(gbytes.Say("GHTTP Received Request: POST - /bar\n"))
-		})
-	})
-
-	Describe("Request Handlers", func() {
-		Describe("VerifyRequest", func() {
-			BeforeEach(func() {
-				s.AppendHandlers(VerifyRequest("GET", "/foo"))
-			})
-
-			It("should verify the method, path", func() {
-				resp, err = http.Get(s.URL() + "/foo?baz=bar")
-				Ω(err).ShouldNot(HaveOccurred())
-			})
-
-			It("should verify the method, path", func() {
-				failures := InterceptGomegaFailures(func() {
-					http.Get(s.URL() + "/foo2")
-				})
-				Ω(failures).Should(HaveLen(1))
-			})
-
-			It("should verify the method, path", func() {
-				failures := InterceptGomegaFailures(func() {
-					http.Post(s.URL()+"/foo", "application/json", nil)
-				})
-				Ω(failures).Should(HaveLen(1))
-			})
-
-			Context("when passed a rawQuery", func() {
-				It("should also be possible to verify the rawQuery", func() {
-					s.SetHandler(0, VerifyRequest("GET", "/foo", "baz=bar"))
-					resp, err = http.Get(s.URL() + "/foo?baz=bar")
-					Ω(err).ShouldNot(HaveOccurred())
-				})
-
-				It("should match irregardless of query parameter ordering", func() {
-					s.SetHandler(0, VerifyRequest("GET", "/foo", "type=get&name=money"))
-					u, _ := url.Parse(s.URL() + "/foo")
-					u.RawQuery = url.Values{
-						"type": []string{"get"},
-						"name": []string{"money"},
-					}.Encode()
-
-					resp, err = http.Get(u.String())
-					Ω(err).ShouldNot(HaveOccurred())
-				})
-			})
-
-			Context("when passed a matcher for path", func() {
-				It("should apply the matcher", func() {
-					s.SetHandler(0, VerifyRequest("GET", MatchRegexp(`/foo/[a-f]*/3`)))
-					resp, err = http.Get(s.URL() + "/foo/abcdefa/3")
-					Ω(err).ShouldNot(HaveOccurred())
-				})
-			})
-		})
-
-		Describe("VerifyContentType", func() {
-			BeforeEach(func() {
-				s.AppendHandlers(CombineHandlers(
-					VerifyRequest("GET", "/foo"),
-					VerifyContentType("application/octet-stream"),
-				))
-			})
-
-			It("should verify the content type", func() {
-				req, err := http.NewRequest("GET", s.URL()+"/foo", nil)
-				Ω(err).ShouldNot(HaveOccurred())
-				req.Header.Set("Content-Type", "application/octet-stream")
-
-				resp, err = http.DefaultClient.Do(req)
-				Ω(err).ShouldNot(HaveOccurred())
-			})
-
-			It("should verify the content type", func() {
-				req, err := http.NewRequest("GET", s.URL()+"/foo", nil)
-				Ω(err).ShouldNot(HaveOccurred())
-				req.Header.Set("Content-Type", "application/json")
-
-				failures := InterceptGomegaFailures(func() {
-					http.DefaultClient.Do(req)
-				})
-				Ω(failures).Should(HaveLen(1))
-			})
-		})
-
-		Describe("Verify BasicAuth", func() {
-			BeforeEach(func() {
-				s.AppendHandlers(CombineHandlers(
-					VerifyRequest("GET", "/foo"),
-					VerifyBasicAuth("bob", "password"),
-				))
-			})
-
-			It("should verify basic auth", func() {
-				req, err := http.NewRequest("GET", s.URL()+"/foo", nil)
-				Ω(err).ShouldNot(HaveOccurred())
-				req.SetBasicAuth("bob", "password")
-
-				resp, err = http.DefaultClient.Do(req)
-				Ω(err).ShouldNot(HaveOccurred())
-			})
-
-			It("should verify basic auth", func() {
-				req, err := http.NewRequest("GET", s.URL()+"/foo", nil)
-				Ω(err).ShouldNot(HaveOccurred())
-				req.SetBasicAuth("bob", "bassword")
-
-				failures := InterceptGomegaFailures(func() {
-					http.DefaultClient.Do(req)
-				})
-				Ω(failures).Should(HaveLen(1))
-			})
-
-			It("should require basic auth header", func() {
-				req, err := http.NewRequest("GET", s.URL()+"/foo", nil)
-				Ω(err).ShouldNot(HaveOccurred())
-
-				failures := InterceptGomegaFailures(func() {
-					http.DefaultClient.Do(req)
-				})
-				Ω(failures).Should(ContainElement(ContainSubstring("Authorization header must be specified")))
-			})
-		})
-
-		Describe("VerifyHeader", func() {
-			BeforeEach(func() {
-				s.AppendHandlers(CombineHandlers(
-					VerifyRequest("GET", "/foo"),
-					VerifyHeader(http.Header{
-						"accept":        []string{"jpeg", "png"},
-						"cache-control": []string{"omicron"},
-						"Return-Path":   []string{"hobbiton"},
-					}),
-				))
-			})
-
-			It("should verify the headers", func() {
-				req, err := http.NewRequest("GET", s.URL()+"/foo", nil)
-				Ω(err).ShouldNot(HaveOccurred())
-				req.Header.Add("Accept", "jpeg")
-				req.Header.Add("Accept", "png")
-				req.Header.Add("Cache-Control", "omicron")
-				req.Header.Add("return-path", "hobbiton")
-
-				resp, err = http.DefaultClient.Do(req)
-				Ω(err).ShouldNot(HaveOccurred())
-			})
-
-			It("should verify the headers", func() {
-				req, err := http.NewRequest("GET", s.URL()+"/foo", nil)
-				Ω(err).ShouldNot(HaveOccurred())
-				req.Header.Add("Schmaccept", "jpeg")
-				req.Header.Add("Schmaccept", "png")
-				req.Header.Add("Cache-Control", "omicron")
-				req.Header.Add("return-path", "hobbiton")
-
-				failures := InterceptGomegaFailures(func() {
-					http.DefaultClient.Do(req)
-				})
-				Ω(failures).Should(HaveLen(1))
-			})
-		})
-
-		Describe("VerifyHeaderKV", func() {
-			BeforeEach(func() {
-				s.AppendHandlers(CombineHandlers(
-					VerifyRequest("GET", "/foo"),
-					VerifyHeaderKV("accept", "jpeg", "png"),
-					VerifyHeaderKV("cache-control", "omicron"),
-					VerifyHeaderKV("Return-Path", "hobbiton"),
-				))
-			})
-
-			It("should verify the headers", func() {
-				req, err := http.NewRequest("GET", s.URL()+"/foo", nil)
-				Ω(err).ShouldNot(HaveOccurred())
-				req.Header.Add("Accept", "jpeg")
-				req.Header.Add("Accept", "png")
-				req.Header.Add("Cache-Control", "omicron")
-				req.Header.Add("return-path", "hobbiton")
-
-				resp, err = http.DefaultClient.Do(req)
-				Ω(err).ShouldNot(HaveOccurred())
-			})
-
-			It("should verify the headers", func() {
-				req, err := http.NewRequest("GET", s.URL()+"/foo", nil)
-				Ω(err).ShouldNot(HaveOccurred())
-				req.Header.Add("Accept", "jpeg")
-				req.Header.Add("Cache-Control", "omicron")
-				req.Header.Add("return-path", "hobbiton")
-
-				failures := InterceptGomegaFailures(func() {
-					http.DefaultClient.Do(req)
-				})
-				Ω(failures).Should(HaveLen(1))
-			})
-		})
-
-		Describe("VerifyBody", func() {
-			BeforeEach(func() {
-				s.AppendHandlers(CombineHandlers(
-					VerifyRequest("POST", "/foo"),
-					VerifyBody([]byte("some body")),
-				))
-			})
-
-			It("should verify the body", func() {
-				resp, err = http.Post(s.URL()+"/foo", "", bytes.NewReader([]byte("some body")))
-				Ω(err).ShouldNot(HaveOccurred())
-			})
-
-			It("should verify the body", func() {
-				failures := InterceptGomegaFailures(func() {
-					http.Post(s.URL()+"/foo", "", bytes.NewReader([]byte("wrong body")))
-				})
-				Ω(failures).Should(HaveLen(1))
-			})
-		})
-
-		Describe("VerifyJSON", func() {
-			BeforeEach(func() {
-				s.AppendHandlers(CombineHandlers(
-					VerifyRequest("POST", "/foo"),
-					VerifyJSON(`{"a":3, "b":2}`),
-				))
-			})
-
-			It("should verify the json body and the content type", func() {
-				resp, err = http.Post(s.URL()+"/foo", "application/json", bytes.NewReader([]byte(`{"b":2, "a":3}`)))
-				Ω(err).ShouldNot(HaveOccurred())
-			})
-
-			It("should verify the json body and the content type", func() {
-				failures := InterceptGomegaFailures(func() {
-					http.Post(s.URL()+"/foo", "application/json", bytes.NewReader([]byte(`{"b":2, "a":4}`)))
-				})
-				Ω(failures).Should(HaveLen(1))
-			})
-
-			It("should verify the json body and the content type", func() {
-				failures := InterceptGomegaFailures(func() {
-					http.Post(s.URL()+"/foo", "application/not-json", bytes.NewReader([]byte(`{"b":2, "a":3}`)))
-				})
-				Ω(failures).Should(HaveLen(1))
-			})
-		})
-
-		Describe("VerifyJSONRepresenting", func() {
-			BeforeEach(func() {
-				s.AppendHandlers(CombineHandlers(
-					VerifyRequest("POST", "/foo"),
-					VerifyJSONRepresenting([]int{1, 3, 5}),
-				))
-			})
-
-			It("should verify the json body and the content type", func() {
-				resp, err = http.Post(s.URL()+"/foo", "application/json", bytes.NewReader([]byte(`[1,3,5]`)))
-				Ω(err).ShouldNot(HaveOccurred())
-			})
-
-			It("should verify the json body and the content type", func() {
-				failures := InterceptGomegaFailures(func() {
-					http.Post(s.URL()+"/foo", "application/json", bytes.NewReader([]byte(`[1,3]`)))
-				})
-				Ω(failures).Should(HaveLen(1))
-			})
-		})
-
-		Describe("VerifyForm", func() {
-			var formValues url.Values
-
-			BeforeEach(func() {
-				formValues = make(url.Values)
-				formValues.Add("users", "user1")
-				formValues.Add("users", "user2")
-				formValues.Add("group", "users")
-			})
-
-			Context("when encoded in the URL", func() {
-				BeforeEach(func() {
-					s.AppendHandlers(CombineHandlers(
-						VerifyRequest("GET", "/foo"),
-						VerifyForm(url.Values{
-							"users": []string{"user1", "user2"},
-							"group": []string{"users"},
-						}),
-					))
-				})
-
-				It("should verify form values", func() {
-					resp, err = http.Get(s.URL() + "/foo?" + formValues.Encode())
-					Ω(err).ShouldNot(HaveOccurred())
-				})
-
-				It("should ignore extra values", func() {
-					formValues.Add("extra", "value")
-					resp, err = http.Get(s.URL() + "/foo?" + formValues.Encode())
-					Ω(err).ShouldNot(HaveOccurred())
-				})
-
-				It("fail on missing values", func() {
-					formValues.Del("group")
-					failures := InterceptGomegaFailures(func() {
-						resp, err = http.Get(s.URL() + "/foo?" + formValues.Encode())
-					})
-					Ω(failures).Should(HaveLen(1))
-				})
-
-				It("fail on incorrect values", func() {
-					formValues.Set("group", "wheel")
-					failures := InterceptGomegaFailures(func() {
-						resp, err = http.Get(s.URL() + "/foo?" + formValues.Encode())
-					})
-					Ω(failures).Should(HaveLen(1))
-				})
-			})
-
-			Context("when present in the body", func() {
-				BeforeEach(func() {
-					s.AppendHandlers(CombineHandlers(
-						VerifyRequest("POST", "/foo"),
-						VerifyForm(url.Values{
-							"users": []string{"user1", "user2"},
-							"group": []string{"users"},
-						}),
-					))
-				})
-
-				It("should verify form values", func() {
-					resp, err = http.PostForm(s.URL()+"/foo", formValues)
-					Ω(err).ShouldNot(HaveOccurred())
-				})
-
-				It("should ignore extra values", func() {
-					formValues.Add("extra", "value")
-					resp, err = http.PostForm(s.URL()+"/foo", formValues)
-					Ω(err).ShouldNot(HaveOccurred())
-				})
-
-				It("fail on missing values", func() {
-					formValues.Del("group")
-					failures := InterceptGomegaFailures(func() {
-						resp, err = http.PostForm(s.URL()+"/foo", formValues)
-					})
-					Ω(failures).Should(HaveLen(1))
-				})
-
-				It("fail on incorrect values", func() {
-					formValues.Set("group", "wheel")
-					failures := InterceptGomegaFailures(func() {
-						resp, err = http.PostForm(s.URL()+"/foo", formValues)
-					})
-					Ω(failures).Should(HaveLen(1))
-				})
-			})
-		})
-
-		Describe("VerifyFormKV", func() {
-			Context("when encoded in the URL", func() {
-				BeforeEach(func() {
-					s.AppendHandlers(CombineHandlers(
-						VerifyRequest("GET", "/foo"),
-						VerifyFormKV("users", "user1", "user2"),
-					))
-				})
-
-				It("verifies the form value", func() {
-					resp, err = http.Get(s.URL() + "/foo?users=user1&users=user2")
-					Ω(err).ShouldNot(HaveOccurred())
-				})
-
-				It("verifies the form value", func() {
-					failures := InterceptGomegaFailures(func() {
-						resp, err = http.Get(s.URL() + "/foo?users=user1")
-					})
-					Ω(failures).Should(HaveLen(1))
-				})
-			})
-
-			Context("when present in the body", func() {
-				BeforeEach(func() {
-					s.AppendHandlers(CombineHandlers(
-						VerifyRequest("POST", "/foo"),
-						VerifyFormKV("users", "user1", "user2"),
-					))
-				})
-
-				It("verifies the form value", func() {
-					resp, err = http.PostForm(s.URL()+"/foo", url.Values{"users": []string{"user1", "user2"}})
-					Ω(err).ShouldNot(HaveOccurred())
-				})
-
-				It("verifies the form value", func() {
-					failures := InterceptGomegaFailures(func() {
-						resp, err = http.PostForm(s.URL()+"/foo", url.Values{"users": []string{"user1"}})
-					})
-					Ω(failures).Should(HaveLen(1))
-				})
-			})
-		})
-
-		Describe("VerifyProtoRepresenting", func() {
-			var message *protobuf.SimpleMessage
-
-			BeforeEach(func() {
-				message = new(protobuf.SimpleMessage)
-				message.Description = proto.String("A description")
-				message.Id = proto.Int32(0)
-
-				s.AppendHandlers(CombineHandlers(
-					VerifyRequest("POST", "/proto"),
-					VerifyProtoRepresenting(message),
-				))
-			})
-
-			It("verifies the proto body and the content type", func() {
-				serialized, err := proto.Marshal(message)
-				Ω(err).ShouldNot(HaveOccurred())
-
-				resp, err = http.Post(s.URL()+"/proto", "application/x-protobuf", bytes.NewReader(serialized))
-				Ω(err).ShouldNot(HaveOccurred())
-			})
-
-			It("should verify the proto body and the content type", func() {
-				serialized, err := proto.Marshal(&protobuf.SimpleMessage{
-					Description: proto.String("A description"),
-					Id:          proto.Int32(0),
-					Metadata:    proto.String("some metadata"),
-				})
-				Ω(err).ShouldNot(HaveOccurred())
-
-				failures := InterceptGomegaFailures(func() {
-					http.Post(s.URL()+"/proto", "application/x-protobuf", bytes.NewReader(serialized))
-				})
-				Ω(failures).Should(HaveLen(1))
-			})
-
-			It("should verify the proto body and the content type", func() {
-				serialized, err := proto.Marshal(message)
-				Ω(err).ShouldNot(HaveOccurred())
-
-				failures := InterceptGomegaFailures(func() {
-					http.Post(s.URL()+"/proto", "application/not-x-protobuf", bytes.NewReader(serialized))
-				})
-				Ω(failures).Should(HaveLen(1))
-			})
-		})
-
-		Describe("RespondWith", func() {
-			Context("without headers", func() {
-				BeforeEach(func() {
-					s.AppendHandlers(CombineHandlers(
-						VerifyRequest("POST", "/foo"),
-						RespondWith(http.StatusCreated, "sweet"),
-					), CombineHandlers(
-						VerifyRequest("POST", "/foo"),
-						RespondWith(http.StatusOK, []byte("sour")),
-					))
-				})
-
-				It("should return the response", func() {
-					resp, err = http.Post(s.URL()+"/foo", "application/json", nil)
-					Ω(err).ShouldNot(HaveOccurred())
-
-					Ω(resp.StatusCode).Should(Equal(http.StatusCreated))
-
-					body, err := ioutil.ReadAll(resp.Body)
-					Ω(err).ShouldNot(HaveOccurred())
-					Ω(body).Should(Equal([]byte("sweet")))
-
-					resp, err = http.Post(s.URL()+"/foo", "application/json", nil)
-					Ω(err).ShouldNot(HaveOccurred())
-
-					Ω(resp.StatusCode).Should(Equal(http.StatusOK))
-
-					body, err = ioutil.ReadAll(resp.Body)
-					Ω(err).ShouldNot(HaveOccurred())
-					Ω(body).Should(Equal([]byte("sour")))
-				})
-			})
-
-			Context("with headers", func() {
-				BeforeEach(func() {
-					s.AppendHandlers(CombineHandlers(
-						VerifyRequest("POST", "/foo"),
-						RespondWith(http.StatusCreated, "sweet", http.Header{"X-Custom-Header": []string{"my header"}}),
-					))
-				})
-
-				It("should return the headers too", func() {
-					resp, err = http.Post(s.URL()+"/foo", "application/json", nil)
-					Ω(err).ShouldNot(HaveOccurred())
-
-					Ω(resp.StatusCode).Should(Equal(http.StatusCreated))
-					Ω(ioutil.ReadAll(resp.Body)).Should(Equal([]byte("sweet")))
-					Ω(resp.Header.Get("X-Custom-Header")).Should(Equal("my header"))
-				})
-			})
-		})
-
-		Describe("RespondWithPtr", func() {
-			var code int
-			var byteBody []byte
-			var stringBody string
-			BeforeEach(func() {
-				code = http.StatusOK
-				byteBody = []byte("sweet")
-				stringBody = "sour"
-
-				s.AppendHandlers(CombineHandlers(
-					VerifyRequest("POST", "/foo"),
-					RespondWithPtr(&code, &byteBody),
-				), CombineHandlers(
-					VerifyRequest("POST", "/foo"),
-					RespondWithPtr(&code, &stringBody),
-				))
-			})
-
-			It("should return the response", func() {
-				code = http.StatusCreated
-				byteBody = []byte("tasty")
-				stringBody = "treat"
-
-				resp, err = http.Post(s.URL()+"/foo", "application/json", nil)
-				Ω(err).ShouldNot(HaveOccurred())
-
-				Ω(resp.StatusCode).Should(Equal(http.StatusCreated))
-
-				body, err := ioutil.ReadAll(resp.Body)
-				Ω(err).ShouldNot(HaveOccurred())
-				Ω(body).Should(Equal([]byte("tasty")))
-
-				resp, err = http.Post(s.URL()+"/foo", "application/json", nil)
-				Ω(err).ShouldNot(HaveOccurred())
-
-				Ω(resp.StatusCode).Should(Equal(http.StatusCreated))
-
-				body, err = ioutil.ReadAll(resp.Body)
-				Ω(err).ShouldNot(HaveOccurred())
-				Ω(body).Should(Equal([]byte("treat")))
-			})
-
-			Context("when passed a nil body", func() {
-				BeforeEach(func() {
-					s.SetHandler(0, CombineHandlers(
-						VerifyRequest("POST", "/foo"),
-						RespondWithPtr(&code, nil),
-					))
-				})
-
-				It("should return an empty body and not explode", func() {
-					resp, err = http.Post(s.URL()+"/foo", "application/json", nil)
-
-					Ω(err).ShouldNot(HaveOccurred())
-					Ω(resp.StatusCode).Should(Equal(http.StatusOK))
-					body, err := ioutil.ReadAll(resp.Body)
-					Ω(err).ShouldNot(HaveOccurred())
-					Ω(body).Should(BeEmpty())
-
-					Ω(s.ReceivedRequests()).Should(HaveLen(1))
-				})
-			})
-		})
-
-		Describe("RespondWithJSON", func() {
-			Context("when no optional headers are set", func() {
-				BeforeEach(func() {
-					s.AppendHandlers(CombineHandlers(
-						VerifyRequest("POST", "/foo"),
-						RespondWithJSONEncoded(http.StatusCreated, []int{1, 2, 3}),
-					))
-				})
-
-				It("should return the response", func() {
-					resp, err = http.Post(s.URL()+"/foo", "application/json", nil)
-					Ω(err).ShouldNot(HaveOccurred())
-
-					Ω(resp.StatusCode).Should(Equal(http.StatusCreated))
-
-					body, err := ioutil.ReadAll(resp.Body)
-					Ω(err).ShouldNot(HaveOccurred())
-					Ω(body).Should(MatchJSON("[1,2,3]"))
-				})
-
-				It("should set the Content-Type header to application/json", func() {
-					resp, err = http.Post(s.URL()+"/foo", "application/json", nil)
-					Ω(err).ShouldNot(HaveOccurred())
-
-					Ω(resp.Header["Content-Type"]).Should(Equal([]string{"application/json"}))
-				})
-			})
-
-			Context("when optional headers are set", func() {
-				var headers http.Header
-				BeforeEach(func() {
-					headers = http.Header{"Stuff": []string{"things"}}
-				})
-
-				JustBeforeEach(func() {
-					s.AppendHandlers(CombineHandlers(
-						VerifyRequest("POST", "/foo"),
-						RespondWithJSONEncoded(http.StatusCreated, []int{1, 2, 3}, headers),
-					))
-				})
-
-				It("should preserve those headers", func() {
-					resp, err = http.Post(s.URL()+"/foo", "application/json", nil)
-					Ω(err).ShouldNot(HaveOccurred())
-
-					Ω(resp.Header["Stuff"]).Should(Equal([]string{"things"}))
-				})
-
-				It("should set the Content-Type header to application/json", func() {
-					resp, err = http.Post(s.URL()+"/foo", "application/json", nil)
-					Ω(err).ShouldNot(HaveOccurred())
-
-					Ω(resp.Header["Content-Type"]).Should(Equal([]string{"application/json"}))
-				})
-
-				Context("when setting the Content-Type explicitly", func() {
-					BeforeEach(func() {
-						headers["Content-Type"] = []string{"not-json"}
-					})
-
-					It("should use the Content-Type header that was explicitly set", func() {
-						resp, err = http.Post(s.URL()+"/foo", "application/json", nil)
-						Ω(err).ShouldNot(HaveOccurred())
-
-						Ω(resp.Header["Content-Type"]).Should(Equal([]string{"not-json"}))
-					})
-				})
-			})
-		})
-
-		Describe("RespondWithJSONPtr", func() {
-			type testObject struct {
-				Key   string
-				Value string
-			}
-
-			var code int
-			var object testObject
-
-			Context("when no optional headers are set", func() {
-				BeforeEach(func() {
-					code = http.StatusOK
-					object = testObject{}
-					s.AppendHandlers(CombineHandlers(
-						VerifyRequest("POST", "/foo"),
-						RespondWithJSONEncodedPtr(&code, &object),
-					))
-				})
-
-				It("should return the response", func() {
-					code = http.StatusCreated
-					object = testObject{
-						Key:   "Jim",
-						Value: "Codes",
-					}
-					resp, err = http.Post(s.URL()+"/foo", "application/json", nil)
-					Ω(err).ShouldNot(HaveOccurred())
-
-					Ω(resp.StatusCode).Should(Equal(http.StatusCreated))
-
-					body, err := ioutil.ReadAll(resp.Body)
-					Ω(err).ShouldNot(HaveOccurred())
-					Ω(body).Should(MatchJSON(`{"Key": "Jim", "Value": "Codes"}`))
-				})
-
-				It("should set the Content-Type header to application/json", func() {
-					resp, err = http.Post(s.URL()+"/foo", "application/json", nil)
-					Ω(err).ShouldNot(HaveOccurred())
-
-					Ω(resp.Header["Content-Type"]).Should(Equal([]string{"application/json"}))
-				})
-			})
-
-			Context("when optional headers are set", func() {
-				var headers http.Header
-				BeforeEach(func() {
-					headers = http.Header{"Stuff": []string{"things"}}
-				})
-
-				JustBeforeEach(func() {
-					code = http.StatusOK
-					object = testObject{}
-					s.AppendHandlers(CombineHandlers(
-						VerifyRequest("POST", "/foo"),
-						RespondWithJSONEncodedPtr(&code, &object, headers),
-					))
-				})
-
-				It("should preserve those headers", func() {
-					resp, err = http.Post(s.URL()+"/foo", "application/json", nil)
-					Ω(err).ShouldNot(HaveOccurred())
-
-					Ω(resp.Header["Stuff"]).Should(Equal([]string{"things"}))
-				})
-
-				It("should set the Content-Type header to application/json", func() {
-					resp, err = http.Post(s.URL()+"/foo", "application/json", nil)
-					Ω(err).ShouldNot(HaveOccurred())
-
-					Ω(resp.Header["Content-Type"]).Should(Equal([]string{"application/json"}))
-				})
-
-				Context("when setting the Content-Type explicitly", func() {
-					BeforeEach(func() {
-						headers["Content-Type"] = []string{"not-json"}
-					})
-
-					It("should use the Content-Type header that was explicitly set", func() {
-						resp, err = http.Post(s.URL()+"/foo", "application/json", nil)
-						Ω(err).ShouldNot(HaveOccurred())
-
-						Ω(resp.Header["Content-Type"]).Should(Equal([]string{"not-json"}))
-					})
-				})
-			})
-		})
-
-		Describe("RespondWithProto", func() {
-			var message *protobuf.SimpleMessage
-
-			BeforeEach(func() {
-				message = new(protobuf.SimpleMessage)
-				message.Description = proto.String("A description")
-				message.Id = proto.Int32(99)
-			})
-
-			Context("when no optional headers are set", func() {
-				BeforeEach(func() {
-					s.AppendHandlers(CombineHandlers(
-						VerifyRequest("POST", "/proto"),
-						RespondWithProto(http.StatusCreated, message),
-					))
-				})
-
-				It("should return the response", func() {
-					resp, err = http.Post(s.URL()+"/proto", "application/x-protobuf", nil)
-					Ω(err).ShouldNot(HaveOccurred())
-
-					Ω(resp.StatusCode).Should(Equal(http.StatusCreated))
-
-					var received protobuf.SimpleMessage
-					body, err := ioutil.ReadAll(resp.Body)
-					err = proto.Unmarshal(body, &received)
-					Ω(err).ShouldNot(HaveOccurred())
-				})
-
-				It("should set the Content-Type header to application/x-protobuf", func() {
-					resp, err = http.Post(s.URL()+"/proto", "application/x-protobuf", nil)
-					Ω(err).ShouldNot(HaveOccurred())
-
-					Ω(resp.Header["Content-Type"]).Should(Equal([]string{"application/x-protobuf"}))
-				})
-			})
-
-			Context("when optional headers are set", func() {
-				var headers http.Header
-				BeforeEach(func() {
-					headers = http.Header{"Stuff": []string{"things"}}
-				})
-
-				JustBeforeEach(func() {
-					s.AppendHandlers(CombineHandlers(
-						VerifyRequest("POST", "/proto"),
-						RespondWithProto(http.StatusCreated, message, headers),
-					))
-				})
-
-				It("should preserve those headers", func() {
-					resp, err = http.Post(s.URL()+"/proto", "application/x-protobuf", nil)
-					Ω(err).ShouldNot(HaveOccurred())
-
-					Ω(resp.Header["Stuff"]).Should(Equal([]string{"things"}))
-				})
-
-				It("should set the Content-Type header to application/x-protobuf", func() {
-					resp, err = http.Post(s.URL()+"/proto", "application/x-protobuf", nil)
-					Ω(err).ShouldNot(HaveOccurred())
-
-					Ω(resp.Header["Content-Type"]).Should(Equal([]string{"application/x-protobuf"}))
-				})
-
-				Context("when setting the Content-Type explicitly", func() {
-					BeforeEach(func() {
-						headers["Content-Type"] = []string{"not-x-protobuf"}
-					})
-
-					It("should use the Content-Type header that was explicitly set", func() {
-						resp, err = http.Post(s.URL()+"/proto", "application/x-protobuf", nil)
-						Ω(err).ShouldNot(HaveOccurred())
-
-						Ω(resp.Header["Content-Type"]).Should(Equal([]string{"not-x-protobuf"}))
-					})
-				})
-			})
-		})
-	})
-})
diff --git a/vendor/github.com/onsi/gomega/gstruct/elements.go b/vendor/github.com/onsi/gomega/gstruct/elements.go
deleted file mode 100644
index a315fa1..0000000
--- a/vendor/github.com/onsi/gomega/gstruct/elements.go
+++ /dev/null
@@ -1,145 +0,0 @@
-package gstruct
-
-import (
-	"errors"
-	"fmt"
-	"reflect"
-	"runtime/debug"
-
-	"github.com/onsi/gomega/format"
-	errorsutil "github.com/onsi/gomega/gstruct/errors"
-	"github.com/onsi/gomega/types"
-)
-
-//MatchAllElements succeeds if every element of a slice matches the element matcher it maps to
-//through the id function, and every element matcher is matched.
-//  Expect([]string{"a", "b"}).To(MatchAllElements(idFn, matchers.Elements{
-//      "a": BeEqual("a"),
-//      "b": BeEqual("b"),
-//  })
-func MatchAllElements(identifier Identifier, elements Elements) types.GomegaMatcher {
-	return &ElementsMatcher{
-		Identifier: identifier,
-		Elements:   elements,
-	}
-}
-
-//MatchElements succeeds if each element of a slice matches the element matcher it maps to
-//through the id function. It can ignore extra elements and/or missing elements.
-//  Expect([]string{"a", "c"}).To(MatchElements(idFn, IgnoreMissing|IgnoreExtra, matchers.Elements{
-//      "a": BeEqual("a")
-//      "b": BeEqual("b"),
-//  })
-func MatchElements(identifier Identifier, options Options, elements Elements) types.GomegaMatcher {
-	return &ElementsMatcher{
-		Identifier:      identifier,
-		Elements:        elements,
-		IgnoreExtras:    options&IgnoreExtras != 0,
-		IgnoreMissing:   options&IgnoreMissing != 0,
-		AllowDuplicates: options&AllowDuplicates != 0,
-	}
-}
-
-// ElementsMatcher is a NestingMatcher that applies custom matchers to each element of a slice mapped
-// by the Identifier function.
-// TODO: Extend this to work with arrays & maps (map the key) as well.
-type ElementsMatcher struct {
-	// Matchers for each element.
-	Elements Elements
-	// Function mapping an element to the string key identifying its matcher.
-	Identifier Identifier
-
-	// Whether to ignore extra elements or consider it an error.
-	IgnoreExtras bool
-	// Whether to ignore missing elements or consider it an error.
-	IgnoreMissing bool
-	// Whether to key duplicates when matching IDs.
-	AllowDuplicates bool
-
-	// State.
-	failures []error
-}
-
-// Element ID to matcher.
-type Elements map[string]types.GomegaMatcher
-
-// Function for identifying (mapping) elements.
-type Identifier func(element interface{}) string
-
-func (m *ElementsMatcher) Match(actual interface{}) (success bool, err error) {
-	if reflect.TypeOf(actual).Kind() != reflect.Slice {
-		return false, fmt.Errorf("%v is type %T, expected slice", actual, actual)
-	}
-
-	m.failures = m.matchElements(actual)
-	if len(m.failures) > 0 {
-		return false, nil
-	}
-	return true, nil
-}
-
-func (m *ElementsMatcher) matchElements(actual interface{}) (errs []error) {
-	// Provide more useful error messages in the case of a panic.
-	defer func() {
-		if err := recover(); err != nil {
-			errs = append(errs, fmt.Errorf("panic checking %+v: %v\n%s", actual, err, debug.Stack()))
-		}
-	}()
-
-	val := reflect.ValueOf(actual)
-	elements := map[string]bool{}
-	for i := 0; i < val.Len(); i++ {
-		element := val.Index(i).Interface()
-		id := m.Identifier(element)
-		if elements[id] {
-			if !m.AllowDuplicates {
-				errs = append(errs, fmt.Errorf("found duplicate element ID %s", id))
-				continue
-			}
-		}
-		elements[id] = true
-
-		matcher, expected := m.Elements[id]
-		if !expected {
-			if !m.IgnoreExtras {
-				errs = append(errs, fmt.Errorf("unexpected element %s", id))
-			}
-			continue
-		}
-
-		match, err := matcher.Match(element)
-		if match {
-			continue
-		}
-
-		if err == nil {
-			if nesting, ok := matcher.(errorsutil.NestingMatcher); ok {
-				err = errorsutil.AggregateError(nesting.Failures())
-			} else {
-				err = errors.New(matcher.FailureMessage(element))
-			}
-		}
-		errs = append(errs, errorsutil.Nest(fmt.Sprintf("[%s]", id), err))
-	}
-
-	for id := range m.Elements {
-		if !elements[id] && !m.IgnoreMissing {
-			errs = append(errs, fmt.Errorf("missing expected element %s", id))
-		}
-	}
-
-	return errs
-}
-
-func (m *ElementsMatcher) FailureMessage(actual interface{}) (message string) {
-	failure := errorsutil.AggregateError(m.failures)
-	return format.Message(actual, fmt.Sprintf("to match elements: %v", failure))
-}
-
-func (m *ElementsMatcher) NegatedFailureMessage(actual interface{}) (message string) {
-	return format.Message(actual, "not to match elements")
-}
-
-func (m *ElementsMatcher) Failures() []error {
-	return m.failures
-}
diff --git a/vendor/github.com/onsi/gomega/gstruct/elements_test.go b/vendor/github.com/onsi/gomega/gstruct/elements_test.go
deleted file mode 100644
index 8ba78cb..0000000
--- a/vendor/github.com/onsi/gomega/gstruct/elements_test.go
+++ /dev/null
@@ -1,144 +0,0 @@
-package gstruct_test
-
-import (
-	. "github.com/onsi/ginkgo"
-	. "github.com/onsi/gomega"
-	. "github.com/onsi/gomega/gstruct"
-)
-
-var _ = Describe("Slice", func() {
-	allElements := []string{"a", "b"}
-	missingElements := []string{"a"}
-	extraElements := []string{"a", "b", "c"}
-	duplicateElements := []string{"a", "a", "b"}
-	empty := []string{}
-	var nils []string
-
-	It("should strictly match all elements", func() {
-		m := MatchAllElements(id, Elements{
-			"b": Equal("b"),
-			"a": Equal("a"),
-		})
-		Ω(allElements).Should(m, "should match all elements")
-		Ω(missingElements).ShouldNot(m, "should fail with missing elements")
-		Ω(extraElements).ShouldNot(m, "should fail with extra elements")
-		Ω(duplicateElements).ShouldNot(m, "should fail with duplicate elements")
-		Ω(nils).ShouldNot(m, "should fail with an uninitialized slice")
-
-		m = MatchAllElements(id, Elements{
-			"a": Equal("a"),
-			"b": Equal("fail"),
-		})
-		Ω(allElements).ShouldNot(m, "should run nested matchers")
-
-		m = MatchAllElements(id, Elements{})
-		Ω(empty).Should(m, "should handle empty slices")
-		Ω(allElements).ShouldNot(m, "should handle only empty slices")
-		Ω(nils).Should(m, "should handle nil slices")
-	})
-
-	It("should ignore extra elements", func() {
-		m := MatchElements(id, IgnoreExtras, Elements{
-			"b": Equal("b"),
-			"a": Equal("a"),
-		})
-		Ω(allElements).Should(m, "should match all elements")
-		Ω(missingElements).ShouldNot(m, "should fail with missing elements")
-		Ω(extraElements).Should(m, "should ignore extra elements")
-		Ω(duplicateElements).ShouldNot(m, "should fail with duplicate elements")
-		Ω(nils).ShouldNot(m, "should fail with an uninitialized slice")
-	})
-
-	It("should ignore missing elements", func() {
-		m := MatchElements(id, IgnoreMissing, Elements{
-			"a": Equal("a"),
-			"b": Equal("b"),
-		})
-		Ω(allElements).Should(m, "should match all elements")
-		Ω(missingElements).Should(m, "should ignore missing elements")
-		Ω(extraElements).ShouldNot(m, "should fail with extra elements")
-		Ω(duplicateElements).ShouldNot(m, "should fail with duplicate elements")
-		Ω(nils).Should(m, "should ignore an uninitialized slice")
-	})
-
-	It("should ignore missing and extra elements", func() {
-		m := MatchElements(id, IgnoreMissing|IgnoreExtras, Elements{
-			"a": Equal("a"),
-			"b": Equal("b"),
-		})
-		Ω(allElements).Should(m, "should match all elements")
-		Ω(missingElements).Should(m, "should ignore missing elements")
-		Ω(extraElements).Should(m, "should ignore extra elements")
-		Ω(duplicateElements).ShouldNot(m, "should fail with duplicate elements")
-		Ω(nils).Should(m, "should ignore an uninitialized slice")
-
-		m = MatchElements(id, IgnoreExtras|IgnoreMissing, Elements{
-			"a": Equal("a"),
-			"b": Equal("fail"),
-		})
-		Ω(allElements).ShouldNot(m, "should run nested matchers")
-	})
-
-	Context("with elements that share a key", func() {
-		nonUniqueID := func(element interface{}) string {
-			return element.(string)[0:1]
-		}
-
-		allElements := []string{"a123", "a213", "b321"}
-		includingBadElements := []string{"a123", "b123", "b5555"}
-		extraElements := []string{"a123", "b1234", "c345"}
-		missingElements := []string{"b123", "b1234", "b1345"}
-
-		It("should strictly allow multiple matches", func() {
-			m := MatchElements(nonUniqueID, AllowDuplicates, Elements{
-				"a": ContainSubstring("1"),
-				"b": ContainSubstring("1"),
-			})
-			Ω(allElements).Should(m, "should match all elements")
-			Ω(includingBadElements).ShouldNot(m, "should reject if a member fails the matcher")
-			Ω(extraElements).ShouldNot(m, "should reject with extra keys")
-			Ω(missingElements).ShouldNot(m, "should reject with missing keys")
-			Ω(nils).ShouldNot(m, "should fail with an uninitialized slice")
-		})
-
-		It("should ignore missing", func() {
-			m := MatchElements(nonUniqueID, AllowDuplicates|IgnoreMissing, Elements{
-				"a": ContainSubstring("1"),
-				"b": ContainSubstring("1"),
-			})
-			Ω(allElements).Should(m, "should match all elements")
-			Ω(includingBadElements).ShouldNot(m, "should reject if a member fails the matcher")
-			Ω(extraElements).ShouldNot(m, "should reject with extra keys")
-			Ω(missingElements).Should(m, "should allow missing keys")
-			Ω(nils).Should(m, "should allow an uninitialized slice")
-		})
-
-		It("should ignore extras", func() {
-			m := MatchElements(nonUniqueID, AllowDuplicates|IgnoreExtras, Elements{
-				"a": ContainSubstring("1"),
-				"b": ContainSubstring("1"),
-			})
-			Ω(allElements).Should(m, "should match all elements")
-			Ω(includingBadElements).ShouldNot(m, "should reject if a member fails the matcher")
-			Ω(extraElements).Should(m, "should allow extra keys")
-			Ω(missingElements).ShouldNot(m, "should reject missing keys")
-			Ω(nils).ShouldNot(m, "should reject an uninitialized slice")
-		})
-
-		It("should ignore missing and extras", func() {
-			m := MatchElements(nonUniqueID, AllowDuplicates|IgnoreExtras|IgnoreMissing, Elements{
-				"a": ContainSubstring("1"),
-				"b": ContainSubstring("1"),
-			})
-			Ω(allElements).Should(m, "should match all elements")
-			Ω(includingBadElements).ShouldNot(m, "should reject if a member fails the matcher")
-			Ω(extraElements).Should(m, "should allow extra keys")
-			Ω(missingElements).Should(m, "should allow missing keys")
-			Ω(nils).Should(m, "should allow an uninitialized slice")
-		})
-	})
-})
-
-func id(element interface{}) string {
-	return element.(string)
-}
diff --git a/vendor/github.com/onsi/gomega/gstruct/errors/nested_types.go b/vendor/github.com/onsi/gomega/gstruct/errors/nested_types.go
deleted file mode 100644
index 188492b..0000000
--- a/vendor/github.com/onsi/gomega/gstruct/errors/nested_types.go
+++ /dev/null
@@ -1,72 +0,0 @@
-package errors
-
-import (
-	"fmt"
-	"strings"
-
-	"github.com/onsi/gomega/types"
-)
-
-// A stateful matcher that nests other matchers within it and preserves the error types of the
-// nested matcher failures.
-type NestingMatcher interface {
-	types.GomegaMatcher
-
-	// Returns the failures of nested matchers.
-	Failures() []error
-}
-
-// An error type for labeling errors on deeply nested matchers.
-type NestedError struct {
-	Path string
-	Err  error
-}
-
-func (e *NestedError) Error() string {
-	// Indent Errors.
-	indented := strings.Replace(e.Err.Error(), "\n", "\n\t", -1)
-	return fmt.Sprintf("%s:\n\t%v", e.Path, indented)
-}
-
-// Create a NestedError with the given path.
-// If err is a NestedError, prepend the path to it.
-// If err is an AggregateError, recursively Nest each error.
-func Nest(path string, err error) error {
-	if ag, ok := err.(AggregateError); ok {
-		var errs AggregateError
-		for _, e := range ag {
-			errs = append(errs, Nest(path, e))
-		}
-		return errs
-	}
-	if ne, ok := err.(*NestedError); ok {
-		return &NestedError{
-			Path: path + ne.Path,
-			Err:  ne.Err,
-		}
-	}
-	return &NestedError{
-		Path: path,
-		Err:  err,
-	}
-}
-
-// An error type for treating multiple errors as a single error.
-type AggregateError []error
-
-// Error is part of the error interface.
-func (err AggregateError) Error() string {
-	if len(err) == 0 {
-		// This should never happen, really.
-		return ""
-	}
-	if len(err) == 1 {
-		return err[0].Error()
-	}
-	result := fmt.Sprintf("[%s", err[0].Error())
-	for i := 1; i < len(err); i++ {
-		result += fmt.Sprintf(", %s", err[i].Error())
-	}
-	result += "]"
-	return result
-}
diff --git a/vendor/github.com/onsi/gomega/gstruct/fields.go b/vendor/github.com/onsi/gomega/gstruct/fields.go
deleted file mode 100644
index f3c1575..0000000
--- a/vendor/github.com/onsi/gomega/gstruct/fields.go
+++ /dev/null
@@ -1,141 +0,0 @@
-package gstruct
-
-import (
-	"errors"
-	"fmt"
-	"reflect"
-	"runtime/debug"
-	"strings"
-
-	"github.com/onsi/gomega/format"
-	errorsutil "github.com/onsi/gomega/gstruct/errors"
-	"github.com/onsi/gomega/types"
-)
-
-//MatchAllFields succeeds if every field of a struct matches the field matcher associated with
-//it, and every element matcher is matched.
-//  Expect([]string{"a", "b"}).To(MatchAllFields(idFn, gstruct.Fields{
-//      "a": BeEqual("a"),
-//      "b": BeEqual("b"),
-//  })
-func MatchAllFields(fields Fields) types.GomegaMatcher {
-	return &FieldsMatcher{
-		Fields: fields,
-	}
-}
-
-//MatchFields succeeds if each element of a struct matches the field matcher associated with
-//it. It can ignore extra fields and/or missing fields.
-//  Expect([]string{"a", "c"}).To(MatchFields(idFn, IgnoreMissing|IgnoreExtra, gstruct.Fields{
-//      "a": BeEqual("a")
-//      "b": BeEqual("b"),
-//  })
-func MatchFields(options Options, fields Fields) types.GomegaMatcher {
-	return &FieldsMatcher{
-		Fields:        fields,
-		IgnoreExtras:  options&IgnoreExtras != 0,
-		IgnoreMissing: options&IgnoreMissing != 0,
-	}
-}
-
-type FieldsMatcher struct {
-	// Matchers for each field.
-	Fields Fields
-
-	// Whether to ignore extra elements or consider it an error.
-	IgnoreExtras bool
-	// Whether to ignore missing elements or consider it an error.
-	IgnoreMissing bool
-
-	// State.
-	failures []error
-}
-
-// Field name to matcher.
-type Fields map[string]types.GomegaMatcher
-
-func (m *FieldsMatcher) Match(actual interface{}) (success bool, err error) {
-	if reflect.TypeOf(actual).Kind() != reflect.Struct {
-		return false, fmt.Errorf("%v is type %T, expected struct", actual, actual)
-	}
-
-	m.failures = m.matchFields(actual)
-	if len(m.failures) > 0 {
-		return false, nil
-	}
-	return true, nil
-}
-
-func (m *FieldsMatcher) matchFields(actual interface{}) (errs []error) {
-	val := reflect.ValueOf(actual)
-	typ := val.Type()
-	fields := map[string]bool{}
-	for i := 0; i < val.NumField(); i++ {
-		fieldName := typ.Field(i).Name
-		fields[fieldName] = true
-
-		err := func() (err error) {
-			// This test relies heavily on reflect, which tends to panic.
-			// Recover here to provide more useful error messages in that case.
-			defer func() {
-				if r := recover(); r != nil {
-					err = fmt.Errorf("panic checking %+v: %v\n%s", actual, r, debug.Stack())
-				}
-			}()
-
-			matcher, expected := m.Fields[fieldName]
-			if !expected {
-				if !m.IgnoreExtras {
-					return fmt.Errorf("unexpected field %s: %+v", fieldName, actual)
-				}
-				return nil
-			}
-
-			var field interface{}
-			if val.Field(i).IsValid() {
-				field = val.Field(i).Interface()
-			} else {
-				field = reflect.Zero(typ.Field(i).Type)
-			}
-
-			match, err := matcher.Match(field)
-			if err != nil {
-				return err
-			} else if !match {
-				if nesting, ok := matcher.(errorsutil.NestingMatcher); ok {
-					return errorsutil.AggregateError(nesting.Failures())
-				}
-				return errors.New(matcher.FailureMessage(field))
-			}
-			return nil
-		}()
-		if err != nil {
-			errs = append(errs, errorsutil.Nest("."+fieldName, err))
-		}
-	}
-
-	for field := range m.Fields {
-		if !fields[field] && !m.IgnoreMissing {
-			errs = append(errs, fmt.Errorf("missing expected field %s", field))
-		}
-	}
-
-	return errs
-}
-
-func (m *FieldsMatcher) FailureMessage(actual interface{}) (message string) {
-	failures := make([]string, len(m.failures))
-	for i := range m.failures {
-		failures[i] = m.failures[i].Error()
-	}
-	return format.Message(reflect.TypeOf(actual).Name(),
-		fmt.Sprintf("to match fields: {\n%v\n}\n", strings.Join(failures, "\n")))
-}
-
-func (m *FieldsMatcher) NegatedFailureMessage(actual interface{}) (message string) {
-	return format.Message(actual, "not to match fields")
-}
-
-func (m *FieldsMatcher) Failures() []error {
-	return m.failures
-}
diff --git a/vendor/github.com/onsi/gomega/gstruct/fields_test.go b/vendor/github.com/onsi/gomega/gstruct/fields_test.go
deleted file mode 100644
index 61f4afc..0000000
--- a/vendor/github.com/onsi/gomega/gstruct/fields_test.go
+++ /dev/null
@@ -1,76 +0,0 @@
-package gstruct_test
-
-import (
-	. "github.com/onsi/ginkgo"
-	. "github.com/onsi/gomega"
-	. "github.com/onsi/gomega/gstruct"
-)
-
-var _ = Describe("Struct", func() {
-	allFields := struct{ A, B string }{"a", "b"}
-	missingFields := struct{ A string }{"a"}
-	extraFields := struct{ A, B, C string }{"a", "b", "c"}
-	emptyFields := struct{ A, B string }{}
-
-	It("should strictly match all fields", func() {
-		m := MatchAllFields(Fields{
-			"B": Equal("b"),
-			"A": Equal("a"),
-		})
-		Ω(allFields).Should(m, "should match all fields")
-		Ω(missingFields).ShouldNot(m, "should fail with missing fields")
-		Ω(extraFields).ShouldNot(m, "should fail with extra fields")
-		Ω(emptyFields).ShouldNot(m, "should fail with empty fields")
-
-		m = MatchAllFields(Fields{
-			"A": Equal("a"),
-			"B": Equal("fail"),
-		})
-		Ω(allFields).ShouldNot(m, "should run nested matchers")
-	})
-
-	It("should handle empty structs", func() {
-		m := MatchAllFields(Fields{})
-		Ω(struct{}{}).Should(m, "should handle empty structs")
-		Ω(allFields).ShouldNot(m, "should fail with extra fields")
-	})
-
-	It("should ignore missing fields", func() {
-		m := MatchFields(IgnoreMissing, Fields{
-			"B": Equal("b"),
-			"A": Equal("a"),
-		})
-		Ω(allFields).Should(m, "should match all fields")
-		Ω(missingFields).Should(m, "should ignore missing fields")
-		Ω(extraFields).ShouldNot(m, "should fail with extra fields")
-		Ω(emptyFields).ShouldNot(m, "should fail with empty fields")
-	})
-
-	It("should ignore extra fields", func() {
-		m := MatchFields(IgnoreExtras, Fields{
-			"B": Equal("b"),
-			"A": Equal("a"),
-		})
-		Ω(allFields).Should(m, "should match all fields")
-		Ω(missingFields).ShouldNot(m, "should fail with missing fields")
-		Ω(extraFields).Should(m, "should ignore extra fields")
-		Ω(emptyFields).ShouldNot(m, "should fail with empty fields")
-	})
-
-	It("should ignore missing and extra fields", func() {
-		m := MatchFields(IgnoreMissing|IgnoreExtras, Fields{
-			"B": Equal("b"),
-			"A": Equal("a"),
-		})
-		Ω(allFields).Should(m, "should match all fields")
-		Ω(missingFields).Should(m, "should ignore missing fields")
-		Ω(extraFields).Should(m, "should ignore extra fields")
-		Ω(emptyFields).ShouldNot(m, "should fail with empty fields")
-
-		m = MatchFields(IgnoreMissing|IgnoreExtras, Fields{
-			"A": Equal("a"),
-			"B": Equal("fail"),
-		})
-		Ω(allFields).ShouldNot(m, "should run nested matchers")
-	})
-})
diff --git a/vendor/github.com/onsi/gomega/gstruct/gstruct_tests_suite_test.go b/vendor/github.com/onsi/gomega/gstruct/gstruct_tests_suite_test.go
deleted file mode 100644
index d475663..0000000
--- a/vendor/github.com/onsi/gomega/gstruct/gstruct_tests_suite_test.go
+++ /dev/null
@@ -1,13 +0,0 @@
-package gstruct_test
-
-import (
-	"testing"
-
-	. "github.com/onsi/ginkgo"
-	. "github.com/onsi/gomega"
-)
-
-func Test(t *testing.T) {
-	RegisterFailHandler(Fail)
-	RunSpecs(t, "Gstruct Suite")
-}
diff --git a/vendor/github.com/onsi/gomega/gstruct/ignore.go b/vendor/github.com/onsi/gomega/gstruct/ignore.go
deleted file mode 100644
index 0365f32..0000000
--- a/vendor/github.com/onsi/gomega/gstruct/ignore.go
+++ /dev/null
@@ -1,37 +0,0 @@
-package gstruct
-
-import (
-	"github.com/onsi/gomega/types"
-)
-
-//Ignore ignores the actual value and always succeeds.
-//  Expect(nil).To(Ignore())
-//  Expect(true).To(Ignore())
-func Ignore() types.GomegaMatcher {
-	return &IgnoreMatcher{true}
-}
-
-//Reject ignores the actual value and always fails. It can be used in conjunction with IgnoreMissing
-//to catch problematic elements, or to verify tests are running.
-//  Expect(nil).NotTo(Reject())
-//  Expect(true).NotTo(Reject())
-func Reject() types.GomegaMatcher {
-	return &IgnoreMatcher{false}
-}
-
-// A matcher that either always succeeds or always fails.
-type IgnoreMatcher struct {
-	Succeed bool
-}
-
-func (m *IgnoreMatcher) Match(actual interface{}) (bool, error) {
-	return m.Succeed, nil
-}
-
-func (m *IgnoreMatcher) FailureMessage(_ interface{}) (message string) {
-	return "Unconditional failure"
-}
-
-func (m *IgnoreMatcher) NegatedFailureMessage(_ interface{}) (message string) {
-	return "Unconditional success"
-}
diff --git a/vendor/github.com/onsi/gomega/gstruct/ignore_test.go b/vendor/github.com/onsi/gomega/gstruct/ignore_test.go
deleted file mode 100644
index 70e1d40..0000000
--- a/vendor/github.com/onsi/gomega/gstruct/ignore_test.go
+++ /dev/null
@@ -1,23 +0,0 @@
-package gstruct_test
-
-import (
-	. "github.com/onsi/ginkgo"
-	. "github.com/onsi/gomega"
-	. "github.com/onsi/gomega/gstruct"
-)
-
-var _ = Describe("Ignore", func() {
-	It("should always succeed", func() {
-		Ω(nil).Should(Ignore())
-		Ω(struct{}{}).Should(Ignore())
-		Ω(0).Should(Ignore())
-		Ω(false).Should(Ignore())
-	})
-
-	It("should always fail", func() {
-		Ω(nil).ShouldNot(Reject())
-		Ω(struct{}{}).ShouldNot(Reject())
-		Ω(1).ShouldNot(Reject())
-		Ω(true).ShouldNot(Reject())
-	})
-})
diff --git a/vendor/github.com/onsi/gomega/gstruct/pointer.go b/vendor/github.com/onsi/gomega/gstruct/pointer.go
deleted file mode 100644
index 0a2f35d..0000000
--- a/vendor/github.com/onsi/gomega/gstruct/pointer.go
+++ /dev/null
@@ -1,56 +0,0 @@
-package gstruct
-
-import (
-	"fmt"
-	"reflect"
-
-	"github.com/onsi/gomega/format"
-	"github.com/onsi/gomega/types"
-)
-
-//PointTo applies the given matcher to the value pointed to by actual. It fails if the pointer is
-//nil.
-//  actual := 5
-//  Expect(&actual).To(PointTo(Equal(5)))
-func PointTo(matcher types.GomegaMatcher) types.GomegaMatcher {
-	return &PointerMatcher{
-		Matcher: matcher,
-	}
-}
-
-type PointerMatcher struct {
-	Matcher types.GomegaMatcher
-
-	// Failure message.
-	failure string
-}
-
-func (m *PointerMatcher) Match(actual interface{}) (bool, error) {
-	val := reflect.ValueOf(actual)
-
-	// return error if actual type is not a pointer
-	if val.Kind() != reflect.Ptr {
-		return false, fmt.Errorf("PointerMatcher expects a pointer but we have '%s'", val.Kind())
-	}
-
-	if !val.IsValid() || val.IsNil() {
-		m.failure = format.Message(actual, "not to be <nil>")
-		return false, nil
-	}
-
-	// Forward the value.
-	elem := val.Elem().Interface()
-	match, err := m.Matcher.Match(elem)
-	if !match {
-		m.failure = m.Matcher.FailureMessage(elem)
-	}
-	return match, err
-}
-
-func (m *PointerMatcher) FailureMessage(_ interface{}) (message string) {
-	return m.failure
-}
-
-func (m *PointerMatcher) NegatedFailureMessage(actual interface{}) (message string) {
-	return m.Matcher.NegatedFailureMessage(actual)
-}
diff --git a/vendor/github.com/onsi/gomega/gstruct/pointer_test.go b/vendor/github.com/onsi/gomega/gstruct/pointer_test.go
deleted file mode 100644
index b02081c..0000000
--- a/vendor/github.com/onsi/gomega/gstruct/pointer_test.go
+++ /dev/null
@@ -1,33 +0,0 @@
-package gstruct_test
-
-import (
-	. "github.com/onsi/ginkgo"
-	. "github.com/onsi/gomega"
-	. "github.com/onsi/gomega/gstruct"
-)
-
-var _ = Describe("PointTo", func() {
-	It("should fail when passed nil", func() {
-		var p *struct{}
-		Ω(p).Should(BeNil())
-	})
-
-	It("should succeed when passed non-nil pointer", func() {
-		var s struct{}
-		Ω(&s).Should(PointTo(Ignore()))
-	})
-
-	It("should unwrap the pointee value", func() {
-		i := 1
-		Ω(&i).Should(PointTo(Equal(1)))
-		Ω(&i).ShouldNot(PointTo(Equal(2)))
-	})
-
-	It("should work with nested pointers", func() {
-		i := 1
-		ip := &i
-		ipp := &ip
-		Ω(ipp).Should(PointTo(PointTo(Equal(1))))
-		Ω(ipp).ShouldNot(PointTo(PointTo(Equal(2))))
-	})
-})
diff --git a/vendor/github.com/onsi/gomega/gstruct/types.go b/vendor/github.com/onsi/gomega/gstruct/types.go
deleted file mode 100644
index 48cbbe8..0000000
--- a/vendor/github.com/onsi/gomega/gstruct/types.go
+++ /dev/null
@@ -1,15 +0,0 @@
-package gstruct
-
-//Options is the type for options passed to some matchers.
-type Options int
-
-const (
-	//IgnoreExtras tells the matcher to ignore extra elements or fields, rather than triggering a failure.
-	IgnoreExtras Options = 1 << iota
-	//IgnoreMissing tells the matcher to ignore missing elements or fields, rather than triggering a failure.
-	IgnoreMissing
-	//AllowDuplicates tells the matcher to permit multiple members of the slice to produce the same ID when
-	//considered by the indentifier function. All members that map to a given key must still match successfully
-	//with the matcher that is provided for that key.
-	AllowDuplicates
-)
diff --git a/vendor/github.com/onsi/gomega/internal/assertion/assertion_suite_test.go b/vendor/github.com/onsi/gomega/internal/assertion/assertion_suite_test.go
deleted file mode 100644
index dae47a4..0000000
--- a/vendor/github.com/onsi/gomega/internal/assertion/assertion_suite_test.go
+++ /dev/null
@@ -1,13 +0,0 @@
-package assertion_test
-
-import (
-	. "github.com/onsi/ginkgo"
-	. "github.com/onsi/gomega"
-
-	"testing"
-)
-
-func TestAssertion(t *testing.T) {
-	RegisterFailHandler(Fail)
-	RunSpecs(t, "Assertion Suite")
-}
diff --git a/vendor/github.com/onsi/gomega/internal/assertion/assertion_test.go b/vendor/github.com/onsi/gomega/internal/assertion/assertion_test.go
deleted file mode 100644
index c03b7a3..0000000
--- a/vendor/github.com/onsi/gomega/internal/assertion/assertion_test.go
+++ /dev/null
@@ -1,252 +0,0 @@
-package assertion_test
-
-import (
-	"errors"
-
-	. "github.com/onsi/ginkgo"
-	. "github.com/onsi/gomega"
-	. "github.com/onsi/gomega/internal/assertion"
-	"github.com/onsi/gomega/internal/fakematcher"
-)
-
-var _ = Describe("Assertion", func() {
-	var (
-		a                 *Assertion
-		failureMessage    string
-		failureCallerSkip int
-		matcher           *fakematcher.FakeMatcher
-	)
-
-	input := "The thing I'm testing"
-
-	var fakeFailHandler = func(message string, callerSkip ...int) {
-		failureMessage = message
-		if len(callerSkip) == 1 {
-			failureCallerSkip = callerSkip[0]
-		}
-	}
-
-	BeforeEach(func() {
-		matcher = &fakematcher.FakeMatcher{}
-		failureMessage = ""
-		failureCallerSkip = 0
-		a = New(input, fakeFailHandler, 1)
-	})
-
-	Context("when called", func() {
-		It("should pass the provided input value to the matcher", func() {
-			a.Should(matcher)
-
-			Ω(matcher.ReceivedActual).Should(Equal(input))
-			matcher.ReceivedActual = ""
-
-			a.ShouldNot(matcher)
-
-			Ω(matcher.ReceivedActual).Should(Equal(input))
-			matcher.ReceivedActual = ""
-
-			a.To(matcher)
-
-			Ω(matcher.ReceivedActual).Should(Equal(input))
-			matcher.ReceivedActual = ""
-
-			a.ToNot(matcher)
-
-			Ω(matcher.ReceivedActual).Should(Equal(input))
-			matcher.ReceivedActual = ""
-
-			a.NotTo(matcher)
-
-			Ω(matcher.ReceivedActual).Should(Equal(input))
-		})
-	})
-
-	Context("when the matcher succeeds", func() {
-		BeforeEach(func() {
-			matcher.MatchesToReturn = true
-			matcher.ErrToReturn = nil
-		})
-
-		Context("and a positive assertion is being made", func() {
-			It("should not call the failure callback", func() {
-				a.Should(matcher)
-				Ω(failureMessage).Should(Equal(""))
-			})
-
-			It("should be true", func() {
-				Ω(a.Should(matcher)).Should(BeTrue())
-			})
-		})
-
-		Context("and a negative assertion is being made", func() {
-			It("should call the failure callback", func() {
-				a.ShouldNot(matcher)
-				Ω(failureMessage).Should(Equal("negative: The thing I'm testing"))
-				Ω(failureCallerSkip).Should(Equal(3))
-			})
-
-			It("should be false", func() {
-				Ω(a.ShouldNot(matcher)).Should(BeFalse())
-			})
-		})
-	})
-
-	Context("when the matcher fails", func() {
-		BeforeEach(func() {
-			matcher.MatchesToReturn = false
-			matcher.ErrToReturn = nil
-		})
-
-		Context("and a positive assertion is being made", func() {
-			It("should call the failure callback", func() {
-				a.Should(matcher)
-				Ω(failureMessage).Should(Equal("positive: The thing I'm testing"))
-				Ω(failureCallerSkip).Should(Equal(3))
-			})
-
-			It("should be false", func() {
-				Ω(a.Should(matcher)).Should(BeFalse())
-			})
-		})
-
-		Context("and a negative assertion is being made", func() {
-			It("should not call the failure callback", func() {
-				a.ShouldNot(matcher)
-				Ω(failureMessage).Should(Equal(""))
-			})
-
-			It("should be true", func() {
-				Ω(a.ShouldNot(matcher)).Should(BeTrue())
-			})
-		})
-	})
-
-	Context("When reporting a failure", func() {
-		BeforeEach(func() {
-			matcher.MatchesToReturn = false
-			matcher.ErrToReturn = nil
-		})
-
-		Context("and there is an optional description", func() {
-			It("should append the description to the failure message", func() {
-				a.Should(matcher, "A description")
-				Ω(failureMessage).Should(Equal("A description\npositive: The thing I'm testing"))
-				Ω(failureCallerSkip).Should(Equal(3))
-			})
-		})
-
-		Context("and there are multiple arguments to the optional description", func() {
-			It("should append the formatted description to the failure message", func() {
-				a.Should(matcher, "A description of [%d]", 3)
-				Ω(failureMessage).Should(Equal("A description of [3]\npositive: The thing I'm testing"))
-				Ω(failureCallerSkip).Should(Equal(3))
-			})
-		})
-	})
-
-	Context("When the matcher returns an error", func() {
-		BeforeEach(func() {
-			matcher.ErrToReturn = errors.New("Kaboom!")
-		})
-
-		Context("and a positive assertion is being made", func() {
-			It("should call the failure callback", func() {
-				matcher.MatchesToReturn = true
-				a.Should(matcher)
-				Ω(failureMessage).Should(Equal("Kaboom!"))
-				Ω(failureCallerSkip).Should(Equal(3))
-			})
-		})
-
-		Context("and a negative assertion is being made", func() {
-			It("should call the failure callback", func() {
-				matcher.MatchesToReturn = false
-				a.ShouldNot(matcher)
-				Ω(failureMessage).Should(Equal("Kaboom!"))
-				Ω(failureCallerSkip).Should(Equal(3))
-			})
-		})
-
-		It("should always be false", func() {
-			Ω(a.Should(matcher)).Should(BeFalse())
-			Ω(a.ShouldNot(matcher)).Should(BeFalse())
-		})
-	})
-
-	Context("when there are extra parameters", func() {
-		It("(a simple example)", func() {
-			Ω(func() (string, int, error) {
-				return "foo", 0, nil
-			}()).Should(Equal("foo"))
-		})
-
-		Context("when the parameters are all nil or zero", func() {
-			It("should invoke the matcher", func() {
-				matcher.MatchesToReturn = true
-				matcher.ErrToReturn = nil
-
-				var typedNil []string
-				a = New(input, fakeFailHandler, 1, 0, nil, typedNil)
-
-				result := a.Should(matcher)
-				Ω(result).Should(BeTrue())
-				Ω(matcher.ReceivedActual).Should(Equal(input))
-
-				Ω(failureMessage).Should(BeZero())
-			})
-		})
-
-		Context("when any of the parameters are not nil or zero", func() {
-			It("should call the failure callback", func() {
-				matcher.MatchesToReturn = false
-				matcher.ErrToReturn = nil
-
-				a = New(input, fakeFailHandler, 1, errors.New("foo"))
-				result := a.Should(matcher)
-				Ω(result).Should(BeFalse())
-				Ω(matcher.ReceivedActual).Should(BeZero(), "The matcher doesn't even get called")
-				Ω(failureMessage).Should(ContainSubstring("foo"))
-				failureMessage = ""
-
-				a = New(input, fakeFailHandler, 1, nil, 1)
-				result = a.ShouldNot(matcher)
-				Ω(result).Should(BeFalse())
-				Ω(failureMessage).Should(ContainSubstring("1"))
-				failureMessage = ""
-
-				a = New(input, fakeFailHandler, 1, nil, 0, []string{"foo"})
-				result = a.To(matcher)
-				Ω(result).Should(BeFalse())
-				Ω(failureMessage).Should(ContainSubstring("foo"))
-				failureMessage = ""
-
-				a = New(input, fakeFailHandler, 1, nil, 0, []string{"foo"})
-				result = a.ToNot(matcher)
-				Ω(result).Should(BeFalse())
-				Ω(failureMessage).Should(ContainSubstring("foo"))
-				failureMessage = ""
-
-				a = New(input, fakeFailHandler, 1, nil, 0, []string{"foo"})
-				result = a.NotTo(matcher)
-				Ω(result).Should(BeFalse())
-				Ω(failureMessage).Should(ContainSubstring("foo"))
-				Ω(failureCallerSkip).Should(Equal(3))
-			})
-		})
-	})
-
-	Context("Making an assertion without a registered fail handler", func() {
-		It("should panic", func() {
-			defer func() {
-				e := recover()
-				RegisterFailHandler(Fail)
-				if e == nil {
-					Fail("expected a panic to have occurred")
-				}
-			}()
-
-			RegisterFailHandler(nil)
-			Ω(true).Should(BeTrue())
-		})
-	})
-})
diff --git a/vendor/github.com/onsi/gomega/internal/asyncassertion/async_assertion_suite_test.go b/vendor/github.com/onsi/gomega/internal/asyncassertion/async_assertion_suite_test.go
deleted file mode 100644
index bdb0c3d..0000000
--- a/vendor/github.com/onsi/gomega/internal/asyncassertion/async_assertion_suite_test.go
+++ /dev/null
@@ -1,13 +0,0 @@
-package asyncassertion_test
-
-import (
-	. "github.com/onsi/ginkgo"
-	. "github.com/onsi/gomega"
-
-	"testing"
-)
-
-func TestAsyncAssertion(t *testing.T) {
-	RegisterFailHandler(Fail)
-	RunSpecs(t, "AsyncAssertion Suite")
-}
diff --git a/vendor/github.com/onsi/gomega/internal/asyncassertion/async_assertion_test.go b/vendor/github.com/onsi/gomega/internal/asyncassertion/async_assertion_test.go
deleted file mode 100644
index 3d7e348..0000000
--- a/vendor/github.com/onsi/gomega/internal/asyncassertion/async_assertion_test.go
+++ /dev/null
@@ -1,345 +0,0 @@
-package asyncassertion_test
-
-import (
-	"errors"
-	"time"
-
-	. "github.com/onsi/ginkgo"
-	. "github.com/onsi/gomega"
-	. "github.com/onsi/gomega/internal/asyncassertion"
-)
-
-var _ = Describe("Async Assertion", func() {
-	var (
-		failureMessage string
-		callerSkip     int
-	)
-
-	var fakeFailHandler = func(message string, skip ...int) {
-		failureMessage = message
-		callerSkip = skip[0]
-	}
-
-	BeforeEach(func() {
-		failureMessage = ""
-		callerSkip = 0
-	})
-
-	Describe("Eventually", func() {
-		Context("the positive case", func() {
-			It("should poll the function and matcher", func() {
-				counter := 0
-				a := New(AsyncAssertionTypeEventually, func() int {
-					counter++
-					return counter
-				}, fakeFailHandler, time.Duration(0.2*float64(time.Second)), time.Duration(0.02*float64(time.Second)), 1)
-
-				a.Should(BeNumerically("==", 5))
-				Ω(failureMessage).Should(BeZero())
-			})
-
-			It("should continue when the matcher errors", func() {
-				counter := 0
-				a := New(AsyncAssertionTypeEventually, func() interface{} {
-					counter++
-					if counter == 5 {
-						return "not-a-number" //this should cause the matcher to error
-					}
-					return counter
-				}, fakeFailHandler, time.Duration(0.2*float64(time.Second)), time.Duration(0.02*float64(time.Second)), 1)
-
-				a.Should(BeNumerically("==", 5), "My description %d", 2)
-
-				Ω(failureMessage).Should(ContainSubstring("Timed out after"))
-				Ω(failureMessage).Should(ContainSubstring("My description 2"))
-				Ω(callerSkip).Should(Equal(4))
-			})
-
-			It("should be able to timeout", func() {
-				counter := 0
-				a := New(AsyncAssertionTypeEventually, func() int {
-					counter++
-					return counter
-				}, fakeFailHandler, time.Duration(0.2*float64(time.Second)), time.Duration(0.02*float64(time.Second)), 1)
-
-				a.Should(BeNumerically(">", 100), "My description %d", 2)
-
-				Ω(counter).Should(BeNumerically(">", 8))
-				Ω(counter).Should(BeNumerically("<=", 10))
-				Ω(failureMessage).Should(ContainSubstring("Timed out after"))
-				Ω(failureMessage).Should(MatchRegexp(`\<int\>: \d`), "Should pass the correct value to the matcher message formatter.")
-				Ω(failureMessage).Should(ContainSubstring("My description 2"))
-				Ω(callerSkip).Should(Equal(4))
-			})
-		})
-
-		Context("the negative case", func() {
-			It("should poll the function and matcher", func() {
-				counter := 0
-				a := New(AsyncAssertionTypeEventually, func() int {
-					counter += 1
-					return counter
-				}, fakeFailHandler, time.Duration(0.2*float64(time.Second)), time.Duration(0.02*float64(time.Second)), 1)
-
-				a.ShouldNot(BeNumerically("<", 3))
-
-				Ω(counter).Should(Equal(3))
-				Ω(failureMessage).Should(BeZero())
-			})
-
-			It("should timeout when the matcher errors", func() {
-				a := New(AsyncAssertionTypeEventually, func() interface{} {
-					return 0 //this should cause the matcher to error
-				}, fakeFailHandler, time.Duration(0.2*float64(time.Second)), time.Duration(0.02*float64(time.Second)), 1)
-
-				a.ShouldNot(HaveLen(0), "My description %d", 2)
-
-				Ω(failureMessage).Should(ContainSubstring("Timed out after"))
-				Ω(failureMessage).Should(ContainSubstring("Error:"))
-				Ω(failureMessage).Should(ContainSubstring("My description 2"))
-				Ω(callerSkip).Should(Equal(4))
-			})
-
-			It("should be able to timeout", func() {
-				a := New(AsyncAssertionTypeEventually, func() int {
-					return 0
-				}, fakeFailHandler, time.Duration(0.1*float64(time.Second)), time.Duration(0.02*float64(time.Second)), 1)
-
-				a.ShouldNot(Equal(0), "My description %d", 2)
-
-				Ω(failureMessage).Should(ContainSubstring("Timed out after"))
-				Ω(failureMessage).Should(ContainSubstring("<int>: 0"), "Should pass the correct value to the matcher message formatter.")
-				Ω(failureMessage).Should(ContainSubstring("My description 2"))
-				Ω(callerSkip).Should(Equal(4))
-			})
-		})
-
-		Context("with a function that returns multiple values", func() {
-			It("should eventually succeed if the additional arguments are nil", func() {
-				i := 0
-				Eventually(func() (int, error) {
-					i++
-					return i, nil
-				}).Should(Equal(10))
-			})
-
-			It("should eventually timeout if the additional arguments are not nil", func() {
-				i := 0
-				a := New(AsyncAssertionTypeEventually, func() (int, error) {
-					i++
-					return i, errors.New("bam")
-				}, fakeFailHandler, time.Duration(0.2*float64(time.Second)), time.Duration(0.02*float64(time.Second)), 1)
-				a.Should(Equal(2))
-
-				Ω(failureMessage).Should(ContainSubstring("Timed out after"))
-				Ω(failureMessage).Should(ContainSubstring("Error:"))
-				Ω(failureMessage).Should(ContainSubstring("bam"))
-				Ω(callerSkip).Should(Equal(4))
-			})
-		})
-
-		Context("Making an assertion without a registered fail handler", func() {
-			It("should panic", func() {
-				defer func() {
-					e := recover()
-					RegisterFailHandler(Fail)
-					if e == nil {
-						Fail("expected a panic to have occurred")
-					}
-				}()
-
-				RegisterFailHandler(nil)
-				c := make(chan bool, 1)
-				c <- true
-				Eventually(c).Should(Receive())
-			})
-		})
-	})
-
-	Describe("Consistently", func() {
-		Describe("The positive case", func() {
-			Context("when the matcher consistently passes for the duration", func() {
-				It("should pass", func() {
-					calls := 0
-					a := New(AsyncAssertionTypeConsistently, func() string {
-						calls++
-						return "foo"
-					}, fakeFailHandler, time.Duration(0.2*float64(time.Second)), time.Duration(0.02*float64(time.Second)), 1)
-
-					a.Should(Equal("foo"))
-					Ω(calls).Should(BeNumerically(">", 8))
-					Ω(calls).Should(BeNumerically("<=", 10))
-					Ω(failureMessage).Should(BeZero())
-				})
-			})
-
-			Context("when the matcher fails at some point", func() {
-				It("should fail", func() {
-					calls := 0
-					a := New(AsyncAssertionTypeConsistently, func() interface{} {
-						calls++
-						if calls > 5 {
-							return "bar"
-						}
-						return "foo"
-					}, fakeFailHandler, time.Duration(0.2*float64(time.Second)), time.Duration(0.02*float64(time.Second)), 1)
-
-					a.Should(Equal("foo"))
-					Ω(failureMessage).Should(ContainSubstring("to equal"))
-					Ω(callerSkip).Should(Equal(4))
-				})
-			})
-
-			Context("when the matcher errors at some point", func() {
-				It("should fail", func() {
-					calls := 0
-					a := New(AsyncAssertionTypeConsistently, func() interface{} {
-						calls++
-						if calls > 5 {
-							return 3
-						}
-						return []int{1, 2, 3}
-					}, fakeFailHandler, time.Duration(0.2*float64(time.Second)), time.Duration(0.02*float64(time.Second)), 1)
-
-					a.Should(HaveLen(3))
-					Ω(failureMessage).Should(ContainSubstring("HaveLen matcher expects"))
-					Ω(callerSkip).Should(Equal(4))
-				})
-			})
-		})
-
-		Describe("The negative case", func() {
-			Context("when the matcher consistently passes for the duration", func() {
-				It("should pass", func() {
-					c := make(chan bool)
-					a := New(AsyncAssertionTypeConsistently, c, fakeFailHandler, time.Duration(0.2*float64(time.Second)), time.Duration(0.02*float64(time.Second)), 1)
-
-					a.ShouldNot(Receive())
-					Ω(failureMessage).Should(BeZero())
-				})
-			})
-
-			Context("when the matcher fails at some point", func() {
-				It("should fail", func() {
-					c := make(chan bool)
-					go func() {
-						time.Sleep(time.Duration(100 * time.Millisecond))
-						c <- true
-					}()
-
-					a := New(AsyncAssertionTypeConsistently, c, fakeFailHandler, time.Duration(0.2*float64(time.Second)), time.Duration(0.02*float64(time.Second)), 1)
-
-					a.ShouldNot(Receive())
-					Ω(failureMessage).Should(ContainSubstring("not to receive anything"))
-				})
-			})
-
-			Context("when the matcher errors at some point", func() {
-				It("should fail", func() {
-					calls := 0
-					a := New(AsyncAssertionTypeConsistently, func() interface{} {
-						calls++
-						return calls
-					}, fakeFailHandler, time.Duration(0.2*float64(time.Second)), time.Duration(0.02*float64(time.Second)), 1)
-
-					a.ShouldNot(BeNumerically(">", 5))
-					Ω(failureMessage).Should(ContainSubstring("not to be >"))
-					Ω(callerSkip).Should(Equal(4))
-				})
-			})
-		})
-
-		Context("with a function that returns multiple values", func() {
-			It("should consistently succeed if the additional arguments are nil", func() {
-				i := 2
-				Consistently(func() (int, error) {
-					i++
-					return i, nil
-				}).Should(BeNumerically(">=", 2))
-			})
-
-			It("should eventually timeout if the additional arguments are not nil", func() {
-				i := 2
-				a := New(AsyncAssertionTypeEventually, func() (int, error) {
-					i++
-					return i, errors.New("bam")
-				}, fakeFailHandler, time.Duration(0.2*float64(time.Second)), time.Duration(0.02*float64(time.Second)), 1)
-				a.Should(BeNumerically(">=", 2))
-
-				Ω(failureMessage).Should(ContainSubstring("Error:"))
-				Ω(failureMessage).Should(ContainSubstring("bam"))
-				Ω(callerSkip).Should(Equal(4))
-			})
-		})
-
-		Context("Making an assertion without a registered fail handler", func() {
-			It("should panic", func() {
-				defer func() {
-					e := recover()
-					RegisterFailHandler(Fail)
-					if e == nil {
-						Fail("expected a panic to have occurred")
-					}
-				}()
-
-				RegisterFailHandler(nil)
-				c := make(chan bool)
-				Consistently(c).ShouldNot(Receive())
-			})
-		})
-	})
-
-	Context("when passed a function with the wrong # or arguments & returns", func() {
-		It("should panic", func() {
-			Ω(func() {
-				New(AsyncAssertionTypeEventually, func() {}, fakeFailHandler, 0, 0, 1)
-			}).Should(Panic())
-
-			Ω(func() {
-				New(AsyncAssertionTypeEventually, func(a string) int { return 0 }, fakeFailHandler, 0, 0, 1)
-			}).Should(Panic())
-
-			Ω(func() {
-				New(AsyncAssertionTypeEventually, func() int { return 0 }, fakeFailHandler, 0, 0, 1)
-			}).ShouldNot(Panic())
-
-			Ω(func() {
-				New(AsyncAssertionTypeEventually, func() (int, error) { return 0, nil }, fakeFailHandler, 0, 0, 1)
-			}).ShouldNot(Panic())
-		})
-	})
-
-	Describe("bailing early", func() {
-		Context("when actual is a value", func() {
-			It("Eventually should bail out and fail early if the matcher says to", func() {
-				c := make(chan bool)
-				close(c)
-
-				t := time.Now()
-				failures := InterceptGomegaFailures(func() {
-					Eventually(c, 0.1).Should(Receive())
-				})
-				Ω(time.Since(t)).Should(BeNumerically("<", 90*time.Millisecond))
-
-				Ω(failures).Should(HaveLen(1))
-			})
-		})
-
-		Context("when actual is a function", func() {
-			It("should never bail early", func() {
-				c := make(chan bool)
-				close(c)
-
-				t := time.Now()
-				failures := InterceptGomegaFailures(func() {
-					Eventually(func() chan bool {
-						return c
-					}, 0.1).Should(Receive())
-				})
-				Ω(time.Since(t)).Should(BeNumerically(">=", 90*time.Millisecond))
-
-				Ω(failures).Should(HaveLen(1))
-			})
-		})
-	})
-})
diff --git a/vendor/github.com/onsi/gomega/internal/fakematcher/fake_matcher.go b/vendor/github.com/onsi/gomega/internal/fakematcher/fake_matcher.go
deleted file mode 100644
index 6e351a7..0000000
--- a/vendor/github.com/onsi/gomega/internal/fakematcher/fake_matcher.go
+++ /dev/null
@@ -1,23 +0,0 @@
-package fakematcher
-
-import "fmt"
-
-type FakeMatcher struct {
-	ReceivedActual  interface{}
-	MatchesToReturn bool
-	ErrToReturn     error
-}
-
-func (matcher *FakeMatcher) Match(actual interface{}) (bool, error) {
-	matcher.ReceivedActual = actual
-
-	return matcher.MatchesToReturn, matcher.ErrToReturn
-}
-
-func (matcher *FakeMatcher) FailureMessage(actual interface{}) string {
-	return fmt.Sprintf("positive: %v", actual)
-}
-
-func (matcher *FakeMatcher) NegatedFailureMessage(actual interface{}) string {
-	return fmt.Sprintf("negative: %v", actual)
-}
diff --git a/vendor/github.com/onsi/gomega/internal/testingtsupport/testing_t_support_test.go b/vendor/github.com/onsi/gomega/internal/testingtsupport/testing_t_support_test.go
deleted file mode 100644
index b9fbd6c..0000000
--- a/vendor/github.com/onsi/gomega/internal/testingtsupport/testing_t_support_test.go
+++ /dev/null
@@ -1,12 +0,0 @@
-package testingtsupport_test
-
-import (
-	. "github.com/onsi/gomega"
-
-	"testing"
-)
-
-func TestTestingT(t *testing.T) {
-	RegisterTestingT(t)
-	Ω(true).Should(BeTrue())
-}
diff --git a/vendor/github.com/onsi/gomega/matchers/and_test.go b/vendor/github.com/onsi/gomega/matchers/and_test.go
deleted file mode 100644
index acf778c..0000000
--- a/vendor/github.com/onsi/gomega/matchers/and_test.go
+++ /dev/null
@@ -1,103 +0,0 @@
-package matchers_test
-
-import (
-	. "github.com/onsi/ginkgo"
-	. "github.com/onsi/gomega"
-	. "github.com/onsi/gomega/matchers"
-	"github.com/onsi/gomega/types"
-)
-
-// sample data
-var (
-	// example input
-	input = "hi"
-	// some matchers that succeed against the input
-	true1 = HaveLen(2)
-	true2 = Equal("hi")
-	true3 = MatchRegexp("hi")
-	// some matchers that fail against the input.
-	false1 = HaveLen(1)
-	false2 = Equal("hip")
-	false3 = MatchRegexp("hope")
-)
-
-// verifyFailureMessage expects the matcher to fail with the given input, and verifies the failure message.
-func verifyFailureMessage(m types.GomegaMatcher, input string, expectedFailureMsgFragment string) {
-	Expect(m.Match(input)).To(BeFalse())
-	Expect(m.FailureMessage(input)).To(Equal(
-		"Expected\n    <string>: " + input + "\n" + expectedFailureMsgFragment))
-}
-
-var _ = Describe("AndMatcher", func() {
-	It("works with positive cases", func() {
-		Expect(input).To(And())
-		Expect(input).To(And(true1))
-		Expect(input).To(And(true1, true2))
-		Expect(input).To(And(true1, true2, true3))
-
-		// use alias
-		Expect(input).To(SatisfyAll(true1, true2, true3))
-	})
-
-	It("works with negative cases", func() {
-		Expect(input).ToNot(And(false1, false2))
-		Expect(input).ToNot(And(true1, true2, false3))
-		Expect(input).ToNot(And(true1, false2, false3))
-		Expect(input).ToNot(And(false1, true1, true2))
-	})
-
-	Context("failure messages", func() {
-		Context("when match fails", func() {
-			It("gives a descriptive message", func() {
-				verifyFailureMessage(And(false1, true1), input, "to have length 1")
-				verifyFailureMessage(And(true1, false2), input, "to equal\n    <string>: hip")
-				verifyFailureMessage(And(true1, true2, false3), input, "to match regular expression\n    <string>: hope")
-			})
-		})
-
-		Context("when match succeeds, but expected it to fail", func() {
-			It("gives a descriptive message", func() {
-				verifyFailureMessage(Not(And(true1, true2)), input,
-					`To not satisfy all of these matchers: [%!s(*matchers.HaveLenMatcher=&{2}) %!s(*matchers.EqualMatcher=&{hi})]`)
-			})
-		})
-	})
-
-	Context("MatchMayChangeInTheFuture", func() {
-		Context("Match returned false", func() {
-			Context("returns value of the failed matcher", func() {
-				It("false if failed matcher not going to change", func() {
-					// 3 matchers: 1st returns true, 2nd returns false and is not going to change, 3rd is never called
-					m := And(Not(BeNil()), Or(), Equal(1))
-					Expect(m.Match("hi")).To(BeFalse())
-					Expect(m.(*AndMatcher).MatchMayChangeInTheFuture("hi")).To(BeFalse()) // empty Or() indicates not going to change
-				})
-				It("true if failed matcher indicates it might change", func() {
-					// 3 matchers: 1st returns true, 2nd returns false and "might" change, 3rd is never called
-					m := And(Not(BeNil()), Equal(5), Equal(1))
-					Expect(m.Match("hi")).To(BeFalse())
-					Expect(m.(*AndMatcher).MatchMayChangeInTheFuture("hi")).To(BeTrue()) // Equal(5) indicates it might change
-				})
-			})
-		})
-		Context("Match returned true", func() {
-			It("returns true if any of the matchers could change", func() {
-				// 3 matchers, all return true, and all could change
-				m := And(Not(BeNil()), Equal("hi"), HaveLen(2))
-				Expect(m.Match("hi")).To(BeTrue())
-				Expect(m.(*AndMatcher).MatchMayChangeInTheFuture("hi")).To(BeTrue()) // all 3 of these matchers default to 'true'
-			})
-			It("returns false if none of the matchers could change", func() {
-				// empty And() has the property of always matching, and never can change since there are no sub-matchers that could change
-				m := And()
-				Expect(m.Match("anything")).To(BeTrue())
-				Expect(m.(*AndMatcher).MatchMayChangeInTheFuture("anything")).To(BeFalse())
-
-				// And() with 3 sub-matchers that return true, and can't change
-				m = And(And(), And(), And())
-				Expect(m.Match("hi")).To(BeTrue())
-				Expect(m.(*AndMatcher).MatchMayChangeInTheFuture("hi")).To(BeFalse()) // the 3 empty And()'s won't change
-			})
-		})
-	})
-})
diff --git a/vendor/github.com/onsi/gomega/matchers/assignable_to_type_of_matcher_test.go b/vendor/github.com/onsi/gomega/matchers/assignable_to_type_of_matcher_test.go
deleted file mode 100644
index d2280e0..0000000
--- a/vendor/github.com/onsi/gomega/matchers/assignable_to_type_of_matcher_test.go
+++ /dev/null
@@ -1,30 +0,0 @@
-package matchers_test
-
-import (
-	. "github.com/onsi/ginkgo"
-	. "github.com/onsi/gomega"
-	. "github.com/onsi/gomega/matchers"
-)
-
-var _ = Describe("AssignableToTypeOf", func() {
-	Context("When asserting assignability between types", func() {
-		It("should do the right thing", func() {
-			Ω(0).Should(BeAssignableToTypeOf(0))
-			Ω(5).Should(BeAssignableToTypeOf(-1))
-			Ω("foo").Should(BeAssignableToTypeOf("bar"))
-			Ω(struct{ Foo string }{}).Should(BeAssignableToTypeOf(struct{ Foo string }{}))
-
-			Ω(0).ShouldNot(BeAssignableToTypeOf("bar"))
-			Ω(5).ShouldNot(BeAssignableToTypeOf(struct{ Foo string }{}))
-			Ω("foo").ShouldNot(BeAssignableToTypeOf(42))
-		})
-	})
-
-	Context("When asserting nil values", func() {
-		It("should error", func() {
-			success, err := (&AssignableToTypeOfMatcher{Expected: nil}).Match(nil)
-			Ω(success).Should(BeFalse())
-			Ω(err).Should(HaveOccurred())
-		})
-	})
-})
diff --git a/vendor/github.com/onsi/gomega/matchers/be_a_directory_test.go b/vendor/github.com/onsi/gomega/matchers/be_a_directory_test.go
deleted file mode 100644
index e59d769..0000000
--- a/vendor/github.com/onsi/gomega/matchers/be_a_directory_test.go
+++ /dev/null
@@ -1,40 +0,0 @@
-package matchers_test
-
-import (
-	"io/ioutil"
-	"os"
-
-	. "github.com/onsi/ginkgo"
-	. "github.com/onsi/gomega"
-	. "github.com/onsi/gomega/matchers"
-)
-
-var _ = Describe("BeADirectoryMatcher", func() {
-	Context("when passed a string", func() {
-		It("should do the right thing", func() {
-			Ω("/dne/test").ShouldNot(BeADirectory())
-
-			tmpFile, err := ioutil.TempFile("", "gomega-test-tempfile")
-			Ω(err).ShouldNot(HaveOccurred())
-			defer os.Remove(tmpFile.Name())
-			Ω(tmpFile.Name()).ShouldNot(BeADirectory())
-
-			tmpDir, err := ioutil.TempDir("", "gomega-test-tempdir")
-			Ω(err).ShouldNot(HaveOccurred())
-			defer os.Remove(tmpDir)
-			Ω(tmpDir).Should(BeADirectory())
-		})
-	})
-
-	Context("when passed something else", func() {
-		It("should error", func() {
-			success, err := (&BeADirectoryMatcher{}).Match(nil)
-			Ω(success).Should(BeFalse())
-			Ω(err).Should(HaveOccurred())
-
-			success, err = (&BeADirectoryMatcher{}).Match(true)
-			Ω(success).Should(BeFalse())
-			Ω(err).Should(HaveOccurred())
-		})
-	})
-})
diff --git a/vendor/github.com/onsi/gomega/matchers/be_a_regular_file_test.go b/vendor/github.com/onsi/gomega/matchers/be_a_regular_file_test.go
deleted file mode 100644
index 951e750..0000000
--- a/vendor/github.com/onsi/gomega/matchers/be_a_regular_file_test.go
+++ /dev/null
@@ -1,40 +0,0 @@
-package matchers_test
-
-import (
-	"io/ioutil"
-	"os"
-
-	. "github.com/onsi/ginkgo"
-	. "github.com/onsi/gomega"
-	. "github.com/onsi/gomega/matchers"
-)
-
-var _ = Describe("BeARegularFileMatcher", func() {
-	Context("when passed a string", func() {
-		It("should do the right thing", func() {
-			Ω("/dne/test").ShouldNot(BeARegularFile())
-
-			tmpFile, err := ioutil.TempFile("", "gomega-test-tempfile")
-			Ω(err).ShouldNot(HaveOccurred())
-			defer os.Remove(tmpFile.Name())
-			Ω(tmpFile.Name()).Should(BeARegularFile())
-
-			tmpDir, err := ioutil.TempDir("", "gomega-test-tempdir")
-			Ω(err).ShouldNot(HaveOccurred())
-			defer os.Remove(tmpDir)
-			Ω(tmpDir).ShouldNot(BeARegularFile())
-		})
-	})
-
-	Context("when passed something else", func() {
-		It("should error", func() {
-			success, err := (&BeARegularFileMatcher{}).Match(nil)
-			Ω(success).Should(BeFalse())
-			Ω(err).Should(HaveOccurred())
-
-			success, err = (&BeARegularFileMatcher{}).Match(true)
-			Ω(success).Should(BeFalse())
-			Ω(err).Should(HaveOccurred())
-		})
-	})
-})
diff --git a/vendor/github.com/onsi/gomega/matchers/be_an_existing_file_test.go b/vendor/github.com/onsi/gomega/matchers/be_an_existing_file_test.go
deleted file mode 100644
index 775f7b6..0000000
--- a/vendor/github.com/onsi/gomega/matchers/be_an_existing_file_test.go
+++ /dev/null
@@ -1,40 +0,0 @@
-package matchers_test
-
-import (
-	"io/ioutil"
-	"os"
-
-	. "github.com/onsi/ginkgo"
-	. "github.com/onsi/gomega"
-	. "github.com/onsi/gomega/matchers"
-)
-
-var _ = Describe("BeAnExistingFileMatcher", func() {
-	Context("when passed a string", func() {
-		It("should do the right thing", func() {
-			Ω("/dne/test").ShouldNot(BeAnExistingFile())
-
-			tmpFile, err := ioutil.TempFile("", "gomega-test-tempfile")
-			Ω(err).ShouldNot(HaveOccurred())
-			defer os.Remove(tmpFile.Name())
-			Ω(tmpFile.Name()).Should(BeAnExistingFile())
-
-			tmpDir, err := ioutil.TempDir("", "gomega-test-tempdir")
-			Ω(err).ShouldNot(HaveOccurred())
-			defer os.Remove(tmpDir)
-			Ω(tmpDir).Should(BeAnExistingFile())
-		})
-	})
-
-	Context("when passed something else", func() {
-		It("should error", func() {
-			success, err := (&BeAnExistingFileMatcher{}).Match(nil)
-			Ω(success).Should(BeFalse())
-			Ω(err).Should(HaveOccurred())
-
-			success, err = (&BeAnExistingFileMatcher{}).Match(true)
-			Ω(success).Should(BeFalse())
-			Ω(err).Should(HaveOccurred())
-		})
-	})
-})
diff --git a/vendor/github.com/onsi/gomega/matchers/be_closed_matcher_test.go b/vendor/github.com/onsi/gomega/matchers/be_closed_matcher_test.go
deleted file mode 100644
index b2c40c9..0000000
--- a/vendor/github.com/onsi/gomega/matchers/be_closed_matcher_test.go
+++ /dev/null
@@ -1,70 +0,0 @@
-package matchers_test
-
-import (
-	. "github.com/onsi/ginkgo"
-	. "github.com/onsi/gomega"
-	. "github.com/onsi/gomega/matchers"
-)
-
-var _ = Describe("BeClosedMatcher", func() {
-	Context("when passed a channel", func() {
-		It("should do the right thing", func() {
-			openChannel := make(chan bool)
-			Ω(openChannel).ShouldNot(BeClosed())
-
-			var openReaderChannel <-chan bool
-			openReaderChannel = openChannel
-			Ω(openReaderChannel).ShouldNot(BeClosed())
-
-			closedChannel := make(chan bool)
-			close(closedChannel)
-
-			Ω(closedChannel).Should(BeClosed())
-
-			var closedReaderChannel <-chan bool
-			closedReaderChannel = closedChannel
-			Ω(closedReaderChannel).Should(BeClosed())
-		})
-	})
-
-	Context("when passed a send-only channel", func() {
-		It("should error", func() {
-			openChannel := make(chan bool)
-			var openWriterChannel chan<- bool
-			openWriterChannel = openChannel
-
-			success, err := (&BeClosedMatcher{}).Match(openWriterChannel)
-			Ω(success).Should(BeFalse())
-			Ω(err).Should(HaveOccurred())
-
-			closedChannel := make(chan bool)
-			close(closedChannel)
-
-			var closedWriterChannel chan<- bool
-			closedWriterChannel = closedChannel
-
-			success, err = (&BeClosedMatcher{}).Match(closedWriterChannel)
-			Ω(success).Should(BeFalse())
-			Ω(err).Should(HaveOccurred())
-
-		})
-	})
-
-	Context("when passed something else", func() {
-		It("should error", func() {
-			var nilChannel chan bool
-
-			success, err := (&BeClosedMatcher{}).Match(nilChannel)
-			Ω(success).Should(BeFalse())
-			Ω(err).Should(HaveOccurred())
-
-			success, err = (&BeClosedMatcher{}).Match(nil)
-			Ω(success).Should(BeFalse())
-			Ω(err).Should(HaveOccurred())
-
-			success, err = (&BeClosedMatcher{}).Match(7)
-			Ω(success).Should(BeFalse())
-			Ω(err).Should(HaveOccurred())
-		})
-	})
-})
diff --git a/vendor/github.com/onsi/gomega/matchers/be_empty_matcher_test.go b/vendor/github.com/onsi/gomega/matchers/be_empty_matcher_test.go
deleted file mode 100644
index 541c1b9..0000000
--- a/vendor/github.com/onsi/gomega/matchers/be_empty_matcher_test.go
+++ /dev/null
@@ -1,52 +0,0 @@
-package matchers_test
-
-import (
-	. "github.com/onsi/ginkgo"
-	. "github.com/onsi/gomega"
-	. "github.com/onsi/gomega/matchers"
-)
-
-var _ = Describe("BeEmpty", func() {
-	Context("when passed a supported type", func() {
-		It("should do the right thing", func() {
-			Ω("").Should(BeEmpty())
-			Ω(" ").ShouldNot(BeEmpty())
-
-			Ω([0]int{}).Should(BeEmpty())
-			Ω([1]int{1}).ShouldNot(BeEmpty())
-
-			Ω([]int{}).Should(BeEmpty())
-			Ω([]int{1}).ShouldNot(BeEmpty())
-
-			Ω(map[string]int{}).Should(BeEmpty())
-			Ω(map[string]int{"a": 1}).ShouldNot(BeEmpty())
-
-			c := make(chan bool, 1)
-			Ω(c).Should(BeEmpty())
-			c <- true
-			Ω(c).ShouldNot(BeEmpty())
-		})
-	})
-
-	Context("when passed a correctly typed nil", func() {
-		It("should be true", func() {
-			var nilSlice []int
-			Ω(nilSlice).Should(BeEmpty())
-
-			var nilMap map[int]string
-			Ω(nilMap).Should(BeEmpty())
-		})
-	})
-
-	Context("when passed an unsupported type", func() {
-		It("should error", func() {
-			success, err := (&BeEmptyMatcher{}).Match(0)
-			Ω(success).Should(BeFalse())
-			Ω(err).Should(HaveOccurred())
-
-			success, err = (&BeEmptyMatcher{}).Match(nil)
-			Ω(success).Should(BeFalse())
-			Ω(err).Should(HaveOccurred())
-		})
-	})
-})
diff --git a/vendor/github.com/onsi/gomega/matchers/be_equivalent_to_matcher_test.go b/vendor/github.com/onsi/gomega/matchers/be_equivalent_to_matcher_test.go
deleted file mode 100644
index def5104..0000000
--- a/vendor/github.com/onsi/gomega/matchers/be_equivalent_to_matcher_test.go
+++ /dev/null
@@ -1,50 +0,0 @@
-package matchers_test
-
-import (
-	. "github.com/onsi/ginkgo"
-	. "github.com/onsi/gomega"
-	. "github.com/onsi/gomega/matchers"
-)
-
-var _ = Describe("BeEquivalentTo", func() {
-	Context("when asserting that nil is equivalent to nil", func() {
-		It("should error", func() {
-			success, err := (&BeEquivalentToMatcher{Expected: nil}).Match(nil)
-
-			Ω(success).Should(BeFalse())
-			Ω(err).Should(HaveOccurred())
-		})
-	})
-
-	Context("When asserting on nil", func() {
-		It("should do the right thing", func() {
-			Ω("foo").ShouldNot(BeEquivalentTo(nil))
-			Ω(nil).ShouldNot(BeEquivalentTo(3))
-			Ω([]int{1, 2}).ShouldNot(BeEquivalentTo(nil))
-		})
-	})
-
-	Context("When asserting on type aliases", func() {
-		It("should the right thing", func() {
-			Ω(StringAlias("foo")).Should(BeEquivalentTo("foo"))
-			Ω("foo").Should(BeEquivalentTo(StringAlias("foo")))
-			Ω(StringAlias("foo")).ShouldNot(BeEquivalentTo("bar"))
-			Ω("foo").ShouldNot(BeEquivalentTo(StringAlias("bar")))
-		})
-	})
-
-	Context("When asserting on numbers", func() {
-		It("should convert actual to expected and do the right thing", func() {
-			Ω(5).Should(BeEquivalentTo(5))
-			Ω(5.0).Should(BeEquivalentTo(5.0))
-			Ω(5).Should(BeEquivalentTo(5.0))
-
-			Ω(5).ShouldNot(BeEquivalentTo("5"))
-			Ω(5).ShouldNot(BeEquivalentTo(3))
-
-			//Here be dragons!
-			Ω(5.1).Should(BeEquivalentTo(5))
-			Ω(5).ShouldNot(BeEquivalentTo(5.1))
-		})
-	})
-})
diff --git a/vendor/github.com/onsi/gomega/matchers/be_false_matcher_test.go b/vendor/github.com/onsi/gomega/matchers/be_false_matcher_test.go
deleted file mode 100644
index 3965a2c..0000000
--- a/vendor/github.com/onsi/gomega/matchers/be_false_matcher_test.go
+++ /dev/null
@@ -1,20 +0,0 @@
-package matchers_test
-
-import (
-	. "github.com/onsi/ginkgo"
-	. "github.com/onsi/gomega"
-	. "github.com/onsi/gomega/matchers"
-)
-
-var _ = Describe("BeFalse", func() {
-	It("should handle true and false correctly", func() {
-		Ω(true).ShouldNot(BeFalse())
-		Ω(false).Should(BeFalse())
-	})
-
-	It("should only support booleans", func() {
-		success, err := (&BeFalseMatcher{}).Match("foo")
-		Ω(success).Should(BeFalse())
-		Ω(err).Should(HaveOccurred())
-	})
-})
diff --git a/vendor/github.com/onsi/gomega/matchers/be_identical_to_test.go b/vendor/github.com/onsi/gomega/matchers/be_identical_to_test.go
deleted file mode 100644
index 8b90a1a..0000000
--- a/vendor/github.com/onsi/gomega/matchers/be_identical_to_test.go
+++ /dev/null
@@ -1,61 +0,0 @@
-package matchers_test
-
-import (
-	"errors"
-
-	. "github.com/onsi/ginkgo"
-	. "github.com/onsi/gomega"
-	. "github.com/onsi/gomega/matchers"
-)
-
-var _ = Describe("BeIdenticalTo", func() {
-	Context("when asserting that nil equals nil", func() {
-		It("should error", func() {
-			success, err := (&BeIdenticalToMatcher{Expected: nil}).Match(nil)
-
-			Ω(success).Should(BeFalse())
-			Ω(err).Should(HaveOccurred())
-		})
-	})
-
-	It("should treat the same pointer to a struct as identical", func() {
-		mySpecialStruct := myCustomType{}
-		Ω(&mySpecialStruct).Should(BeIdenticalTo(&mySpecialStruct))
-		Ω(&myCustomType{}).ShouldNot(BeIdenticalTo(&mySpecialStruct))
-	})
-
-	It("should be strict about types", func() {
-		Ω(5).ShouldNot(BeIdenticalTo("5"))
-		Ω(5).ShouldNot(BeIdenticalTo(5.0))
-		Ω(5).ShouldNot(BeIdenticalTo(3))
-	})
-
-	It("should treat primtives as identical", func() {
-		Ω("5").Should(BeIdenticalTo("5"))
-		Ω("5").ShouldNot(BeIdenticalTo("55"))
-
-		Ω(5.55).Should(BeIdenticalTo(5.55))
-		Ω(5.55).ShouldNot(BeIdenticalTo(6.66))
-
-		Ω(5).Should(BeIdenticalTo(5))
-		Ω(5).ShouldNot(BeIdenticalTo(55))
-	})
-
-	It("should treat the same pointers to a slice as identical", func() {
-		mySlice := []int{1, 2}
-		Ω(&mySlice).Should(BeIdenticalTo(&mySlice))
-		Ω(&mySlice).ShouldNot(BeIdenticalTo(&[]int{1, 2}))
-	})
-
-	It("should treat the same pointers to a map as identical", func() {
-		myMap := map[string]string{"a": "b", "c": "d"}
-		Ω(&myMap).Should(BeIdenticalTo(&myMap))
-		Ω(myMap).ShouldNot(BeIdenticalTo(map[string]string{"a": "b", "c": "d"}))
-	})
-
-	It("should treat the same pointers to an error as identical", func() {
-		myError := errors.New("foo")
-		Ω(&myError).Should(BeIdenticalTo(&myError))
-		Ω(errors.New("foo")).ShouldNot(BeIdenticalTo(errors.New("bar")))
-	})
-})
diff --git a/vendor/github.com/onsi/gomega/matchers/be_nil_matcher_test.go b/vendor/github.com/onsi/gomega/matchers/be_nil_matcher_test.go
deleted file mode 100644
index 7533253..0000000
--- a/vendor/github.com/onsi/gomega/matchers/be_nil_matcher_test.go
+++ /dev/null
@@ -1,28 +0,0 @@
-package matchers_test
-
-import (
-	. "github.com/onsi/ginkgo"
-	. "github.com/onsi/gomega"
-)
-
-var _ = Describe("BeNil", func() {
-	It("should succeed when passed nil", func() {
-		Ω(nil).Should(BeNil())
-	})
-
-	It("should succeed when passed a typed nil", func() {
-		var a []int
-		Ω(a).Should(BeNil())
-	})
-
-	It("should succeed when passing nil pointer", func() {
-		var f *struct{}
-		Ω(f).Should(BeNil())
-	})
-
-	It("should not succeed when not passed nil", func() {
-		Ω(0).ShouldNot(BeNil())
-		Ω(false).ShouldNot(BeNil())
-		Ω("").ShouldNot(BeNil())
-	})
-})
diff --git a/vendor/github.com/onsi/gomega/matchers/be_numerically_matcher_test.go b/vendor/github.com/onsi/gomega/matchers/be_numerically_matcher_test.go
deleted file mode 100644
index 43fdb1f..0000000
--- a/vendor/github.com/onsi/gomega/matchers/be_numerically_matcher_test.go
+++ /dev/null
@@ -1,148 +0,0 @@
-package matchers_test
-
-import (
-	. "github.com/onsi/ginkgo"
-	. "github.com/onsi/gomega"
-	. "github.com/onsi/gomega/matchers"
-)
-
-var _ = Describe("BeNumerically", func() {
-	Context("when passed a number", func() {
-		It("should support ==", func() {
-			Ω(uint32(5)).Should(BeNumerically("==", 5))
-			Ω(float64(5.0)).Should(BeNumerically("==", 5))
-			Ω(int8(5)).Should(BeNumerically("==", 5))
-		})
-
-		It("should not have false positives", func() {
-			Ω(5.1).ShouldNot(BeNumerically("==", 5))
-			Ω(5).ShouldNot(BeNumerically("==", 5.1))
-		})
-
-		It("should support >", func() {
-			Ω(uint32(5)).Should(BeNumerically(">", 4))
-			Ω(float64(5.0)).Should(BeNumerically(">", 4.9))
-			Ω(int8(5)).Should(BeNumerically(">", 4))
-
-			Ω(uint32(5)).ShouldNot(BeNumerically(">", 5))
-			Ω(float64(5.0)).ShouldNot(BeNumerically(">", 5.0))
-			Ω(int8(5)).ShouldNot(BeNumerically(">", 5))
-		})
-
-		It("should support <", func() {
-			Ω(uint32(5)).Should(BeNumerically("<", 6))
-			Ω(float64(5.0)).Should(BeNumerically("<", 5.1))
-			Ω(int8(5)).Should(BeNumerically("<", 6))
-
-			Ω(uint32(5)).ShouldNot(BeNumerically("<", 5))
-			Ω(float64(5.0)).ShouldNot(BeNumerically("<", 5.0))
-			Ω(int8(5)).ShouldNot(BeNumerically("<", 5))
-		})
-
-		It("should support >=", func() {
-			Ω(uint32(5)).Should(BeNumerically(">=", 4))
-			Ω(float64(5.0)).Should(BeNumerically(">=", 4.9))
-			Ω(int8(5)).Should(BeNumerically(">=", 4))
-
-			Ω(uint32(5)).Should(BeNumerically(">=", 5))
-			Ω(float64(5.0)).Should(BeNumerically(">=", 5.0))
-			Ω(int8(5)).Should(BeNumerically(">=", 5))
-
-			Ω(uint32(5)).ShouldNot(BeNumerically(">=", 6))
-			Ω(float64(5.0)).ShouldNot(BeNumerically(">=", 5.1))
-			Ω(int8(5)).ShouldNot(BeNumerically(">=", 6))
-		})
-
-		It("should support <=", func() {
-			Ω(uint32(5)).Should(BeNumerically("<=", 6))
-			Ω(float64(5.0)).Should(BeNumerically("<=", 5.1))
-			Ω(int8(5)).Should(BeNumerically("<=", 6))
-
-			Ω(uint32(5)).Should(BeNumerically("<=", 5))
-			Ω(float64(5.0)).Should(BeNumerically("<=", 5.0))
-			Ω(int8(5)).Should(BeNumerically("<=", 5))
-
-			Ω(uint32(5)).ShouldNot(BeNumerically("<=", 4))
-			Ω(float64(5.0)).ShouldNot(BeNumerically("<=", 4.9))
-			Ω(int8(5)).Should(BeNumerically("<=", 5))
-		})
-
-		Context("when passed ~", func() {
-			Context("when passed a float", func() {
-				Context("and there is no precision parameter", func() {
-					It("should default to 1e-8", func() {
-						Ω(5.00000001).Should(BeNumerically("~", 5.00000002))
-						Ω(5.00000001).ShouldNot(BeNumerically("~", 5.0000001))
-					})
-				})
-
-				Context("and there is a precision parameter", func() {
-					It("should use the precision parameter", func() {
-						Ω(5.1).Should(BeNumerically("~", 5.19, 0.1))
-						Ω(5.1).Should(BeNumerically("~", 5.01, 0.1))
-						Ω(5.1).ShouldNot(BeNumerically("~", 5.22, 0.1))
-						Ω(5.1).ShouldNot(BeNumerically("~", 4.98, 0.1))
-					})
-				})
-			})
-
-			Context("when passed an int/uint", func() {
-				Context("and there is no precision parameter", func() {
-					It("should just do strict equality", func() {
-						Ω(5).Should(BeNumerically("~", 5))
-						Ω(5).ShouldNot(BeNumerically("~", 6))
-						Ω(uint(5)).ShouldNot(BeNumerically("~", 6))
-					})
-				})
-
-				Context("and there is a precision parameter", func() {
-					It("should use precision paramter", func() {
-						Ω(5).Should(BeNumerically("~", 6, 2))
-						Ω(5).ShouldNot(BeNumerically("~", 8, 2))
-						Ω(uint(5)).Should(BeNumerically("~", 6, 1))
-					})
-				})
-			})
-		})
-	})
-
-	Context("when passed a non-number", func() {
-		It("should error", func() {
-			success, err := (&BeNumericallyMatcher{Comparator: "==", CompareTo: []interface{}{5}}).Match("foo")
-			Ω(success).Should(BeFalse())
-			Ω(err).Should(HaveOccurred())
-
-			success, err = (&BeNumericallyMatcher{Comparator: "=="}).Match(5)
-			Ω(success).Should(BeFalse())
-			Ω(err).Should(HaveOccurred())
-
-			success, err = (&BeNumericallyMatcher{Comparator: "~", CompareTo: []interface{}{3.0, "foo"}}).Match(5.0)
-			Ω(success).Should(BeFalse())
-			Ω(err).Should(HaveOccurred())
-
-			success, err = (&BeNumericallyMatcher{Comparator: "==", CompareTo: []interface{}{"bar"}}).Match(5)
-			Ω(success).Should(BeFalse())
-			Ω(err).Should(HaveOccurred())
-
-			success, err = (&BeNumericallyMatcher{Comparator: "==", CompareTo: []interface{}{"bar"}}).Match("foo")
-			Ω(success).Should(BeFalse())
-			Ω(err).Should(HaveOccurred())
-
-			success, err = (&BeNumericallyMatcher{Comparator: "==", CompareTo: []interface{}{nil}}).Match(0)
-			Ω(success).Should(BeFalse())
-			Ω(err).Should(HaveOccurred())
-
-			success, err = (&BeNumericallyMatcher{Comparator: "==", CompareTo: []interface{}{0}}).Match(nil)
-			Ω(success).Should(BeFalse())
-			Ω(err).Should(HaveOccurred())
-		})
-	})
-
-	Context("when passed an unsupported comparator", func() {
-		It("should error", func() {
-			success, err := (&BeNumericallyMatcher{Comparator: "!=", CompareTo: []interface{}{5}}).Match(4)
-			Ω(success).Should(BeFalse())
-			Ω(err).Should(HaveOccurred())
-		})
-	})
-})
diff --git a/vendor/github.com/onsi/gomega/matchers/be_sent_matcher_test.go b/vendor/github.com/onsi/gomega/matchers/be_sent_matcher_test.go
deleted file mode 100644
index 205d71f..0000000
--- a/vendor/github.com/onsi/gomega/matchers/be_sent_matcher_test.go
+++ /dev/null
@@ -1,106 +0,0 @@
-package matchers_test
-
-import (
-	. "github.com/onsi/gomega/matchers"
-	"time"
-
-	. "github.com/onsi/ginkgo"
-	. "github.com/onsi/gomega"
-)
-
-var _ = Describe("BeSent", func() {
-	Context("when passed a channel and a matching type", func() {
-		Context("when the channel is ready to receive", func() {
-			It("should succeed and send the value down the channel", func() {
-				c := make(chan string)
-				d := make(chan string)
-				go func() {
-					val := <-c
-					d <- val
-				}()
-
-				time.Sleep(10 * time.Millisecond)
-
-				Ω(c).Should(BeSent("foo"))
-				Eventually(d).Should(Receive(Equal("foo")))
-			})
-
-			It("should succeed (with a buffered channel)", func() {
-				c := make(chan string, 1)
-				Ω(c).Should(BeSent("foo"))
-				Ω(<-c).Should(Equal("foo"))
-			})
-		})
-
-		Context("when the channel is not ready to receive", func() {
-			It("should fail and not send down the channel", func() {
-				c := make(chan string)
-				Ω(c).ShouldNot(BeSent("foo"))
-				Consistently(c).ShouldNot(Receive())
-			})
-		})
-
-		Context("when the channel is eventually ready to receive", func() {
-			It("should succeed", func() {
-				c := make(chan string)
-				d := make(chan string)
-				go func() {
-					time.Sleep(30 * time.Millisecond)
-					val := <-c
-					d <- val
-				}()
-
-				Eventually(c).Should(BeSent("foo"))
-				Eventually(d).Should(Receive(Equal("foo")))
-			})
-		})
-
-		Context("when the channel is closed", func() {
-			It("should error", func() {
-				c := make(chan string)
-				close(c)
-				success, err := (&BeSentMatcher{Arg: "foo"}).Match(c)
-				Ω(success).Should(BeFalse())
-				Ω(err).Should(HaveOccurred())
-			})
-
-			It("should short-circuit Eventually", func() {
-				c := make(chan string)
-				close(c)
-
-				t := time.Now()
-				failures := InterceptGomegaFailures(func() {
-					Eventually(c, 10.0).Should(BeSent("foo"))
-				})
-				Ω(failures).Should(HaveLen(1))
-				Ω(time.Since(t)).Should(BeNumerically("<", time.Second))
-			})
-		})
-	})
-
-	Context("when passed a channel and a non-matching type", func() {
-		It("should error", func() {
-			success, err := (&BeSentMatcher{Arg: "foo"}).Match(make(chan int, 1))
-			Ω(success).Should(BeFalse())
-			Ω(err).Should(HaveOccurred())
-		})
-	})
-
-	Context("when passed a receive-only channel", func() {
-		It("should error", func() {
-			var c <-chan string
-			c = make(chan string, 1)
-			success, err := (&BeSentMatcher{Arg: "foo"}).Match(c)
-			Ω(success).Should(BeFalse())
-			Ω(err).Should(HaveOccurred())
-		})
-	})
-
-	Context("when passed a nonchannel", func() {
-		It("should error", func() {
-			success, err := (&BeSentMatcher{Arg: "foo"}).Match("bar")
-			Ω(success).Should(BeFalse())
-			Ω(err).Should(HaveOccurred())
-		})
-	})
-})
diff --git a/vendor/github.com/onsi/gomega/matchers/be_temporally_matcher_test.go b/vendor/github.com/onsi/gomega/matchers/be_temporally_matcher_test.go
deleted file mode 100644
index feb33e5..0000000
--- a/vendor/github.com/onsi/gomega/matchers/be_temporally_matcher_test.go
+++ /dev/null
@@ -1,98 +0,0 @@
-package matchers_test
-
-import (
-	. "github.com/onsi/ginkgo"
-	. "github.com/onsi/gomega"
-	. "github.com/onsi/gomega/matchers"
-	"time"
-)
-
-var _ = Describe("BeTemporally", func() {
-
-	var t0, t1, t2 time.Time
-	BeforeEach(func() {
-		t0 = time.Now()
-		t1 = t0.Add(time.Second)
-		t2 = t0.Add(-time.Second)
-	})
-
-	Context("When comparing times", func() {
-
-		It("should support ==", func() {
-			Ω(t0).Should(BeTemporally("==", t0))
-			Ω(t1).ShouldNot(BeTemporally("==", t0))
-			Ω(t0).ShouldNot(BeTemporally("==", t1))
-			Ω(t0).ShouldNot(BeTemporally("==", time.Time{}))
-		})
-
-		It("should support >", func() {
-			Ω(t0).Should(BeTemporally(">", t2))
-			Ω(t0).ShouldNot(BeTemporally(">", t0))
-			Ω(t2).ShouldNot(BeTemporally(">", t0))
-		})
-
-		It("should support <", func() {
-			Ω(t0).Should(BeTemporally("<", t1))
-			Ω(t0).ShouldNot(BeTemporally("<", t0))
-			Ω(t1).ShouldNot(BeTemporally("<", t0))
-		})
-
-		It("should support >=", func() {
-			Ω(t0).Should(BeTemporally(">=", t2))
-			Ω(t0).Should(BeTemporally(">=", t0))
-			Ω(t0).ShouldNot(BeTemporally(">=", t1))
-		})
-
-		It("should support <=", func() {
-			Ω(t0).Should(BeTemporally("<=", t1))
-			Ω(t0).Should(BeTemporally("<=", t0))
-			Ω(t0).ShouldNot(BeTemporally("<=", t2))
-		})
-
-		Context("when passed ~", func() {
-			Context("and there is no precision parameter", func() {
-				BeforeEach(func() {
-					t1 = t0.Add(time.Millisecond / 2)
-					t2 = t0.Add(-2 * time.Millisecond)
-				})
-				It("should approximate", func() {
-					Ω(t0).Should(BeTemporally("~", t0))
-					Ω(t0).Should(BeTemporally("~", t1))
-					Ω(t0).ShouldNot(BeTemporally("~", t2))
-				})
-			})
-
-			Context("and there is a precision parameter", func() {
-				BeforeEach(func() {
-					t2 = t0.Add(3 * time.Second)
-				})
-				It("should use precision paramter", func() {
-					d := 2 * time.Second
-					Ω(t0).Should(BeTemporally("~", t0, d))
-					Ω(t0).Should(BeTemporally("~", t1, d))
-					Ω(t0).ShouldNot(BeTemporally("~", t2, d))
-				})
-			})
-		})
-	})
-
-	Context("when passed a non-time", func() {
-		It("should error", func() {
-			success, err := (&BeTemporallyMatcher{Comparator: "==", CompareTo: t0}).Match("foo")
-			Ω(success).Should(BeFalse())
-			Ω(err).Should(HaveOccurred())
-
-			success, err = (&BeTemporallyMatcher{Comparator: "=="}).Match(nil)
-			Ω(success).Should(BeFalse())
-			Ω(err).Should(HaveOccurred())
-		})
-	})
-
-	Context("when passed an unsupported comparator", func() {
-		It("should error", func() {
-			success, err := (&BeTemporallyMatcher{Comparator: "!=", CompareTo: t0}).Match(t2)
-			Ω(success).Should(BeFalse())
-			Ω(err).Should(HaveOccurred())
-		})
-	})
-})
diff --git a/vendor/github.com/onsi/gomega/matchers/be_true_matcher_test.go b/vendor/github.com/onsi/gomega/matchers/be_true_matcher_test.go
deleted file mode 100644
index ca32e56..0000000
--- a/vendor/github.com/onsi/gomega/matchers/be_true_matcher_test.go
+++ /dev/null
@@ -1,20 +0,0 @@
-package matchers_test
-
-import (
-	. "github.com/onsi/ginkgo"
-	. "github.com/onsi/gomega"
-	. "github.com/onsi/gomega/matchers"
-)
-
-var _ = Describe("BeTrue", func() {
-	It("should handle true and false correctly", func() {
-		Ω(true).Should(BeTrue())
-		Ω(false).ShouldNot(BeTrue())
-	})
-
-	It("should only support booleans", func() {
-		success, err := (&BeTrueMatcher{}).Match("foo")
-		Ω(success).Should(BeFalse())
-		Ω(err).Should(HaveOccurred())
-	})
-})
diff --git a/vendor/github.com/onsi/gomega/matchers/be_zero_matcher_test.go b/vendor/github.com/onsi/gomega/matchers/be_zero_matcher_test.go
deleted file mode 100644
index 8ec3643..0000000
--- a/vendor/github.com/onsi/gomega/matchers/be_zero_matcher_test.go
+++ /dev/null
@@ -1,30 +0,0 @@
-package matchers_test
-
-import (
-	. "github.com/onsi/ginkgo"
-	. "github.com/onsi/gomega"
-)
-
-var _ = Describe("BeZero", func() {
-	It("should succeed if the passed in object is the zero value for its type", func() {
-		Ω(nil).Should(BeZero())
-
-		Ω("").Should(BeZero())
-		Ω(" ").ShouldNot(BeZero())
-
-		Ω(0).Should(BeZero())
-		Ω(1).ShouldNot(BeZero())
-
-		Ω(0.0).Should(BeZero())
-		Ω(0.1).ShouldNot(BeZero())
-
-		// Ω([]int{}).Should(BeZero())
-		Ω([]int{1}).ShouldNot(BeZero())
-
-		// Ω(map[string]int{}).Should(BeZero())
-		Ω(map[string]int{"a": 1}).ShouldNot(BeZero())
-
-		Ω(myCustomType{}).Should(BeZero())
-		Ω(myCustomType{s: "a"}).ShouldNot(BeZero())
-	})
-})
diff --git a/vendor/github.com/onsi/gomega/matchers/consist_of_test.go b/vendor/github.com/onsi/gomega/matchers/consist_of_test.go
deleted file mode 100644
index dcd1afe..0000000
--- a/vendor/github.com/onsi/gomega/matchers/consist_of_test.go
+++ /dev/null
@@ -1,75 +0,0 @@
-package matchers_test
-
-import (
-	. "github.com/onsi/ginkgo"
-	. "github.com/onsi/gomega"
-)
-
-var _ = Describe("ConsistOf", func() {
-	Context("with a slice", func() {
-		It("should do the right thing", func() {
-			Ω([]string{"foo", "bar", "baz"}).Should(ConsistOf("foo", "bar", "baz"))
-			Ω([]string{"foo", "bar", "baz"}).Should(ConsistOf("foo", "bar", "baz"))
-			Ω([]string{"foo", "bar", "baz"}).Should(ConsistOf("baz", "bar", "foo"))
-			Ω([]string{"foo", "bar", "baz"}).ShouldNot(ConsistOf("baz", "bar", "foo", "foo"))
-			Ω([]string{"foo", "bar", "baz"}).ShouldNot(ConsistOf("baz", "foo"))
-		})
-	})
-
-	Context("with an array", func() {
-		It("should do the right thing", func() {
-			Ω([3]string{"foo", "bar", "baz"}).Should(ConsistOf("foo", "bar", "baz"))
-			Ω([3]string{"foo", "bar", "baz"}).Should(ConsistOf("baz", "bar", "foo"))
-			Ω([3]string{"foo", "bar", "baz"}).ShouldNot(ConsistOf("baz", "bar", "foo", "foo"))
-			Ω([3]string{"foo", "bar", "baz"}).ShouldNot(ConsistOf("baz", "foo"))
-		})
-	})
-
-	Context("with a map", func() {
-		It("should apply to the values", func() {
-			Ω(map[int]string{1: "foo", 2: "bar", 3: "baz"}).Should(ConsistOf("foo", "bar", "baz"))
-			Ω(map[int]string{1: "foo", 2: "bar", 3: "baz"}).Should(ConsistOf("baz", "bar", "foo"))
-			Ω(map[int]string{1: "foo", 2: "bar", 3: "baz"}).ShouldNot(ConsistOf("baz", "bar", "foo", "foo"))
-			Ω(map[int]string{1: "foo", 2: "bar", 3: "baz"}).ShouldNot(ConsistOf("baz", "foo"))
-		})
-
-	})
-
-	Context("with anything else", func() {
-		It("should error", func() {
-			failures := InterceptGomegaFailures(func() {
-				Ω("foo").Should(ConsistOf("f", "o", "o"))
-			})
-
-			Ω(failures).Should(HaveLen(1))
-		})
-	})
-
-	Context("when passed matchers", func() {
-		It("should pass if the matchers pass", func() {
-			Ω([]string{"foo", "bar", "baz"}).Should(ConsistOf("foo", MatchRegexp("^ba"), "baz"))
-			Ω([]string{"foo", "bar", "baz"}).ShouldNot(ConsistOf("foo", MatchRegexp("^ba")))
-			Ω([]string{"foo", "bar", "baz"}).ShouldNot(ConsistOf("foo", MatchRegexp("^ba"), MatchRegexp("foo")))
-			Ω([]string{"foo", "bar", "baz"}).Should(ConsistOf("foo", MatchRegexp("^ba"), MatchRegexp("^ba")))
-			Ω([]string{"foo", "bar", "baz"}).ShouldNot(ConsistOf("foo", MatchRegexp("^ba"), MatchRegexp("turducken")))
-		})
-
-		It("should not depend on the order of the matchers", func() {
-			Ω([][]int{[]int{1, 2}, []int{2}}).Should(ConsistOf(ContainElement(1), ContainElement(2)))
-			Ω([][]int{[]int{1, 2}, []int{2}}).Should(ConsistOf(ContainElement(2), ContainElement(1)))
-		})
-
-		Context("when a matcher errors", func() {
-			It("should soldier on", func() {
-				Ω([]string{"foo", "bar", "baz"}).ShouldNot(ConsistOf(BeFalse(), "foo", "bar"))
-				Ω([]interface{}{"foo", "bar", false}).Should(ConsistOf(BeFalse(), ContainSubstring("foo"), "bar"))
-			})
-		})
-	})
-
-	Context("when passed exactly one argument, and that argument is a slice", func() {
-		It("should match against the elements of that argument", func() {
-			Ω([]string{"foo", "bar", "baz"}).Should(ConsistOf([]string{"foo", "bar", "baz"}))
-		})
-	})
-})
diff --git a/vendor/github.com/onsi/gomega/matchers/contain_element_matcher_test.go b/vendor/github.com/onsi/gomega/matchers/contain_element_matcher_test.go
deleted file mode 100644
index 38ee518..0000000
--- a/vendor/github.com/onsi/gomega/matchers/contain_element_matcher_test.go
+++ /dev/null
@@ -1,76 +0,0 @@
-package matchers_test
-
-import (
-	. "github.com/onsi/ginkgo"
-	. "github.com/onsi/gomega"
-	. "github.com/onsi/gomega/matchers"
-)
-
-var _ = Describe("ContainElement", func() {
-	Context("when passed a supported type", func() {
-		Context("and expecting a non-matcher", func() {
-			It("should do the right thing", func() {
-				Ω([2]int{1, 2}).Should(ContainElement(2))
-				Ω([2]int{1, 2}).ShouldNot(ContainElement(3))
-
-				Ω([]int{1, 2}).Should(ContainElement(2))
-				Ω([]int{1, 2}).ShouldNot(ContainElement(3))
-
-				Ω(map[string]int{"foo": 1, "bar": 2}).Should(ContainElement(2))
-				Ω(map[int]int{3: 1, 4: 2}).ShouldNot(ContainElement(3))
-
-				arr := make([]myCustomType, 2)
-				arr[0] = myCustomType{s: "foo", n: 3, f: 2.0, arr: []string{"a", "b"}}
-				arr[1] = myCustomType{s: "foo", n: 3, f: 2.0, arr: []string{"a", "c"}}
-				Ω(arr).Should(ContainElement(myCustomType{s: "foo", n: 3, f: 2.0, arr: []string{"a", "b"}}))
-				Ω(arr).ShouldNot(ContainElement(myCustomType{s: "foo", n: 3, f: 2.0, arr: []string{"b", "c"}}))
-			})
-		})
-
-		Context("and expecting a matcher", func() {
-			It("should pass each element through the matcher", func() {
-				Ω([]int{1, 2, 3}).Should(ContainElement(BeNumerically(">=", 3)))
-				Ω([]int{1, 2, 3}).ShouldNot(ContainElement(BeNumerically(">", 3)))
-				Ω(map[string]int{"foo": 1, "bar": 2}).Should(ContainElement(BeNumerically(">=", 2)))
-				Ω(map[string]int{"foo": 1, "bar": 2}).ShouldNot(ContainElement(BeNumerically(">", 2)))
-			})
-
-			It("should power through even if the matcher ever fails", func() {
-				Ω([]interface{}{1, 2, "3", 4}).Should(ContainElement(BeNumerically(">=", 3)))
-			})
-
-			It("should fail if the matcher fails", func() {
-				actual := []interface{}{1, 2, "3", "4"}
-				success, err := (&ContainElementMatcher{Element: BeNumerically(">=", 3)}).Match(actual)
-				Ω(success).Should(BeFalse())
-				Ω(err).Should(HaveOccurred())
-			})
-		})
-	})
-
-	Context("when passed a correctly typed nil", func() {
-		It("should operate succesfully on the passed in value", func() {
-			var nilSlice []int
-			Ω(nilSlice).ShouldNot(ContainElement(1))
-
-			var nilMap map[int]string
-			Ω(nilMap).ShouldNot(ContainElement("foo"))
-		})
-	})
-
-	Context("when passed an unsupported type", func() {
-		It("should error", func() {
-			success, err := (&ContainElementMatcher{Element: 0}).Match(0)
-			Ω(success).Should(BeFalse())
-			Ω(err).Should(HaveOccurred())
-
-			success, err = (&ContainElementMatcher{Element: 0}).Match("abc")
-			Ω(success).Should(BeFalse())
-			Ω(err).Should(HaveOccurred())
-
-			success, err = (&ContainElementMatcher{Element: 0}).Match(nil)
-			Ω(success).Should(BeFalse())
-			Ω(err).Should(HaveOccurred())
-		})
-	})
-})
diff --git a/vendor/github.com/onsi/gomega/matchers/contain_substring_matcher_test.go b/vendor/github.com/onsi/gomega/matchers/contain_substring_matcher_test.go
deleted file mode 100644
index 6935168..0000000
--- a/vendor/github.com/onsi/gomega/matchers/contain_substring_matcher_test.go
+++ /dev/null
@@ -1,36 +0,0 @@
-package matchers_test
-
-import (
-	. "github.com/onsi/ginkgo"
-	. "github.com/onsi/gomega"
-	. "github.com/onsi/gomega/matchers"
-)
-
-var _ = Describe("ContainSubstringMatcher", func() {
-	Context("when actual is a string", func() {
-		It("should match against the string", func() {
-			Ω("Marvelous").Should(ContainSubstring("rve"))
-			Ω("Marvelous").ShouldNot(ContainSubstring("boo"))
-		})
-	})
-
-	Context("when the matcher is called with multiple arguments", func() {
-		It("should pass the string and arguments to sprintf", func() {
-			Ω("Marvelous3").Should(ContainSubstring("velous%d", 3))
-		})
-	})
-
-	Context("when actual is a stringer", func() {
-		It("should call the stringer and match agains the returned string", func() {
-			Ω(&myStringer{a: "Abc3"}).Should(ContainSubstring("bc3"))
-		})
-	})
-
-	Context("when actual is neither a string nor a stringer", func() {
-		It("should error", func() {
-			success, err := (&ContainSubstringMatcher{Substr: "2"}).Match(2)
-			Ω(success).Should(BeFalse())
-			Ω(err).Should(HaveOccurred())
-		})
-	})
-})
diff --git a/vendor/github.com/onsi/gomega/matchers/equal_matcher_test.go b/vendor/github.com/onsi/gomega/matchers/equal_matcher_test.go
deleted file mode 100644
index 2add0b7..0000000
--- a/vendor/github.com/onsi/gomega/matchers/equal_matcher_test.go
+++ /dev/null
@@ -1,78 +0,0 @@
-package matchers_test
-
-import (
-	"errors"
-	"strings"
-
-	. "github.com/onsi/ginkgo"
-	. "github.com/onsi/gomega"
-	. "github.com/onsi/gomega/matchers"
-)
-
-var _ = Describe("Equal", func() {
-	Context("when asserting that nil equals nil", func() {
-		It("should error", func() {
-			success, err := (&EqualMatcher{Expected: nil}).Match(nil)
-
-			Ω(success).Should(BeFalse())
-			Ω(err).Should(HaveOccurred())
-		})
-	})
-
-	Context("When asserting equality between objects", func() {
-		It("should do the right thing", func() {
-			Ω(5).Should(Equal(5))
-			Ω(5.0).Should(Equal(5.0))
-
-			Ω(5).ShouldNot(Equal("5"))
-			Ω(5).ShouldNot(Equal(5.0))
-			Ω(5).ShouldNot(Equal(3))
-
-			Ω("5").Should(Equal("5"))
-			Ω([]int{1, 2}).Should(Equal([]int{1, 2}))
-			Ω([]int{1, 2}).ShouldNot(Equal([]int{2, 1}))
-			Ω(map[string]string{"a": "b", "c": "d"}).Should(Equal(map[string]string{"a": "b", "c": "d"}))
-			Ω(map[string]string{"a": "b", "c": "d"}).ShouldNot(Equal(map[string]string{"a": "b", "c": "e"}))
-			Ω(errors.New("foo")).Should(Equal(errors.New("foo")))
-			Ω(errors.New("foo")).ShouldNot(Equal(errors.New("bar")))
-
-			Ω(myCustomType{s: "foo", n: 3, f: 2.0, arr: []string{"a", "b"}}).Should(Equal(myCustomType{s: "foo", n: 3, f: 2.0, arr: []string{"a", "b"}}))
-			Ω(myCustomType{s: "foo", n: 3, f: 2.0, arr: []string{"a", "b"}}).ShouldNot(Equal(myCustomType{s: "bar", n: 3, f: 2.0, arr: []string{"a", "b"}}))
-			Ω(myCustomType{s: "foo", n: 3, f: 2.0, arr: []string{"a", "b"}}).ShouldNot(Equal(myCustomType{s: "foo", n: 2, f: 2.0, arr: []string{"a", "b"}}))
-			Ω(myCustomType{s: "foo", n: 3, f: 2.0, arr: []string{"a", "b"}}).ShouldNot(Equal(myCustomType{s: "foo", n: 3, f: 3.0, arr: []string{"a", "b"}}))
-			Ω(myCustomType{s: "foo", n: 3, f: 2.0, arr: []string{"a", "b"}}).ShouldNot(Equal(myCustomType{s: "foo", n: 3, f: 2.0, arr: []string{"a", "b", "c"}}))
-		})
-	})
-
-	Describe("failure messages", func() {
-		It("shows the two strings simply when they are short", func() {
-			subject := EqualMatcher{Expected: "eric"}
-
-			failureMessage := subject.FailureMessage("tim")
-			Ω(failureMessage).To(BeEquivalentTo(expectedShortStringFailureMessage))
-		})
-
-		It("shows the exact point where two long strings differ", func() {
-			stringWithB := "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaabaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
-			stringWithZ := "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaazaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
-
-			subject := EqualMatcher{Expected: stringWithZ}
-
-			failureMessage := subject.FailureMessage(stringWithB)
-			Ω(failureMessage).To(BeEquivalentTo(expectedLongStringFailureMessage))
-		})
-	})
-})
-
-var expectedShortStringFailureMessage = strings.TrimSpace(`
-Expected
-    <string>: tim
-to equal
-    <string>: eric
-`)
-var expectedLongStringFailureMessage = strings.TrimSpace(`
-Expected
-    <string>: "...aaaaabaaaaa..."
-to equal               |
-    <string>: "...aaaaazaaaaa..."
-`)
diff --git a/vendor/github.com/onsi/gomega/matchers/have_cap_matcher_test.go b/vendor/github.com/onsi/gomega/matchers/have_cap_matcher_test.go
deleted file mode 100644
index a92a177..0000000
--- a/vendor/github.com/onsi/gomega/matchers/have_cap_matcher_test.go
+++ /dev/null
@@ -1,50 +0,0 @@
-package matchers_test
-
-import (
-	. "github.com/onsi/ginkgo"
-	. "github.com/onsi/gomega"
-	. "github.com/onsi/gomega/matchers"
-)
-
-var _ = Describe("HaveCap", func() {
-	Context("when passed a supported type", func() {
-		It("should do the right thing", func() {
-			Ω([0]int{}).Should(HaveCap(0))
-			Ω([2]int{1}).Should(HaveCap(2))
-
-			Ω([]int{}).Should(HaveCap(0))
-			Ω([]int{1, 2, 3, 4, 5}[:2]).Should(HaveCap(5))
-			Ω(make([]int, 0, 5)).Should(HaveCap(5))
-
-			c := make(chan bool, 3)
-			Ω(c).Should(HaveCap(3))
-			c <- true
-			c <- true
-			Ω(c).Should(HaveCap(3))
-
-			Ω(make(chan bool)).Should(HaveCap(0))
-		})
-	})
-
-	Context("when passed a correctly typed nil", func() {
-		It("should operate succesfully on the passed in value", func() {
-			var nilSlice []int
-			Ω(nilSlice).Should(HaveCap(0))
-
-			var nilChan chan int
-			Ω(nilChan).Should(HaveCap(0))
-		})
-	})
-
-	Context("when passed an unsupported type", func() {
-		It("should error", func() {
-			success, err := (&HaveCapMatcher{Count: 0}).Match(0)
-			Ω(success).Should(BeFalse())
-			Ω(err).Should(HaveOccurred())
-
-			success, err = (&HaveCapMatcher{Count: 0}).Match(nil)
-			Ω(success).Should(BeFalse())
-			Ω(err).Should(HaveOccurred())
-		})
-	})
-})
diff --git a/vendor/github.com/onsi/gomega/matchers/have_key_matcher_test.go b/vendor/github.com/onsi/gomega/matchers/have_key_matcher_test.go
deleted file mode 100644
index c663e30..0000000
--- a/vendor/github.com/onsi/gomega/matchers/have_key_matcher_test.go
+++ /dev/null
@@ -1,73 +0,0 @@
-package matchers_test
-
-import (
-	. "github.com/onsi/ginkgo"
-	. "github.com/onsi/gomega"
-	. "github.com/onsi/gomega/matchers"
-)
-
-var _ = Describe("HaveKey", func() {
-	var (
-		stringKeys map[string]int
-		intKeys    map[int]string
-		objKeys    map[*myCustomType]string
-
-		customA *myCustomType
-		customB *myCustomType
-	)
-	BeforeEach(func() {
-		stringKeys = map[string]int{"foo": 2, "bar": 3}
-		intKeys = map[int]string{2: "foo", 3: "bar"}
-
-		customA = &myCustomType{s: "a", n: 2, f: 2.3, arr: []string{"ice", "cream"}}
-		customB = &myCustomType{s: "b", n: 4, f: 3.1, arr: []string{"cake"}}
-		objKeys = map[*myCustomType]string{customA: "aardvark", customB: "kangaroo"}
-	})
-
-	Context("when passed a map", func() {
-		It("should do the right thing", func() {
-			Ω(stringKeys).Should(HaveKey("foo"))
-			Ω(stringKeys).ShouldNot(HaveKey("baz"))
-
-			Ω(intKeys).Should(HaveKey(2))
-			Ω(intKeys).ShouldNot(HaveKey(4))
-
-			Ω(objKeys).Should(HaveKey(customA))
-			Ω(objKeys).Should(HaveKey(&myCustomType{s: "b", n: 4, f: 3.1, arr: []string{"cake"}}))
-			Ω(objKeys).ShouldNot(HaveKey(&myCustomType{s: "b", n: 4, f: 3.1, arr: []string{"apple", "pie"}}))
-		})
-	})
-
-	Context("when passed a correctly typed nil", func() {
-		It("should operate succesfully on the passed in value", func() {
-			var nilMap map[int]string
-			Ω(nilMap).ShouldNot(HaveKey("foo"))
-		})
-	})
-
-	Context("when the passed in key is actually a matcher", func() {
-		It("should pass each element through the matcher", func() {
-			Ω(stringKeys).Should(HaveKey(ContainSubstring("oo")))
-			Ω(stringKeys).ShouldNot(HaveKey(ContainSubstring("foobar")))
-		})
-
-		It("should fail if the matcher ever fails", func() {
-			actual := map[int]string{1: "a", 3: "b", 2: "c"}
-			success, err := (&HaveKeyMatcher{Key: ContainSubstring("ar")}).Match(actual)
-			Ω(success).Should(BeFalse())
-			Ω(err).Should(HaveOccurred())
-		})
-	})
-
-	Context("when passed something that is not a map", func() {
-		It("should error", func() {
-			success, err := (&HaveKeyMatcher{Key: "foo"}).Match([]string{"foo"})
-			Ω(success).Should(BeFalse())
-			Ω(err).Should(HaveOccurred())
-
-			success, err = (&HaveKeyMatcher{Key: "foo"}).Match(nil)
-			Ω(success).Should(BeFalse())
-			Ω(err).Should(HaveOccurred())
-		})
-	})
-})
diff --git a/vendor/github.com/onsi/gomega/matchers/have_key_with_value_matcher_test.go b/vendor/github.com/onsi/gomega/matchers/have_key_with_value_matcher_test.go
deleted file mode 100644
index 06a2242..0000000
--- a/vendor/github.com/onsi/gomega/matchers/have_key_with_value_matcher_test.go
+++ /dev/null
@@ -1,82 +0,0 @@
-package matchers_test
-
-import (
-	. "github.com/onsi/ginkgo"
-	. "github.com/onsi/gomega"
-	. "github.com/onsi/gomega/matchers"
-)
-
-var _ = Describe("HaveKeyWithValue", func() {
-	var (
-		stringKeys map[string]int
-		intKeys    map[int]string
-		objKeys    map[*myCustomType]*myCustomType
-
-		customA *myCustomType
-		customB *myCustomType
-	)
-	BeforeEach(func() {
-		stringKeys = map[string]int{"foo": 2, "bar": 3}
-		intKeys = map[int]string{2: "foo", 3: "bar"}
-
-		customA = &myCustomType{s: "a", n: 2, f: 2.3, arr: []string{"ice", "cream"}}
-		customB = &myCustomType{s: "b", n: 4, f: 3.1, arr: []string{"cake"}}
-		objKeys = map[*myCustomType]*myCustomType{customA: customA, customB: customA}
-	})
-
-	Context("when passed a map", func() {
-		It("should do the right thing", func() {
-			Ω(stringKeys).Should(HaveKeyWithValue("foo", 2))
-			Ω(stringKeys).ShouldNot(HaveKeyWithValue("foo", 1))
-			Ω(stringKeys).ShouldNot(HaveKeyWithValue("baz", 2))
-			Ω(stringKeys).ShouldNot(HaveKeyWithValue("baz", 1))
-
-			Ω(intKeys).Should(HaveKeyWithValue(2, "foo"))
-			Ω(intKeys).ShouldNot(HaveKeyWithValue(4, "foo"))
-			Ω(intKeys).ShouldNot(HaveKeyWithValue(2, "baz"))
-
-			Ω(objKeys).Should(HaveKeyWithValue(customA, customA))
-			Ω(objKeys).Should(HaveKeyWithValue(&myCustomType{s: "b", n: 4, f: 3.1, arr: []string{"cake"}}, &myCustomType{s: "a", n: 2, f: 2.3, arr: []string{"ice", "cream"}}))
-			Ω(objKeys).ShouldNot(HaveKeyWithValue(&myCustomType{s: "b", n: 4, f: 3.1, arr: []string{"apple", "pie"}}, customA))
-		})
-	})
-
-	Context("when passed a correctly typed nil", func() {
-		It("should operate succesfully on the passed in value", func() {
-			var nilMap map[int]string
-			Ω(nilMap).ShouldNot(HaveKeyWithValue("foo", "bar"))
-		})
-	})
-
-	Context("when the passed in key or value is actually a matcher", func() {
-		It("should pass each element through the matcher", func() {
-			Ω(stringKeys).Should(HaveKeyWithValue(ContainSubstring("oo"), 2))
-			Ω(intKeys).Should(HaveKeyWithValue(2, ContainSubstring("oo")))
-			Ω(stringKeys).ShouldNot(HaveKeyWithValue(ContainSubstring("foobar"), 2))
-		})
-
-		It("should fail if the matcher ever fails", func() {
-			actual := map[int]string{1: "a", 3: "b", 2: "c"}
-			success, err := (&HaveKeyWithValueMatcher{Key: ContainSubstring("ar"), Value: 2}).Match(actual)
-			Ω(success).Should(BeFalse())
-			Ω(err).Should(HaveOccurred())
-
-			otherActual := map[string]int{"a": 1, "b": 2, "c": 3}
-			success, err = (&HaveKeyWithValueMatcher{Key: "a", Value: ContainSubstring("1")}).Match(otherActual)
-			Ω(success).Should(BeFalse())
-			Ω(err).Should(HaveOccurred())
-		})
-	})
-
-	Context("when passed something that is not a map", func() {
-		It("should error", func() {
-			success, err := (&HaveKeyWithValueMatcher{Key: "foo", Value: "bar"}).Match([]string{"foo"})
-			Ω(success).Should(BeFalse())
-			Ω(err).Should(HaveOccurred())
-
-			success, err = (&HaveKeyWithValueMatcher{Key: "foo", Value: "bar"}).Match(nil)
-			Ω(success).Should(BeFalse())
-			Ω(err).Should(HaveOccurred())
-		})
-	})
-})
diff --git a/vendor/github.com/onsi/gomega/matchers/have_len_matcher_test.go b/vendor/github.com/onsi/gomega/matchers/have_len_matcher_test.go
deleted file mode 100644
index 1e6aa69..0000000
--- a/vendor/github.com/onsi/gomega/matchers/have_len_matcher_test.go
+++ /dev/null
@@ -1,53 +0,0 @@
-package matchers_test
-
-import (
-	. "github.com/onsi/ginkgo"
-	. "github.com/onsi/gomega"
-	. "github.com/onsi/gomega/matchers"
-)
-
-var _ = Describe("HaveLen", func() {
-	Context("when passed a supported type", func() {
-		It("should do the right thing", func() {
-			Ω("").Should(HaveLen(0))
-			Ω("AA").Should(HaveLen(2))
-
-			Ω([0]int{}).Should(HaveLen(0))
-			Ω([2]int{1, 2}).Should(HaveLen(2))
-
-			Ω([]int{}).Should(HaveLen(0))
-			Ω([]int{1, 2, 3}).Should(HaveLen(3))
-
-			Ω(map[string]int{}).Should(HaveLen(0))
-			Ω(map[string]int{"a": 1, "b": 2, "c": 3, "d": 4}).Should(HaveLen(4))
-
-			c := make(chan bool, 3)
-			Ω(c).Should(HaveLen(0))
-			c <- true
-			c <- true
-			Ω(c).Should(HaveLen(2))
-		})
-	})
-
-	Context("when passed a correctly typed nil", func() {
-		It("should operate succesfully on the passed in value", func() {
-			var nilSlice []int
-			Ω(nilSlice).Should(HaveLen(0))
-
-			var nilMap map[int]string
-			Ω(nilMap).Should(HaveLen(0))
-		})
-	})
-
-	Context("when passed an unsupported type", func() {
-		It("should error", func() {
-			success, err := (&HaveLenMatcher{Count: 0}).Match(0)
-			Ω(success).Should(BeFalse())
-			Ω(err).Should(HaveOccurred())
-
-			success, err = (&HaveLenMatcher{Count: 0}).Match(nil)
-			Ω(success).Should(BeFalse())
-			Ω(err).Should(HaveOccurred())
-		})
-	})
-})
diff --git a/vendor/github.com/onsi/gomega/matchers/have_occurred_matcher_test.go b/vendor/github.com/onsi/gomega/matchers/have_occurred_matcher_test.go
deleted file mode 100644
index 009e23e..0000000
--- a/vendor/github.com/onsi/gomega/matchers/have_occurred_matcher_test.go
+++ /dev/null
@@ -1,58 +0,0 @@
-package matchers_test
-
-import (
-	"errors"
-	. "github.com/onsi/ginkgo"
-	. "github.com/onsi/gomega"
-	. "github.com/onsi/gomega/matchers"
-)
-
-type CustomErr struct {
-	msg string
-}
-
-func (e *CustomErr) Error() string {
-	return e.msg
-}
-
-var _ = Describe("HaveOccurred", func() {
-	It("should succeed if matching an error", func() {
-		Ω(errors.New("Foo")).Should(HaveOccurred())
-	})
-
-	It("should not succeed with nil", func() {
-		Ω(nil).ShouldNot(HaveOccurred())
-	})
-
-	It("should only support errors and nil", func() {
-		success, err := (&HaveOccurredMatcher{}).Match("foo")
-		Ω(success).Should(BeFalse())
-		Ω(err).Should(HaveOccurred())
-
-		success, err = (&HaveOccurredMatcher{}).Match("")
-		Ω(success).Should(BeFalse())
-		Ω(err).Should(HaveOccurred())
-	})
-
-	It("doesn't support non-error type", func() {
-		success, err := (&HaveOccurredMatcher{}).Match(AnyType{})
-		Ω(success).Should(BeFalse())
-		Ω(err).Should(MatchError("Expected an error-type.  Got:\n    <matchers_test.AnyType>: {}"))
-	})
-
-	It("doesn't support non-error pointer type", func() {
-		success, err := (&HaveOccurredMatcher{}).Match(&AnyType{})
-		Ω(success).Should(BeFalse())
-		Ω(err).Should(MatchError(MatchRegexp(`Expected an error-type.  Got:\n    <*matchers_test.AnyType | 0x[[:xdigit:]]+>: {}`)))
-	})
-
-	It("should succeed with pointer types that conform to error interface", func() {
-		err := &CustomErr{"ohai"}
-		Ω(err).Should(HaveOccurred())
-	})
-
-	It("should not succeed with nil pointers to types that conform to error interface", func() {
-		var err *CustomErr = nil
-		Ω(err).ShouldNot(HaveOccurred())
-	})
-})
diff --git a/vendor/github.com/onsi/gomega/matchers/have_prefix_matcher_test.go b/vendor/github.com/onsi/gomega/matchers/have_prefix_matcher_test.go
deleted file mode 100644
index bec3f97..0000000
--- a/vendor/github.com/onsi/gomega/matchers/have_prefix_matcher_test.go
+++ /dev/null
@@ -1,36 +0,0 @@
-package matchers_test
-
-import (
-	. "github.com/onsi/ginkgo"
-	. "github.com/onsi/gomega"
-	. "github.com/onsi/gomega/matchers"
-)
-
-var _ = Describe("HavePrefixMatcher", func() {
-	Context("when actual is a string", func() {
-		It("should match a string prefix", func() {
-			Ω("Ab").Should(HavePrefix("A"))
-			Ω("A").ShouldNot(HavePrefix("Ab"))
-		})
-	})
-
-	Context("when the matcher is called with multiple arguments", func() {
-		It("should pass the string and arguments to sprintf", func() {
-			Ω("C3PO").Should(HavePrefix("C%dP", 3))
-		})
-	})
-
-	Context("when actual is a stringer", func() {
-		It("should call the stringer and match against the returned string", func() {
-			Ω(&myStringer{a: "Ab"}).Should(HavePrefix("A"))
-		})
-	})
-
-	Context("when actual is neither a string nor a stringer", func() {
-		It("should error", func() {
-			success, err := (&HavePrefixMatcher{Prefix: "2"}).Match(2)
-			Ω(success).Should(BeFalse())
-			Ω(err).Should(HaveOccurred())
-		})
-	})
-})
diff --git a/vendor/github.com/onsi/gomega/matchers/have_suffix_matcher_test.go b/vendor/github.com/onsi/gomega/matchers/have_suffix_matcher_test.go
deleted file mode 100644
index 72e8975..0000000
--- a/vendor/github.com/onsi/gomega/matchers/have_suffix_matcher_test.go
+++ /dev/null
@@ -1,36 +0,0 @@
-package matchers_test
-
-import (
-	. "github.com/onsi/ginkgo"
-	. "github.com/onsi/gomega"
-	. "github.com/onsi/gomega/matchers"
-)
-
-var _ = Describe("HaveSuffixMatcher", func() {
-	Context("when actual is a string", func() {
-		It("should match a string suffix", func() {
-			Ω("Ab").Should(HaveSuffix("b"))
-			Ω("A").ShouldNot(HaveSuffix("Ab"))
-		})
-	})
-
-	Context("when the matcher is called with multiple arguments", func() {
-		It("should pass the string and arguments to sprintf", func() {
-			Ω("C3PO").Should(HaveSuffix("%dPO", 3))
-		})
-	})
-
-	Context("when actual is a stringer", func() {
-		It("should call the stringer and match against the returned string", func() {
-			Ω(&myStringer{a: "Ab"}).Should(HaveSuffix("b"))
-		})
-	})
-
-	Context("when actual is neither a string nor a stringer", func() {
-		It("should error", func() {
-			success, err := (&HaveSuffixMatcher{Suffix: "2"}).Match(2)
-			Ω(success).Should(BeFalse())
-			Ω(err).Should(HaveOccurred())
-		})
-	})
-})
diff --git a/vendor/github.com/onsi/gomega/matchers/match_error_matcher_test.go b/vendor/github.com/onsi/gomega/matchers/match_error_matcher_test.go
deleted file mode 100644
index 338b512..0000000
--- a/vendor/github.com/onsi/gomega/matchers/match_error_matcher_test.go
+++ /dev/null
@@ -1,93 +0,0 @@
-package matchers_test
-
-import (
-	"errors"
-	"fmt"
-	. "github.com/onsi/ginkgo"
-	. "github.com/onsi/gomega"
-	. "github.com/onsi/gomega/matchers"
-)
-
-type CustomError struct {
-}
-
-func (c CustomError) Error() string {
-	return "an error"
-}
-
-var _ = Describe("MatchErrorMatcher", func() {
-	Context("When asserting against an error", func() {
-		It("should succeed when matching with an error", func() {
-			err := errors.New("an error")
-			fmtErr := fmt.Errorf("an error")
-			customErr := CustomError{}
-
-			Ω(err).Should(MatchError(errors.New("an error")))
-			Ω(err).ShouldNot(MatchError(errors.New("another error")))
-
-			Ω(fmtErr).Should(MatchError(errors.New("an error")))
-			Ω(customErr).Should(MatchError(CustomError{}))
-		})
-
-		It("should succeed when matching with a string", func() {
-			err := errors.New("an error")
-			fmtErr := fmt.Errorf("an error")
-			customErr := CustomError{}
-
-			Ω(err).Should(MatchError("an error"))
-			Ω(err).ShouldNot(MatchError("another error"))
-
-			Ω(fmtErr).Should(MatchError("an error"))
-			Ω(customErr).Should(MatchError("an error"))
-		})
-
-		Context("when passed a matcher", func() {
-			It("should pass if the matcher passes against the error string", func() {
-				err := errors.New("error 123 abc")
-
-				Ω(err).Should(MatchError(MatchRegexp(`\d{3}`)))
-			})
-
-			It("should fail if the matcher fails against the error string", func() {
-				err := errors.New("no digits")
-				Ω(err).ShouldNot(MatchError(MatchRegexp(`\d`)))
-			})
-		})
-
-		It("should fail when passed anything else", func() {
-			actualErr := errors.New("an error")
-			_, err := (&MatchErrorMatcher{
-				Expected: []byte("an error"),
-			}).Match(actualErr)
-			Ω(err).Should(HaveOccurred())
-
-			_, err = (&MatchErrorMatcher{
-				Expected: 3,
-			}).Match(actualErr)
-			Ω(err).Should(HaveOccurred())
-		})
-	})
-
-	Context("when passed nil", func() {
-		It("should fail", func() {
-			_, err := (&MatchErrorMatcher{
-				Expected: "an error",
-			}).Match(nil)
-			Ω(err).Should(HaveOccurred())
-		})
-	})
-
-	Context("when passed a non-error", func() {
-		It("should fail", func() {
-			_, err := (&MatchErrorMatcher{
-				Expected: "an error",
-			}).Match("an error")
-			Ω(err).Should(HaveOccurred())
-
-			_, err = (&MatchErrorMatcher{
-				Expected: "an error",
-			}).Match(3)
-			Ω(err).Should(HaveOccurred())
-		})
-	})
-})
diff --git a/vendor/github.com/onsi/gomega/matchers/match_json_matcher_test.go b/vendor/github.com/onsi/gomega/matchers/match_json_matcher_test.go
deleted file mode 100644
index 755c4ad..0000000
--- a/vendor/github.com/onsi/gomega/matchers/match_json_matcher_test.go
+++ /dev/null
@@ -1,73 +0,0 @@
-package matchers_test
-
-import (
-	. "github.com/onsi/ginkgo"
-	. "github.com/onsi/gomega"
-	. "github.com/onsi/gomega/matchers"
-)
-
-var _ = Describe("MatchJSONMatcher", func() {
-	Context("When passed stringifiables", func() {
-		It("should succeed if the JSON matches", func() {
-			Ω("{}").Should(MatchJSON("{}"))
-			Ω(`{"a":1}`).Should(MatchJSON(`{"a":1}`))
-			Ω(`{
-			             "a":1
-			         }`).Should(MatchJSON(`{"a":1}`))
-			Ω(`{"a":1, "b":2}`).Should(MatchJSON(`{"b":2, "a":1}`))
-			Ω(`{"a":1}`).ShouldNot(MatchJSON(`{"b":2, "a":1}`))
-		})
-
-		It("should work with byte arrays", func() {
-			Ω([]byte("{}")).Should(MatchJSON([]byte("{}")))
-			Ω("{}").Should(MatchJSON([]byte("{}")))
-			Ω([]byte("{}")).Should(MatchJSON("{}"))
-		})
-	})
-
-	Context("when the expected is not valid JSON", func() {
-		It("should error and explain why", func() {
-			success, err := (&MatchJSONMatcher{JSONToMatch: `{}`}).Match(`oops`)
-			Ω(success).Should(BeFalse())
-			Ω(err).Should(HaveOccurred())
-			Ω(err.Error()).Should(ContainSubstring("Actual 'oops' should be valid JSON"))
-		})
-	})
-
-	Context("when the actual is not valid JSON", func() {
-		It("should error and explain why", func() {
-			success, err := (&MatchJSONMatcher{JSONToMatch: `oops`}).Match(`{}`)
-			Ω(success).Should(BeFalse())
-			Ω(err).Should(HaveOccurred())
-			Ω(err.Error()).Should(ContainSubstring("Expected 'oops' should be valid JSON"))
-		})
-	})
-
-	Context("when the expected is neither a string nor a stringer nor a byte array", func() {
-		It("should error", func() {
-			success, err := (&MatchJSONMatcher{JSONToMatch: 2}).Match("{}")
-			Ω(success).Should(BeFalse())
-			Ω(err).Should(HaveOccurred())
-			Ω(err.Error()).Should(ContainSubstring("MatchJSONMatcher matcher requires a string, stringer, or []byte.  Got expected:\n    <int>: 2"))
-
-			success, err = (&MatchJSONMatcher{JSONToMatch: nil}).Match("{}")
-			Ω(success).Should(BeFalse())
-			Ω(err).Should(HaveOccurred())
-			Ω(err.Error()).Should(ContainSubstring("MatchJSONMatcher matcher requires a string, stringer, or []byte.  Got expected:\n    <nil>: nil"))
-		})
-	})
-
-	Context("when the actual is neither a string nor a stringer nor a byte array", func() {
-		It("should error", func() {
-			success, err := (&MatchJSONMatcher{JSONToMatch: "{}"}).Match(2)
-			Ω(success).Should(BeFalse())
-			Ω(err).Should(HaveOccurred())
-			Ω(err.Error()).Should(ContainSubstring("MatchJSONMatcher matcher requires a string, stringer, or []byte.  Got actual:\n    <int>: 2"))
-
-			success, err = (&MatchJSONMatcher{JSONToMatch: "{}"}).Match(nil)
-			Ω(success).Should(BeFalse())
-			Ω(err).Should(HaveOccurred())
-			Ω(err.Error()).Should(ContainSubstring("MatchJSONMatcher matcher requires a string, stringer, or []byte.  Got actual:\n    <nil>: nil"))
-		})
-	})
-})
diff --git a/vendor/github.com/onsi/gomega/matchers/match_regexp_matcher_test.go b/vendor/github.com/onsi/gomega/matchers/match_regexp_matcher_test.go
deleted file mode 100644
index bb521cc..0000000
--- a/vendor/github.com/onsi/gomega/matchers/match_regexp_matcher_test.go
+++ /dev/null
@@ -1,44 +0,0 @@
-package matchers_test
-
-import (
-	. "github.com/onsi/ginkgo"
-	. "github.com/onsi/gomega"
-	. "github.com/onsi/gomega/matchers"
-)
-
-var _ = Describe("MatchRegexp", func() {
-	Context("when actual is a string", func() {
-		It("should match against the string", func() {
-			Ω(" a2!bla").Should(MatchRegexp(`\d!`))
-			Ω(" a2!bla").ShouldNot(MatchRegexp(`[A-Z]`))
-		})
-	})
-
-	Context("when actual is a stringer", func() {
-		It("should call the stringer and match agains the returned string", func() {
-			Ω(&myStringer{a: "Abc3"}).Should(MatchRegexp(`[A-Z][a-z]+\d`))
-		})
-	})
-
-	Context("when the matcher is called with multiple arguments", func() {
-		It("should pass the string and arguments to sprintf", func() {
-			Ω(" a23!bla").Should(MatchRegexp(`\d%d!`, 3))
-		})
-	})
-
-	Context("when actual is neither a string nor a stringer", func() {
-		It("should error", func() {
-			success, err := (&MatchRegexpMatcher{Regexp: `\d`}).Match(2)
-			Ω(success).Should(BeFalse())
-			Ω(err).Should(HaveOccurred())
-		})
-	})
-
-	Context("when the passed in regexp fails to compile", func() {
-		It("should error", func() {
-			success, err := (&MatchRegexpMatcher{Regexp: "("}).Match("Foo")
-			Ω(success).Should(BeFalse())
-			Ω(err).Should(HaveOccurred())
-		})
-	})
-})
diff --git a/vendor/github.com/onsi/gomega/matchers/match_yaml_matcher_test.go b/vendor/github.com/onsi/gomega/matchers/match_yaml_matcher_test.go
deleted file mode 100644
index 8e63de1..0000000
--- a/vendor/github.com/onsi/gomega/matchers/match_yaml_matcher_test.go
+++ /dev/null
@@ -1,94 +0,0 @@
-package matchers_test
-
-import (
-	. "github.com/onsi/ginkgo"
-	. "github.com/onsi/gomega"
-
-	. "github.com/onsi/gomega/matchers"
-)
-
-var _ = Describe("MatchYAMLMatcher", func() {
-	Context("When passed stringifiables", func() {
-		It("should succeed if the YAML matches", func() {
-			Expect("---").Should(MatchYAML(""))
-			Expect("a: 1").Should(MatchYAML(`{"a":1}`))
-			Expect("a: 1\nb: 2").Should(MatchYAML(`{"b":2, "a":1}`))
-		})
-
-		It("should explain if the YAML does not match when it should", func() {
-			message := (&MatchYAMLMatcher{YAMLToMatch: "a: 1"}).FailureMessage("b: 2")
-			Expect(message).To(MatchRegexp(`Expected\s+<string>: b: 2\s+to match YAML of\s+<string>: a: 1`))
-		})
-
-		It("should normalise the expected and actual when explaining if the YAML does not match when it should", func() {
-			message := (&MatchYAMLMatcher{YAMLToMatch: "a: 'one'"}).FailureMessage("{b: two}")
-			Expect(message).To(MatchRegexp(`Expected\s+<string>: b: two\s+to match YAML of\s+<string>: a: one`))
-		})
-
-		It("should explain if the YAML matches when it should not", func() {
-			message := (&MatchYAMLMatcher{YAMLToMatch: "a: 1"}).NegatedFailureMessage("a: 1")
-			Expect(message).To(MatchRegexp(`Expected\s+<string>: a: 1\s+not to match YAML of\s+<string>: a: 1`))
-		})
-
-		It("should normalise the expected and actual when explaining if the YAML matches when it should not", func() {
-			message := (&MatchYAMLMatcher{YAMLToMatch: "a: 'one'"}).NegatedFailureMessage("{a: one}")
-			Expect(message).To(MatchRegexp(`Expected\s+<string>: a: one\s+not to match YAML of\s+<string>: a: one`))
-		})
-
-		It("should fail if the YAML does not match", func() {
-			Expect("a: 1").ShouldNot(MatchYAML(`{"b":2, "a":1}`))
-		})
-
-		It("should work with byte arrays", func() {
-			Expect([]byte("a: 1")).Should(MatchYAML([]byte("a: 1")))
-			Expect("a: 1").Should(MatchYAML([]byte("a: 1")))
-			Expect([]byte("a: 1")).Should(MatchYAML("a: 1"))
-		})
-	})
-
-	Context("when the expected is not valid YAML", func() {
-		It("should error and explain why", func() {
-			success, err := (&MatchYAMLMatcher{YAMLToMatch: ""}).Match("good:\nbad")
-			Expect(success).Should(BeFalse())
-			Expect(err).Should(HaveOccurred())
-			Expect(err.Error()).Should(ContainSubstring("Actual 'good:\nbad' should be valid YAML"))
-		})
-	})
-
-	Context("when the actual is not valid YAML", func() {
-		It("should error and explain why", func() {
-			success, err := (&MatchYAMLMatcher{YAMLToMatch: "good:\nbad"}).Match("")
-			Expect(success).Should(BeFalse())
-			Expect(err).Should(HaveOccurred())
-			Expect(err.Error()).Should(ContainSubstring("Expected 'good:\nbad' should be valid YAML"))
-		})
-	})
-
-	Context("when the expected is neither a string nor a stringer nor a byte array", func() {
-		It("should error", func() {
-			success, err := (&MatchYAMLMatcher{YAMLToMatch: 2}).Match("")
-			Expect(success).Should(BeFalse())
-			Expect(err).Should(HaveOccurred())
-			Expect(err.Error()).Should(ContainSubstring("MatchYAMLMatcher matcher requires a string, stringer, or []byte.  Got expected:\n    <int>: 2"))
-
-			success, err = (&MatchYAMLMatcher{YAMLToMatch: nil}).Match("")
-			Expect(success).Should(BeFalse())
-			Expect(err).Should(HaveOccurred())
-			Expect(err.Error()).Should(ContainSubstring("MatchYAMLMatcher matcher requires a string, stringer, or []byte.  Got expected:\n    <nil>: nil"))
-		})
-	})
-
-	Context("when the actual is neither a string nor a stringer nor a byte array", func() {
-		It("should error", func() {
-			success, err := (&MatchYAMLMatcher{YAMLToMatch: ""}).Match(2)
-			Expect(success).Should(BeFalse())
-			Expect(err).Should(HaveOccurred())
-			Expect(err.Error()).Should(ContainSubstring("MatchYAMLMatcher matcher requires a string, stringer, or []byte.  Got actual:\n    <int>: 2"))
-
-			success, err = (&MatchYAMLMatcher{YAMLToMatch: ""}).Match(nil)
-			Expect(success).Should(BeFalse())
-			Expect(err).Should(HaveOccurred())
-			Expect(err.Error()).Should(ContainSubstring("MatchYAMLMatcher matcher requires a string, stringer, or []byte.  Got actual:\n    <nil>: nil"))
-		})
-	})
-})
diff --git a/vendor/github.com/onsi/gomega/matchers/matcher_tests_suite_test.go b/vendor/github.com/onsi/gomega/matchers/matcher_tests_suite_test.go
deleted file mode 100644
index 01b11b9..0000000
--- a/vendor/github.com/onsi/gomega/matchers/matcher_tests_suite_test.go
+++ /dev/null
@@ -1,30 +0,0 @@
-package matchers_test
-
-import (
-	"testing"
-
-	. "github.com/onsi/ginkgo"
-	. "github.com/onsi/gomega"
-)
-
-type myStringer struct {
-	a string
-}
-
-func (s *myStringer) String() string {
-	return s.a
-}
-
-type StringAlias string
-
-type myCustomType struct {
-	s   string
-	n   int
-	f   float32
-	arr []string
-}
-
-func Test(t *testing.T) {
-	RegisterFailHandler(Fail)
-	RunSpecs(t, "Gomega Matchers")
-}
diff --git a/vendor/github.com/onsi/gomega/matchers/not_test.go b/vendor/github.com/onsi/gomega/matchers/not_test.go
deleted file mode 100644
index b3c1fdb..0000000
--- a/vendor/github.com/onsi/gomega/matchers/not_test.go
+++ /dev/null
@@ -1,57 +0,0 @@
-package matchers_test
-
-import (
-	. "github.com/onsi/ginkgo"
-	. "github.com/onsi/gomega"
-	. "github.com/onsi/gomega/matchers"
-)
-
-var _ = Describe("NotMatcher", func() {
-	Context("basic examples", func() {
-		It("works", func() {
-			Expect(input).To(Not(false1))
-			Expect(input).To(Not(Not(true2)))
-			Expect(input).ToNot(Not(true3))
-			Expect(input).ToNot(Not(Not(false1)))
-			Expect(input).To(Not(Not(Not(false2))))
-		})
-	})
-
-	Context("De Morgan's laws", func() {
-		It("~(A && B) == ~A || ~B", func() {
-			Expect(input).To(Not(And(false1, false2)))
-			Expect(input).To(Or(Not(false1), Not(false2)))
-		})
-		It("~(A || B) == ~A && ~B", func() {
-			Expect(input).To(Not(Or(false1, false2)))
-			Expect(input).To(And(Not(false1), Not(false2)))
-		})
-	})
-
-	Context("failure messages are opposite of original matchers' failure messages", func() {
-		Context("when match fails", func() {
-			It("gives a descriptive message", func() {
-				verifyFailureMessage(Not(HaveLen(2)), input, "not to have length 2")
-			})
-		})
-
-		Context("when match succeeds, but expected it to fail", func() {
-			It("gives a descriptive message", func() {
-				verifyFailureMessage(Not(Not(HaveLen(3))), input, "to have length 3")
-			})
-		})
-	})
-
-	Context("MatchMayChangeInTheFuture()", func() {
-		It("Propagates value from wrapped matcher", func() {
-			m := Not(Or()) // an empty Or() always returns false, and indicates it cannot change
-			Expect(m.Match("anything")).To(BeTrue())
-			Expect(m.(*NotMatcher).MatchMayChangeInTheFuture("anything")).To(BeFalse())
-		})
-		It("Defaults to true", func() {
-			m := Not(Equal(1)) // Equal does not have this method
-			Expect(m.Match(2)).To(BeTrue())
-			Expect(m.(*NotMatcher).MatchMayChangeInTheFuture(2)).To(BeTrue()) // defaults to true
-		})
-	})
-})
diff --git a/vendor/github.com/onsi/gomega/matchers/or_test.go b/vendor/github.com/onsi/gomega/matchers/or_test.go
deleted file mode 100644
index 9589a17..0000000
--- a/vendor/github.com/onsi/gomega/matchers/or_test.go
+++ /dev/null
@@ -1,85 +0,0 @@
-package matchers_test
-
-import (
-	. "github.com/onsi/ginkgo"
-	. "github.com/onsi/gomega"
-	. "github.com/onsi/gomega/matchers"
-)
-
-var _ = Describe("OrMatcher", func() {
-	It("works with positive cases", func() {
-		Expect(input).To(Or(true1))
-		Expect(input).To(Or(true1, true2))
-		Expect(input).To(Or(true1, false1))
-		Expect(input).To(Or(false1, true2))
-		Expect(input).To(Or(true1, true2, true3))
-		Expect(input).To(Or(true1, true2, false3))
-		Expect(input).To(Or(true1, false2, true3))
-		Expect(input).To(Or(false1, true2, true3))
-		Expect(input).To(Or(true1, false2, false3))
-		Expect(input).To(Or(false1, false2, true3))
-
-		// use alias
-		Expect(input).To(SatisfyAny(false1, false2, true3))
-	})
-
-	It("works with negative cases", func() {
-		Expect(input).ToNot(Or())
-		Expect(input).ToNot(Or(false1))
-		Expect(input).ToNot(Or(false1, false2))
-		Expect(input).ToNot(Or(false1, false2, false3))
-	})
-
-	Context("failure messages", func() {
-		Context("when match fails", func() {
-			It("gives a descriptive message", func() {
-				verifyFailureMessage(Or(false1, false2), input,
-					"To satisfy at least one of these matchers: [%!s(*matchers.HaveLenMatcher=&{1}) %!s(*matchers.EqualMatcher=&{hip})]")
-			})
-		})
-
-		Context("when match succeeds, but expected it to fail", func() {
-			It("gives a descriptive message", func() {
-				verifyFailureMessage(Not(Or(true1, true2)), input, `not to have length 2`)
-			})
-		})
-	})
-
-	Context("MatchMayChangeInTheFuture", func() {
-		Context("Match returned false", func() {
-			It("returns true if any of the matchers could change", func() {
-				// 3 matchers, all return false, and all could change
-				m := Or(BeNil(), Equal("hip"), HaveLen(1))
-				Expect(m.Match("hi")).To(BeFalse())
-				Expect(m.(*OrMatcher).MatchMayChangeInTheFuture("hi")).To(BeTrue()) // all 3 of these matchers default to 'true'
-			})
-			It("returns false if none of the matchers could change", func() {
-				// empty Or() has the property of never matching, and never can change since there are no sub-matchers that could change
-				m := Or()
-				Expect(m.Match("anything")).To(BeFalse())
-				Expect(m.(*OrMatcher).MatchMayChangeInTheFuture("anything")).To(BeFalse())
-
-				// Or() with 3 sub-matchers that return false, and can't change
-				m = Or(Or(), Or(), Or())
-				Expect(m.Match("hi")).To(BeFalse())
-				Expect(m.(*OrMatcher).MatchMayChangeInTheFuture("hi")).To(BeFalse()) // the 3 empty Or()'s won't change
-			})
-		})
-		Context("Match returned true", func() {
-			Context("returns value of the successful matcher", func() {
-				It("false if successful matcher not going to change", func() {
-					// 3 matchers: 1st returns false, 2nd returns true and is not going to change, 3rd is never called
-					m := Or(BeNil(), And(), Equal(1))
-					Expect(m.Match("hi")).To(BeTrue())
-					Expect(m.(*OrMatcher).MatchMayChangeInTheFuture("hi")).To(BeFalse())
-				})
-				It("true if successful matcher indicates it might change", func() {
-					// 3 matchers: 1st returns false, 2nd returns true and "might" change, 3rd is never called
-					m := Or(Not(BeNil()), Equal("hi"), Equal(1))
-					Expect(m.Match("hi")).To(BeTrue())
-					Expect(m.(*OrMatcher).MatchMayChangeInTheFuture("hi")).To(BeTrue()) // Equal("hi") indicates it might change
-				})
-			})
-		})
-	})
-})
diff --git a/vendor/github.com/onsi/gomega/matchers/panic_matcher_test.go b/vendor/github.com/onsi/gomega/matchers/panic_matcher_test.go
deleted file mode 100644
index 6b859a7..0000000
--- a/vendor/github.com/onsi/gomega/matchers/panic_matcher_test.go
+++ /dev/null
@@ -1,45 +0,0 @@
-package matchers_test
-
-import (
-	. "github.com/onsi/ginkgo"
-	. "github.com/onsi/gomega"
-	. "github.com/onsi/gomega/matchers"
-)
-
-var _ = Describe("Panic", func() {
-	Context("when passed something that's not a function that takes zero arguments and returns nothing", func() {
-		It("should error", func() {
-			success, err := (&PanicMatcher{}).Match("foo")
-			Ω(success).Should(BeFalse())
-			Ω(err).Should(HaveOccurred())
-
-			success, err = (&PanicMatcher{}).Match(nil)
-			Ω(success).Should(BeFalse())
-			Ω(err).Should(HaveOccurred())
-
-			success, err = (&PanicMatcher{}).Match(func(foo string) {})
-			Ω(success).Should(BeFalse())
-			Ω(err).Should(HaveOccurred())
-
-			success, err = (&PanicMatcher{}).Match(func() string { return "bar" })
-			Ω(success).Should(BeFalse())
-			Ω(err).Should(HaveOccurred())
-		})
-	})
-
-	Context("when passed a function of the correct type", func() {
-		It("should call the function and pass if the function panics", func() {
-			Ω(func() { panic("ack!") }).Should(Panic())
-			Ω(func() {}).ShouldNot(Panic())
-		})
-	})
-
-	Context("when assertion fails", func() {
-		It("should print the object passed to Panic", func() {
-			failuresMessages := InterceptGomegaFailures(func() {
-				Ω(func() { panic("ack!") }).ShouldNot(Panic())
-			})
-			Ω(failuresMessages).Should(ConsistOf(MatchRegexp("not to panic, but panicked with\\s*<string>: ack!")))
-		})
-	})
-})
diff --git a/vendor/github.com/onsi/gomega/matchers/receive_matcher_test.go b/vendor/github.com/onsi/gomega/matchers/receive_matcher_test.go
deleted file mode 100644
index 938c078..0000000
--- a/vendor/github.com/onsi/gomega/matchers/receive_matcher_test.go
+++ /dev/null
@@ -1,280 +0,0 @@
-package matchers_test
-
-import (
-	"time"
-
-	. "github.com/onsi/ginkgo"
-	. "github.com/onsi/gomega"
-	. "github.com/onsi/gomega/matchers"
-)
-
-type kungFuActor interface {
-	DrunkenMaster() bool
-}
-
-type jackie struct {
-	name string
-}
-
-func (j *jackie) DrunkenMaster() bool {
-	return true
-}
-
-var _ = Describe("ReceiveMatcher", func() {
-	Context("with no argument", func() {
-		Context("for a buffered channel", func() {
-			It("should succeed", func() {
-				channel := make(chan bool, 1)
-
-				Ω(channel).ShouldNot(Receive())
-
-				channel <- true
-
-				Ω(channel).Should(Receive())
-			})
-		})
-
-		Context("for an unbuffered channel", func() {
-			It("should succeed (eventually)", func() {
-				channel := make(chan bool)
-
-				Ω(channel).ShouldNot(Receive())
-
-				go func() {
-					time.Sleep(10 * time.Millisecond)
-					channel <- true
-				}()
-
-				Eventually(channel).Should(Receive())
-			})
-		})
-	})
-
-	Context("with a pointer argument", func() {
-		Context("of the correct type", func() {
-			It("should write the value received on the channel to the pointer", func() {
-				channel := make(chan int, 1)
-
-				var value int
-
-				Ω(channel).ShouldNot(Receive(&value))
-				Ω(value).Should(BeZero())
-
-				channel <- 17
-
-				Ω(channel).Should(Receive(&value))
-				Ω(value).Should(Equal(17))
-			})
-		})
-
-		Context("to various types of objects", func() {
-			It("should work", func() {
-				//channels of strings
-				stringChan := make(chan string, 1)
-				stringChan <- "foo"
-
-				var s string
-				Ω(stringChan).Should(Receive(&s))
-				Ω(s).Should(Equal("foo"))
-
-				//channels of slices
-				sliceChan := make(chan []bool, 1)
-				sliceChan <- []bool{true, true, false}
-
-				var sl []bool
-				Ω(sliceChan).Should(Receive(&sl))
-				Ω(sl).Should(Equal([]bool{true, true, false}))
-
-				//channels of channels
-				chanChan := make(chan chan bool, 1)
-				c := make(chan bool)
-				chanChan <- c
-
-				var receivedC chan bool
-				Ω(chanChan).Should(Receive(&receivedC))
-				Ω(receivedC).Should(Equal(c))
-
-				//channels of interfaces
-				jackieChan := make(chan kungFuActor, 1)
-				aJackie := &jackie{name: "Jackie Chan"}
-				jackieChan <- aJackie
-
-				var theJackie kungFuActor
-				Ω(jackieChan).Should(Receive(&theJackie))
-				Ω(theJackie).Should(Equal(aJackie))
-			})
-		})
-
-		Context("of the wrong type", func() {
-			It("should error", func() {
-				channel := make(chan int)
-				var incorrectType bool
-
-				success, err := (&ReceiveMatcher{Arg: &incorrectType}).Match(channel)
-				Ω(success).Should(BeFalse())
-				Ω(err).Should(HaveOccurred())
-
-				var notAPointer int
-				success, err = (&ReceiveMatcher{Arg: notAPointer}).Match(channel)
-				Ω(success).Should(BeFalse())
-				Ω(err).Should(HaveOccurred())
-			})
-		})
-	})
-
-	Context("with a matcher", func() {
-		It("should defer to the underlying matcher", func() {
-			intChannel := make(chan int, 1)
-			intChannel <- 3
-			Ω(intChannel).Should(Receive(Equal(3)))
-
-			intChannel <- 2
-			Ω(intChannel).ShouldNot(Receive(Equal(3)))
-
-			stringChannel := make(chan []string, 1)
-			stringChannel <- []string{"foo", "bar", "baz"}
-			Ω(stringChannel).Should(Receive(ContainElement(ContainSubstring("fo"))))
-
-			stringChannel <- []string{"foo", "bar", "baz"}
-			Ω(stringChannel).ShouldNot(Receive(ContainElement(ContainSubstring("archipelago"))))
-		})
-
-		It("should defer to the underlying matcher for the message", func() {
-			matcher := Receive(Equal(3))
-			channel := make(chan int, 1)
-			channel <- 2
-			matcher.Match(channel)
-			Ω(matcher.FailureMessage(channel)).Should(MatchRegexp(`Expected\s+<int>: 2\s+to equal\s+<int>: 3`))
-
-			channel <- 3
-			matcher.Match(channel)
-			Ω(matcher.NegatedFailureMessage(channel)).Should(MatchRegexp(`Expected\s+<int>: 3\s+not to equal\s+<int>: 3`))
-		})
-
-		It("should work just fine with Eventually", func() {
-			stringChannel := make(chan string)
-
-			go func() {
-				time.Sleep(5 * time.Millisecond)
-				stringChannel <- "A"
-				time.Sleep(5 * time.Millisecond)
-				stringChannel <- "B"
-			}()
-
-			Eventually(stringChannel).Should(Receive(Equal("B")))
-		})
-
-		Context("if the matcher errors", func() {
-			It("should error", func() {
-				channel := make(chan int, 1)
-				channel <- 3
-				success, err := (&ReceiveMatcher{Arg: ContainSubstring("three")}).Match(channel)
-				Ω(success).Should(BeFalse())
-				Ω(err).Should(HaveOccurred())
-			})
-		})
-
-		Context("if nothing is received", func() {
-			It("should fail", func() {
-				channel := make(chan int, 1)
-				success, err := (&ReceiveMatcher{Arg: Equal(1)}).Match(channel)
-				Ω(success).Should(BeFalse())
-				Ω(err).ShouldNot(HaveOccurred())
-			})
-		})
-	})
-
-	Context("When actual is a *closed* channel", func() {
-		Context("for a buffered channel", func() {
-			It("should work until it hits the end of the buffer", func() {
-				channel := make(chan bool, 1)
-				channel <- true
-
-				close(channel)
-
-				Ω(channel).Should(Receive())
-				Ω(channel).ShouldNot(Receive())
-			})
-		})
-
-		Context("for an unbuffered channel", func() {
-			It("should always fail", func() {
-				channel := make(chan bool)
-				close(channel)
-
-				Ω(channel).ShouldNot(Receive())
-			})
-		})
-	})
-
-	Context("When actual is a send-only channel", func() {
-		It("should error", func() {
-			channel := make(chan bool)
-
-			var writerChannel chan<- bool
-			writerChannel = channel
-
-			success, err := (&ReceiveMatcher{}).Match(writerChannel)
-			Ω(success).Should(BeFalse())
-			Ω(err).Should(HaveOccurred())
-		})
-	})
-
-	Context("when acutal is a non-channel", func() {
-		It("should error", func() {
-			var nilChannel chan bool
-
-			success, err := (&ReceiveMatcher{}).Match(nilChannel)
-			Ω(success).Should(BeFalse())
-			Ω(err).Should(HaveOccurred())
-
-			success, err = (&ReceiveMatcher{}).Match(nil)
-			Ω(success).Should(BeFalse())
-			Ω(err).Should(HaveOccurred())
-
-			success, err = (&ReceiveMatcher{}).Match(3)
-			Ω(success).Should(BeFalse())
-			Ω(err).Should(HaveOccurred())
-		})
-	})
-
-	Describe("when used with eventually and a custom matcher", func() {
-		It("should return the matcher's error when a failing value is received on the channel, instead of the must receive something failure", func() {
-			failures := InterceptGomegaFailures(func() {
-				c := make(chan string, 0)
-				Eventually(c, 0.01).Should(Receive(Equal("hello")))
-			})
-			Ω(failures[0]).Should(ContainSubstring("When passed a matcher, ReceiveMatcher's channel *must* receive something."))
-
-			failures = InterceptGomegaFailures(func() {
-				c := make(chan string, 1)
-				c <- "hi"
-				Eventually(c, 0.01).Should(Receive(Equal("hello")))
-			})
-			Ω(failures[0]).Should(ContainSubstring("<string>: hello"))
-		})
-	})
-
-	Describe("Bailing early", func() {
-		It("should bail early when passed a closed channel", func() {
-			c := make(chan bool)
-			close(c)
-
-			t := time.Now()
-			failures := InterceptGomegaFailures(func() {
-				Eventually(c).Should(Receive())
-			})
-			Ω(time.Since(t)).Should(BeNumerically("<", 500*time.Millisecond))
-			Ω(failures).Should(HaveLen(1))
-		})
-
-		It("should bail early when passed a non-channel", func() {
-			t := time.Now()
-			failures := InterceptGomegaFailures(func() {
-				Eventually(3).Should(Receive())
-			})
-			Ω(time.Since(t)).Should(BeNumerically("<", 500*time.Millisecond))
-			Ω(failures).Should(HaveLen(1))
-		})
-	})
-})
diff --git a/vendor/github.com/onsi/gomega/matchers/succeed_matcher_test.go b/vendor/github.com/onsi/gomega/matchers/succeed_matcher_test.go
deleted file mode 100644
index 6b62c8b..0000000
--- a/vendor/github.com/onsi/gomega/matchers/succeed_matcher_test.go
+++ /dev/null
@@ -1,62 +0,0 @@
-package matchers_test
-
-import (
-	"errors"
-
-	. "github.com/onsi/ginkgo"
-	. "github.com/onsi/gomega"
-	. "github.com/onsi/gomega/matchers"
-)
-
-func Erroring() error {
-	return errors.New("bam")
-}
-
-func NotErroring() error {
-	return nil
-}
-
-type AnyType struct{}
-
-func Invalid() *AnyType {
-	return nil
-}
-
-var _ = Describe("Succeed", func() {
-	It("should succeed if the function succeeds", func() {
-		Ω(NotErroring()).Should(Succeed())
-	})
-
-	It("should succeed (in the negated) if the function errored", func() {
-		Ω(Erroring()).ShouldNot(Succeed())
-	})
-
-	It("should not if passed a non-error", func() {
-		success, err := (&SucceedMatcher{}).Match(Invalid())
-		Ω(success).Should(BeFalse())
-		Ω(err).Should(MatchError("Expected an error-type.  Got:\n    <*matchers_test.AnyType | 0x0>: nil"))
-	})
-
-	It("doesn't support non-error type", func() {
-		success, err := (&SucceedMatcher{}).Match(AnyType{})
-		Ω(success).Should(BeFalse())
-		Ω(err).Should(MatchError("Expected an error-type.  Got:\n    <matchers_test.AnyType>: {}"))
-	})
-
-	It("doesn't support non-error pointer type", func() {
-		success, err := (&SucceedMatcher{}).Match(&AnyType{})
-		Ω(success).Should(BeFalse())
-		Ω(err).Should(MatchError(MatchRegexp(`Expected an error-type.  Got:\n    <*matchers_test.AnyType | 0x[[:xdigit:]]+>: {}`)))
-	})
-
-	It("should not succeed with pointer types that conform to error interface", func() {
-		err := &CustomErr{"ohai"}
-		Ω(err).ShouldNot(Succeed())
-	})
-
-	It("should succeed with nil pointers to types that conform to error interface", func() {
-		var err *CustomErr = nil
-		Ω(err).Should(Succeed())
-	})
-
-})
diff --git a/vendor/github.com/onsi/gomega/matchers/support/goraph/MIT.LICENSE b/vendor/github.com/onsi/gomega/matchers/support/goraph/MIT.LICENSE
deleted file mode 100644
index 8edd817..0000000
--- a/vendor/github.com/onsi/gomega/matchers/support/goraph/MIT.LICENSE
+++ /dev/null
@@ -1,20 +0,0 @@
-Copyright (c) 2014 Amit Kumar Gupta
-
-Permission is hereby granted, free of charge, to any person obtaining
-a copy of this software and associated documentation files (the
-"Software"), to deal in the Software without restriction, including
-without limitation the rights to use, copy, modify, merge, publish,
-distribute, sublicense, and/or sell copies of the Software, and to
-permit persons to whom the Software is furnished to do so, subject to
-the following conditions:
-
-The above copyright notice and this permission notice shall be
-included in all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
-LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
-OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
-WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
diff --git a/vendor/github.com/onsi/gomega/matchers/with_transform_test.go b/vendor/github.com/onsi/gomega/matchers/with_transform_test.go
deleted file mode 100644
index e52bf8e..0000000
--- a/vendor/github.com/onsi/gomega/matchers/with_transform_test.go
+++ /dev/null
@@ -1,102 +0,0 @@
-package matchers_test
-
-import (
-	"errors"
-
-	. "github.com/onsi/ginkgo"
-	. "github.com/onsi/gomega"
-	. "github.com/onsi/gomega/matchers"
-)
-
-var _ = Describe("WithTransformMatcher", func() {
-
-	var plus1 = func(i int) int { return i + 1 }
-
-	Context("Panic if transform function invalid", func() {
-		panicsWithTransformer := func(transform interface{}) {
-			ExpectWithOffset(1, func() { WithTransform(transform, nil) }).To(Panic())
-		}
-		It("nil", func() {
-			panicsWithTransformer(nil)
-		})
-		Context("Invalid number of args, but correct return value count", func() {
-			It("zero", func() {
-				panicsWithTransformer(func() int { return 5 })
-			})
-			It("two", func() {
-				panicsWithTransformer(func(i, j int) int { return 5 })
-			})
-		})
-		Context("Invalid number of return values, but correct number of arguments", func() {
-			It("zero", func() {
-				panicsWithTransformer(func(i int) {})
-			})
-			It("two", func() {
-				panicsWithTransformer(func(i int) (int, int) { return 5, 6 })
-			})
-		})
-	})
-
-	It("works with positive cases", func() {
-		Expect(1).To(WithTransform(plus1, Equal(2)))
-		Expect(1).To(WithTransform(plus1, WithTransform(plus1, Equal(3))))
-		Expect(1).To(WithTransform(plus1, And(Equal(2), BeNumerically(">", 1))))
-
-		// transform expects custom type
-		type S struct {
-			A int
-			B string
-		}
-		transformer := func(s S) string { return s.B }
-		Expect(S{1, "hi"}).To(WithTransform(transformer, Equal("hi")))
-
-		// transform expects interface
-		errString := func(e error) string { return e.Error() }
-		Expect(errors.New("abc")).To(WithTransform(errString, Equal("abc")))
-	})
-
-	It("works with negative cases", func() {
-		Expect(1).ToNot(WithTransform(plus1, Equal(3)))
-		Expect(1).ToNot(WithTransform(plus1, WithTransform(plus1, Equal(2))))
-	})
-
-	Context("failure messages", func() {
-		Context("when match fails", func() {
-			It("gives a descriptive message", func() {
-				m := WithTransform(plus1, Equal(3))
-				Expect(m.Match(1)).To(BeFalse())
-				Expect(m.FailureMessage(1)).To(Equal("Expected\n    <int>: 2\nto equal\n    <int>: 3"))
-			})
-		})
-
-		Context("when match succeeds, but expected it to fail", func() {
-			It("gives a descriptive message", func() {
-				m := Not(WithTransform(plus1, Equal(3)))
-				Expect(m.Match(2)).To(BeFalse())
-				Expect(m.FailureMessage(2)).To(Equal("Expected\n    <int>: 3\nnot to equal\n    <int>: 3"))
-			})
-		})
-
-		Context("actual value is incompatible with transform function's argument type", func() {
-			It("gracefully fails if transform cannot be performed", func() {
-				m := WithTransform(plus1, Equal(3))
-				result, err := m.Match("hi") // give it a string but transform expects int; doesn't panic
-				Expect(result).To(BeFalse())
-				Expect(err).To(MatchError("Transform function expects 'int' but we have 'string'"))
-			})
-		})
-	})
-
-	Context("MatchMayChangeInTheFuture()", func() {
-		It("Propagates value from wrapped matcher on the transformed value", func() {
-			m := WithTransform(plus1, Or()) // empty Or() always returns false, and indicates it cannot change
-			Expect(m.Match(1)).To(BeFalse())
-			Expect(m.(*WithTransformMatcher).MatchMayChangeInTheFuture(1)).To(BeFalse()) // empty Or() indicates cannot change
-		})
-		It("Defaults to true", func() {
-			m := WithTransform(plus1, Equal(2)) // Equal does not have this method
-			Expect(m.Match(1)).To(BeTrue())
-			Expect(m.(*WithTransformMatcher).MatchMayChangeInTheFuture(1)).To(BeTrue()) // defaults to true
-		})
-	})
-})