migrate to go-modules

Signed-off-by: Valentin Rothberg <rothberg@redhat.com>

87 files changed, 0 insertions, 8520 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 8e65a9529..000000000
--- 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 9ea781379..000000000
--- a/vendor/github.com/onsi/gomega/format/format_test.go
+++ /dev/null
@@ -1,627 +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() {
-				Expect(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() {
-				Expect(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"
-
-			Expect(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"
-
-			Expect(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"
-
-			Expect(MessageWithDiff(largeString, "to equal", smallString)).Should(Equal(expectedTruncatedStartSizeFailureMessage))
-			Expect(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"
-
-			Expect(MessageWithDiff(stringWithB, "to equal", stringWithZ)).Should(Equal(expectedTruncatedEndStringFailureMessage))
-		})
-
-		It("handles multi-byte sequences correctly", func() {
-			stringA := "• abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz1"
-			stringB := "• abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz"
-
-			Expect(MessageWithDiff(stringA, "to equal", stringB)).Should(Equal(expectedTruncatedMultiByteFailureMessage))
-		})
-
-		Context("With truncated diff disabled", func() {
-			BeforeEach(func() {
-				TruncatedDiff = false
-			})
-
-			AfterEach(func() {
-				TruncatedDiff = true
-			})
-
-			It("should show the full diff", func() {
-				stringWithB := "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaabaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
-				stringWithZ := "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaazaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
-
-				Expect(MessageWithDiff(stringWithB, "to equal", stringWithZ)).Should(Equal(expectedFullFailureDiff))
-			})
-		})
-	})
-
-	Describe("IndentString", func() {
-		It("should indent the string", func() {
-			Expect(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() {
-				Expect(Object(true, 1)).Should(match("bool", "true"))
-				Expect(Object(false, 1)).Should(match("bool", "false"))
-			})
-		})
-
-		Describe("formatting numbers", func() {
-			It("should give the type and format values correctly", func() {
-				Expect(Object(int(3), 1)).Should(match("int", "3"))
-				Expect(Object(int8(3), 1)).Should(match("int8", "3"))
-				Expect(Object(int16(3), 1)).Should(match("int16", "3"))
-				Expect(Object(int32(3), 1)).Should(match("int32", "3"))
-				Expect(Object(int64(3), 1)).Should(match("int64", "3"))
-
-				Expect(Object(uint(3), 1)).Should(match("uint", "3"))
-				Expect(Object(uint8(3), 1)).Should(match("uint8", "3"))
-				Expect(Object(uint16(3), 1)).Should(match("uint16", "3"))
-				Expect(Object(uint32(3), 1)).Should(match("uint32", "3"))
-				Expect(Object(uint64(3), 1)).Should(match("uint64", "3"))
-			})
-
-			It("should handle uintptr differently", func() {
-				Expect(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
-				Expect(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"
-				Expect(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")
-					Expect(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")
-					Expect(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
-				}
-				Expect(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
-				Expect(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
-
-					Expect(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
-					Expect(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"}
-				Expect(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}
-					Expect(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)
-				Expect(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",
-    ]`
-					Expect(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
-				Expect(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"),
-    }`
-					Expect(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,
-				}
-
-				Expect(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,
-					}
-
-					Expect(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() {
-				Expect(Object(nil, 1)).Should(match("nil", "nil"))
-				var typedNil *AStruct
-				Expect(Object(typedNil, 1)).Should(match("*format_test.AStruct | 0x0", "nil"))
-				var c chan<- bool
-				Expect(Object(c, 1)).Should(match("chan<- bool | len:0, cap:0", "nil"))
-				var s []string
-				Expect(Object(s, 1)).Should(match("[]string | len:0, cap:0", "nil"))
-				var m map[string]bool
-				Expect(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() {
-				Expect(Object(StringAlias("alias"), 1)).Should(match("format_test.StringAlias", `alias`))
-				Expect(Object(ByteAlias("alias"), 1)).Should(matchRegexp(`format_test\.ByteAlias \| len:5, cap:\d+`, `alias`))
-				Expect(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"),
-        },
-    }`
-				Expect(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)
-				Expect(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`))
-
-			Expect(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}`)
-			Expect(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
-			Expect(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
-			Expect(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() {
-				Expect(Object(GoStringer{}, 1)).Should(ContainSubstring("<format_test.GoStringer>: go-string"))
-			})
-		})
-
-		Context("when passed a stringer", func() {
-			It("should use what String() returns", func() {
-				Expect(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() {
-			Expect(Object(objWithContext, 1)).Should(ContainSubstring("<suppressed context>"))
-		})
-
-		It("Doesn't supress the context if it's the object being printed", func() {
-			Expect(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() {
-				Expect(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"
-`)
-var expectedTruncatedMultiByteFailureMessage = strings.TrimSpace(`
-Expected
-    <string>: "...tuvwxyz1"
-to equal                 |
-    <string>: "...tuvwxyz"
-`)
-
-var expectedFullFailureDiff = strings.TrimSpace(`
-Expected
-    <string>: aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaabaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
-to equal
-    <string>: aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaazaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
-`)
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 9d4e8279d..000000000
--- a/vendor/github.com/onsi/gomega/gbytes/buffer_test.go
+++ /dev/null
@@ -1,205 +0,0 @@
-package gbytes_test
-
-import (
-	"io"
-	"time"
-
-	. "github.com/onsi/gomega/gbytes"
-
-	"bytes"
-
-	. "github.com/onsi/ginkgo"
-	. "github.com/onsi/gomega"
-)
-
-type SlowReader struct {
-	R io.Reader
-	D time.Duration
-}
-
-func (s SlowReader) Read(p []byte) (int, error) {
-	time.Sleep(s.D)
-	return s.R.Read(p)
-}
-
-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"))
-			Expect(buffer.Contents()).Should(Equal([]byte("abcdef")))
-
-			Expect(buffer).Should(Say("bcd"))
-			Expect(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"))
-			Expect(buffer.Contents()).Should(Equal([]byte("abcdef")))
-			Expect(buffer).Should(Say("abc"))
-			Expect(buffer).ShouldNot(Say("abc"))
-			Expect(buffer).Should(Say("def"))
-		})
-	})
-
-	Describe("creating a buffer that wraps a reader", func() {
-		Context("for a well-behaved reader", func() {
-			It("should buffer the contents of the reader", func() {
-				reader := bytes.NewBuffer([]byte("abcdef"))
-				buffer := BufferReader(reader)
-				Eventually(buffer).Should(Say("abc"))
-				Expect(buffer).ShouldNot(Say("abc"))
-				Eventually(buffer).Should(Say("def"))
-				Eventually(buffer.Closed).Should(BeTrue())
-			})
-		})
-
-		Context("for a slow reader", func() {
-			It("should allow Eventually to time out", func() {
-				slowReader := SlowReader{
-					R: bytes.NewBuffer([]byte("abcdef")),
-					D: time.Second,
-				}
-				buffer := BufferReader(slowReader)
-				failures := InterceptGomegaFailures(func() {
-					Eventually(buffer, 100*time.Millisecond).Should(Say("abc"))
-				})
-				Expect(failures).ShouldNot(BeEmpty())
-
-				fastReader := SlowReader{
-					R: bytes.NewBuffer([]byte("abcdef")),
-					D: time.Millisecond,
-				}
-				buffer = BufferReader(fastReader)
-				Eventually(buffer, 100*time.Millisecond).Should(Say("abc"))
-				Eventually(buffer.Closed).Should(BeTrue())
-			})
-		})
-	})
-
-	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)
-			Expect(err).ShouldNot(HaveOccurred())
-			Expect(n).Should(Equal(3))
-			Expect(string(dest)).Should(Equal("abc"))
-
-			dest = make([]byte, 3)
-			n, err = buffer.Read(dest)
-			Expect(err).ShouldNot(HaveOccurred())
-			Expect(n).Should(Equal(2))
-			Expect(string(dest[:n])).Should(Equal("de"))
-
-			n, err = buffer.Read(dest)
-			Expect(err).Should(Equal(io.EOF))
-			Expect(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)
-				Expect(err).Should(HaveOccurred())
-				Expect(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")
-			}
-
-			Expect(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")
-			Expect(buffer).ShouldNot(Say("abc"))
-			Expect(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
-			Expect(buffer).Should(Say("abcd"))
-			<-A
-			Expect(buffer).ShouldNot(Say("d"))
-			Expect(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())
-
-			Expect(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"))
-			Expect(err).ShouldNot(HaveOccurred())
-
-			buffer.Close()
-
-			_, err = buffer.Write([]byte("def"))
-			Expect(err).Should(HaveOccurred())
-
-			Expect(buffer.Contents()).Should(Equal([]byte("abc")))
-		})
-
-		It("should be closed", func() {
-			Expect(buffer.Closed()).Should(BeFalse())
-
-			buffer.Close()
-
-			Expect(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 3a7dc0612..000000000
--- 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/io_wrappers_test.go b/vendor/github.com/onsi/gomega/gbytes/io_wrappers_test.go
deleted file mode 100644
index 3da973498..000000000
--- a/vendor/github.com/onsi/gomega/gbytes/io_wrappers_test.go
+++ /dev/null
@@ -1,188 +0,0 @@
-package gbytes_test
-
-import (
-	"fmt"
-	"io"
-	"time"
-
-	. "github.com/onsi/gomega/gbytes"
-
-	. "github.com/onsi/ginkgo"
-	. "github.com/onsi/gomega"
-)
-
-type FakeCloser struct {
-	err      error
-	duration time.Duration
-}
-
-func (f FakeCloser) Close() error {
-	time.Sleep(f.duration)
-	return f.err
-}
-
-type FakeReader struct {
-	err      error
-	duration time.Duration
-}
-
-func (f FakeReader) Read(p []byte) (int, error) {
-	time.Sleep(f.duration)
-	if f.err != nil {
-		return 0, f.err
-	}
-
-	for i := 0; i < len(p); i++ {
-		p[i] = 'a'
-	}
-
-	return len(p), nil
-}
-
-type FakeWriter struct {
-	err      error
-	duration time.Duration
-}
-
-func (f FakeWriter) Write(p []byte) (int, error) {
-	time.Sleep(f.duration)
-	if f.err != nil {
-		return 0, f.err
-	}
-
-	return len(p), nil
-}
-
-var _ = Describe("Io Wrappers", func() {
-	Describe("TimeoutCloser", func() {
-		var innerCloser io.Closer
-		var timeoutCloser io.Closer
-
-		JustBeforeEach(func() {
-			timeoutCloser = TimeoutCloser(innerCloser, 20*time.Millisecond)
-		})
-
-		Context("when the underlying Closer closes with no error", func() {
-			BeforeEach(func() {
-				innerCloser = FakeCloser{}
-			})
-
-			It("returns with no error", func() {
-				Expect(timeoutCloser.Close()).Should(Succeed())
-			})
-		})
-
-		Context("when the underlying Closer closes with an error", func() {
-			BeforeEach(func() {
-				innerCloser = FakeCloser{err: fmt.Errorf("boom")}
-			})
-
-			It("returns the error", func() {
-				Expect(timeoutCloser.Close()).Should(MatchError("boom"))
-			})
-		})
-
-		Context("when the underlying Closer hangs", func() {
-			BeforeEach(func() {
-				innerCloser = FakeCloser{
-					err:      fmt.Errorf("boom"),
-					duration: time.Hour,
-				}
-			})
-
-			It("returns ErrTimeout", func() {
-				Expect(timeoutCloser.Close()).Should(MatchError(ErrTimeout))
-			})
-		})
-	})
-
-	Describe("TimeoutReader", func() {
-		var innerReader io.Reader
-		var timeoutReader io.Reader
-
-		JustBeforeEach(func() {
-			timeoutReader = TimeoutReader(innerReader, 20*time.Millisecond)
-		})
-
-		Context("when the underlying Reader returns no error", func() {
-			BeforeEach(func() {
-				innerReader = FakeReader{}
-			})
-
-			It("returns with no error", func() {
-				p := make([]byte, 5)
-				n, err := timeoutReader.Read(p)
-				Expect(n).Should(Equal(5))
-				Expect(err).ShouldNot(HaveOccurred())
-				Expect(p).Should(Equal([]byte("aaaaa")))
-			})
-		})
-
-		Context("when the underlying Reader returns an error", func() {
-			BeforeEach(func() {
-				innerReader = FakeReader{err: fmt.Errorf("boom")}
-			})
-
-			It("returns the error", func() {
-				p := make([]byte, 5)
-				_, err := timeoutReader.Read(p)
-				Expect(err).Should(MatchError("boom"))
-			})
-		})
-
-		Context("when the underlying Reader hangs", func() {
-			BeforeEach(func() {
-				innerReader = FakeReader{err: fmt.Errorf("boom"), duration: time.Hour}
-			})
-
-			It("returns ErrTimeout", func() {
-				p := make([]byte, 5)
-				_, err := timeoutReader.Read(p)
-				Expect(err).Should(MatchError(ErrTimeout))
-			})
-		})
-	})
-
-	Describe("TimeoutWriter", func() {
-		var innerWriter io.Writer
-		var timeoutWriter io.Writer
-
-		JustBeforeEach(func() {
-			timeoutWriter = TimeoutWriter(innerWriter, 20*time.Millisecond)
-		})
-
-		Context("when the underlying Writer returns no error", func() {
-			BeforeEach(func() {
-				innerWriter = FakeWriter{}
-			})
-
-			It("returns with no error", func() {
-				n, err := timeoutWriter.Write([]byte("aaaaa"))
-				Expect(n).Should(Equal(5))
-				Expect(err).ShouldNot(HaveOccurred())
-			})
-		})
-
-		Context("when the underlying Writer returns an error", func() {
-			BeforeEach(func() {
-				innerWriter = FakeWriter{err: fmt.Errorf("boom")}
-			})
-
-			It("returns the error", func() {
-				_, err := timeoutWriter.Write([]byte("aaaaa"))
-				Expect(err).Should(MatchError("boom"))
-			})
-		})
-
-		Context("when the underlying Writer hangs", func() {
-			BeforeEach(func() {
-				innerWriter = FakeWriter{err: fmt.Errorf("boom"), duration: time.Hour}
-			})
-
-			It("returns ErrTimeout", func() {
-				_, err := timeoutWriter.Write([]byte("aaaaa"))
-				Expect(err).Should(MatchError(ErrTimeout))
-			})
-		})
-	})
-})
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 0055d4a1b..000000000
--- a/vendor/github.com/onsi/gomega/gbytes/say_matcher_test.go
+++ /dev/null
@@ -1,169 +0,0 @@
-package gbytes_test
-
-import (
-	"time"
-
-	. "github.com/onsi/gomega/gbytes"
-
-	. "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() {
-				Expect("foo").Should(Say("foo"))
-			})
-			Expect(failures[0]).Should(ContainSubstring("*gbytes.Buffer"))
-		})
-	})
-
-	Context("when a match is found", func() {
-		It("should succeed", func() {
-			Expect(buffer).Should(Say("abc"))
-		})
-
-		It("should support printf-like formatting", func() {
-			Expect(buffer).Should(Say("a%sc", "b"))
-		})
-
-		It("should match literal %", func() {
-			buffer.Write([]byte("%"))
-			Expect(buffer).Should(Say("abc%"))
-		})
-
-		It("should use a regular expression", func() {
-			Expect(buffer).Should(Say("a.c"))
-		})
-
-		It("should fastforward the buffer", func() {
-			buffer.Write([]byte("def"))
-			Expect(buffer).Should(Say("abcd"))
-			Expect(buffer).Should(Say("ef"))
-			Expect(buffer).ShouldNot(Say("[a-z]"))
-		})
-	})
-
-	Context("when no match is found", func() {
-		It("should not error", func() {
-			Expect(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"))
-				Expect(time.Since(t)).Should(BeNumerically("<", 500*time.Millisecond))
-				Expect(failures).Should(HaveLen(1))
-
-				t = time.Now()
-				Eventually(buffer).Should(Say("abc"))
-				Expect(time.Since(t)).Should(BeNumerically("<", 500*time.Millisecond))
-			})
-
-			It("should abort a consistently", func() {
-				t := time.Now()
-				Consistently(buffer, 2.0).ShouldNot(Say("def"))
-				Expect(time.Since(t)).Should(BeNumerically("<", 500*time.Millisecond))
-			})
-
-			It("should not error with a synchronous matcher", func() {
-				Expect(buffer).ShouldNot(Say("def"))
-				Expect(buffer).Should(Say("abc"))
-			})
-		})
-	})
-
-	Context("when a positive match fails", func() {
-		It("should report where it got stuck", func() {
-			Expect(buffer).Should(Say("abc"))
-			buffer.Write([]byte("def"))
-			failures := InterceptGomegaFailures(func() {
-				Expect(buffer).Should(Say("abc"))
-			})
-			Expect(failures[0]).Should(ContainSubstring("Got stuck at:"))
-			Expect(failures[0]).Should(ContainSubstring("def"))
-		})
-	})
-
-	Context("when a negative match fails", func() {
-		It("should report where it got stuck", func() {
-			failures := InterceptGomegaFailures(func() {
-				Expect(buffer).ShouldNot(Say("abc"))
-			})
-			Expect(failures[0]).Should(ContainSubstring("Saw:"))
-			Expect(failures[0]).Should(ContainSubstring("Which matches the unexpected:"))
-			Expect(failures[0]).Should(ContainSubstring("abc"))
-		})
-	})
-
-	Context("when a match is not found", func() {
-		It("should not fastforward the buffer", func() {
-			Expect(buffer).ShouldNot(Say("def"))
-			Expect(buffer).Should(Say("abc"))
-		})
-	})
-
-	Context("a nice real-life example", func() {
-		It("should behave well", func() {
-			Expect(buffer).Should(Say("abc"))
-			go func() {
-				time.Sleep(10 * time.Millisecond)
-				buffer.Write([]byte("def"))
-			}()
-			Expect(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(),
-			}
-
-			Expect(s).ShouldNot(Say("abc"))
-
-			s.Buffer().Write([]byte("abc"))
-			Expect(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"))
-			})
-			Expect(failures).Should(HaveLen(1))
-			Expect(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 16091c22b..000000000
--- 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_test.go b/vendor/github.com/onsi/gomega/gexec/build_test.go
deleted file mode 100644
index 295dac8bc..000000000
--- a/vendor/github.com/onsi/gomega/gexec/build_test.go
+++ /dev/null
@@ -1,112 +0,0 @@
-package gexec_test
-
-import (
-	"fmt"
-	"io/ioutil"
-	"os"
-	"path/filepath"
-
-	. "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)
-			Expect(err).ShouldNot(HaveOccurred())
-		})
-
-		It("compiles the specified package", func() {
-			compiledPath, err := gexec.Build(packagePath)
-			Expect(err).ShouldNot(HaveOccurred())
-			Expect(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)
-				Expect(err).ShouldNot(HaveOccurred())
-				Expect(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)
-		Expect(err).ShouldNot(HaveOccurred())
-		Expect(compiledPath).Should(BeAnExistingFile())
-	})
-
-	It("returns the environment to a good state", func() {
-		_, err = gexec.BuildWithEnvironment(packagePath, env)
-		Expect(err).ShouldNot(HaveOccurred())
-		Expect(os.Environ()).ShouldNot(ContainElement("GOOS=linux"))
-	})
-})
-
-var _ = Describe(".BuildIn", func() {
-	const (
-		target = "github.com/onsi/gomega/gexec/_fixture/firefly/"
-	)
-
-	var (
-		original string
-		gopath   string
-	)
-
-	BeforeEach(func() {
-		var err error
-		original = os.Getenv("GOPATH")
-		gopath, err = ioutil.TempDir("", "")
-		Expect(err).NotTo(HaveOccurred())
-		copyFile(filepath.Join("_fixture", "firefly", "main.go"), filepath.Join(gopath, "src", target), "main.go")
-		Expect(os.Setenv("GOPATH", filepath.Join(os.TempDir(), "emptyFakeGopath"))).To(Succeed())
-		Expect(os.Environ()).To(ContainElement(fmt.Sprintf("GOPATH=%s", filepath.Join(os.TempDir(), "emptyFakeGopath"))))
-	})
-
-	AfterEach(func() {
-		if original == "" {
-			Expect(os.Unsetenv("GOPATH")).To(Succeed())
-		} else {
-			Expect(os.Setenv("GOPATH", original)).To(Succeed())
-		}
-		if gopath != "" {
-			os.RemoveAll(gopath)
-		}
-	})
-
-	It("appends the gopath env var", func() {
-		_, err := gexec.BuildIn(gopath, target)
-		Expect(err).NotTo(HaveOccurred())
-	})
-
-	It("resets GOPATH to its original value", func() {
-		_, err := gexec.BuildIn(gopath, target)
-		Expect(err).NotTo(HaveOccurred())
-		Expect(os.Getenv("GOPATH")).To(Equal(filepath.Join(os.TempDir(), "emptyFakeGopath")))
-	})
-})
-
-func copyFile(source, directory, basename string) {
-	Expect(os.MkdirAll(directory, 0755)).To(Succeed())
-	content, err := ioutil.ReadFile(source)
-	Expect(err).NotTo(HaveOccurred())
-	Expect(ioutil.WriteFile(filepath.Join(directory, basename), content, 0644)).To(Succeed())
-}
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 9abc3226f..000000000
--- a/vendor/github.com/onsi/gomega/gexec/exit_matcher_test.go
+++ /dev/null
@@ -1,114 +0,0 @@
-package gexec_test
-
-import (
-	"os/exec"
-	"time"
-
-	. "github.com/onsi/gomega/gexec"
-
-	. "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)
-		Expect(err).ShouldNot(HaveOccurred())
-	})
-
-	Describe("when passed something that is an Exiter", func() {
-		It("should act normally", func() {
-			failures := InterceptGomegaFailures(func() {
-				Expect(NeverExits{}).Should(Exit())
-			})
-
-			Expect(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() {
-				Expect("aardvark").Should(Exit())
-			})
-
-			Expect(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() {
-			Expect(session).ShouldNot(Exit())
-
-			failures := InterceptGomegaFailures(func() {
-				Expect(session).Should(Exit())
-			})
-
-			Expect(failures[0]).Should(ContainSubstring("Expected process to exit.  It did not."))
-
-			Eventually(session).Should(Exit())
-
-			Expect(session).Should(Exit())
-
-			failures = InterceptGomegaFailures(func() {
-				Expect(session).ShouldNot(Exit())
-			})
-
-			Expect(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() {
-			Expect(session).ShouldNot(Exit(0))
-			Expect(session).ShouldNot(Exit(1))
-
-			failures := InterceptGomegaFailures(func() {
-				Expect(session).Should(Exit(0))
-			})
-
-			Expect(failures[0]).Should(ContainSubstring("Expected process to exit.  It did not."))
-
-			Eventually(session).Should(Exit(0))
-
-			Expect(session).Should(Exit(0))
-
-			failures = InterceptGomegaFailures(func() {
-				Expect(session).Should(Exit(1))
-			})
-
-			Expect(failures[0]).Should(ContainSubstring("to match exit code:"))
-
-			Expect(session).ShouldNot(Exit(1))
-
-			failures = InterceptGomegaFailures(func() {
-				Expect(session).ShouldNot(Exit(0))
-			})
-
-			Expect(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))
-			})
-			Expect(time.Since(t)).Should(BeNumerically("<=", 500*time.Millisecond))
-			Expect(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 dc8e1f40c..000000000
--- 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")
-		Expect(err).ShouldNot(HaveOccurred())
-	})
-
-	AfterSuite(func() {
-		gexec.CleanupBuildArtifacts()
-	})
-
-	RegisterFailHandler(Fail)
-	RunSpecs(t, "Gexec Suite")
-}
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 e847b1501..000000000
--- 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"))
-
-		Expect(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_test.go b/vendor/github.com/onsi/gomega/gexec/session_test.go
deleted file mode 100644
index 6fdf22d21..000000000
--- a/vendor/github.com/onsi/gomega/gexec/session_test.go
+++ /dev/null
@@ -1,336 +0,0 @@
-package gexec_test
-
-import (
-	"io"
-	"io/ioutil"
-	"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 io.Writer
-
-	BeforeEach(func() {
-		outWriter = nil
-		errWriter = nil
-	})
-
-	JustBeforeEach(func() {
-		command = exec.Command(fireflyPath)
-		var err error
-		session, err = Start(command, outWriter, errWriter)
-		Expect(err).ShouldNot(HaveOccurred())
-	})
-
-	Context("running a command", func() {
-		It("should start the process", func() {
-			Expect(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() {
-			Expect(session.ExitCode()).Should(Equal(-1))
-
-			Eventually(session).Should(Exit())
-			Expect(session.ExitCode()).Should(BeNumerically(">=", 0))
-			Expect(session.ExitCode()).Should(BeNumerically("<", 3))
-		})
-	})
-
-	Describe("wait", func() {
-		It("should wait till the command exits", func() {
-			Expect(session.ExitCode()).Should(Equal(-1))
-			Expect(session.Wait().ExitCode()).Should(BeNumerically(">=", 0))
-			Expect(session.Wait().ExitCode()).Should(BeNumerically("<", 3))
-		})
-	})
-
-	Describe("exited", func() {
-		It("should close when the command exits", func() {
-			Eventually(session.Exited).Should(BeClosed())
-			Expect(session.ExitCode()).ShouldNot(Equal(-1))
-		})
-	})
-
-	Describe("kill", func() {
-		It("should kill the command", func() {
-			session, err := Start(exec.Command("sleep", "10000000"), GinkgoWriter, GinkgoWriter)
-			Expect(err).ShouldNot(HaveOccurred())
-
-			session.Kill()
-			Eventually(session).Should(Exit(128 + 9))
-		})
-	})
-
-	Describe("interrupt", func() {
-		It("should interrupt the command", func() {
-			session, err := Start(exec.Command("sleep", "10000000"), GinkgoWriter, GinkgoWriter)
-			Expect(err).ShouldNot(HaveOccurred())
-
-			session.Interrupt()
-			Eventually(session).Should(Exit(128 + 2))
-		})
-	})
-
-	Describe("terminate", func() {
-		It("should terminate the command", func() {
-			session, err := Start(exec.Command("sleep", "10000000"), GinkgoWriter, GinkgoWriter)
-			Expect(err).ShouldNot(HaveOccurred())
-
-			session.Terminate()
-			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)
-			Expect(err).ShouldNot(HaveOccurred())
-
-			session.Signal(syscall.SIGABRT)
-			Eventually(session).Should(Exit(128 + 6))
-		})
-
-		It("should ignore sending a signal if the command did not start", func() {
-			session, err := Start(exec.Command("notexisting"), GinkgoWriter, GinkgoWriter)
-			Expect(err).To(HaveOccurred())
-
-			Expect(func() { session.Signal(syscall.SIGUSR1) }).NotTo(Panic())
-		})
-	})
-
-	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)
-				Expect(err).ShouldNot(HaveOccurred())
-
-				session2, err := Start(exec.Command("sleep", "10000000"), GinkgoWriter, GinkgoWriter)
-				Expect(err).ShouldNot(HaveOccurred())
-
-				session3, err := Start(exec.Command("sleep", "10000000"), GinkgoWriter, GinkgoWriter)
-				Expect(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 track unstarted sessions", func() {
-				_, err := Start(exec.Command("does not exist", "10000000"), GinkgoWriter, GinkgoWriter)
-				Expect(err).Should(HaveOccurred())
-
-				session2, err := Start(exec.Command("sleep", "10000000"), GinkgoWriter, GinkgoWriter)
-				Expect(err).ShouldNot(HaveOccurred())
-
-				session3, err := Start(exec.Command("sleep", "10000000"), GinkgoWriter, GinkgoWriter)
-				Expect(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)
-				Expect(err).ShouldNot(HaveOccurred())
-
-				session2, err := Start(exec.Command("sleep", "10000000"), GinkgoWriter, GinkgoWriter)
-				Expect(err).ShouldNot(HaveOccurred())
-
-				session3, err := Start(exec.Command("sleep", "10000000"), GinkgoWriter, GinkgoWriter)
-				Expect(err).ShouldNot(HaveOccurred())
-
-				KillAndWait()
-				Expect(session1).Should(Exit(128+9), "Should have exited")
-				Expect(session2).Should(Exit(128+9), "Should have exited")
-				Expect(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)
-				Expect(err).ShouldNot(HaveOccurred())
-
-				session2, err := Start(exec.Command("sleep", "10000000"), GinkgoWriter, GinkgoWriter)
-				Expect(err).ShouldNot(HaveOccurred())
-
-				session3, err := Start(exec.Command("sleep", "10000000"), GinkgoWriter, GinkgoWriter)
-				Expect(err).ShouldNot(HaveOccurred())
-
-				Terminate()
-
-				Eventually(session1).Should(Exit(128 + 15))
-				Eventually(session2).Should(Exit(128 + 15))
-				Eventually(session3).Should(Exit(128 + 15))
-			})
-		})
-
-		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)
-				Expect(err).ShouldNot(HaveOccurred())
-
-				session2, err := Start(exec.Command("sleep", "10000000"), GinkgoWriter, GinkgoWriter)
-				Expect(err).ShouldNot(HaveOccurred())
-
-				session3, err := Start(exec.Command("sleep", "10000000"), GinkgoWriter, GinkgoWriter)
-				Expect(err).ShouldNot(HaveOccurred())
-
-				TerminateAndWait()
-
-				Expect(session1).Should(Exit(128+15), "Should have exited")
-				Expect(session2).Should(Exit(128+15), "Should have exited")
-				Expect(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)
-				Expect(err).ShouldNot(HaveOccurred())
-
-				session2, err := Start(exec.Command("sleep", "10000000"), GinkgoWriter, GinkgoWriter)
-				Expect(err).ShouldNot(HaveOccurred())
-
-				session3, err := Start(exec.Command("sleep", "10000000"), GinkgoWriter, GinkgoWriter)
-				Expect(err).ShouldNot(HaveOccurred())
-
-				Signal(syscall.SIGABRT)
-
-				Eventually(session1).Should(Exit(128 + 6))
-				Eventually(session2).Should(Exit(128 + 6))
-				Eventually(session3).Should(Exit(128 + 6))
-			})
-		})
-
-		Describe("interrupt", func() {
-			It("should interrupt all the started sessions, and not wait", func() {
-				session1, err := Start(exec.Command("sleep", "10000000"), GinkgoWriter, GinkgoWriter)
-				Expect(err).ShouldNot(HaveOccurred())
-
-				session2, err := Start(exec.Command("sleep", "10000000"), GinkgoWriter, GinkgoWriter)
-				Expect(err).ShouldNot(HaveOccurred())
-
-				session3, err := Start(exec.Command("sleep", "10000000"), GinkgoWriter, GinkgoWriter)
-				Expect(err).ShouldNot(HaveOccurred())
-
-				Interrupt()
-
-				Eventually(session1).Should(Exit(128 + 2))
-				Eventually(session2).Should(Exit(128 + 2))
-				Eventually(session3).Should(Exit(128 + 2))
-			})
-		})
-	})
-
-	Context("when the command exits", func() {
-		It("should close the buffers", func() {
-			Eventually(session).Should(Exit())
-
-			Expect(session.Out.Closed()).Should(BeTrue())
-			Expect(session.Err.Closed()).Should(BeTrue())
-
-			Expect(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"))
-			})
-			Expect(time.Since(t)).Should(BeNumerically("<=", 500*time.Millisecond))
-			Expect(failures).Should(HaveLen(1))
-		})
-	})
-
-	Context("when wrapping out and err", func() {
-		var (
-			outWriterBuffer, errWriterBuffer *Buffer
-		)
-
-		BeforeEach(func() {
-			outWriterBuffer = NewBuffer()
-			outWriter = outWriterBuffer
-			errWriterBuffer = NewBuffer()
-			errWriter = errWriterBuffer
-		})
-
-		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!"))
-
-			Expect(outWriterBuffer.Contents()).Should(ContainSubstring("We've done the impossible, and that makes us mighty"))
-			Expect(errWriterBuffer.Contents()).Should(ContainSubstring("Ah, curse your sudden but inevitable betrayal!"))
-
-			Eventually(session).Should(Exit())
-
-			Expect(outWriterBuffer.Contents()).Should(Equal(session.Out.Contents()))
-			Expect(errWriterBuffer.Contents()).Should(Equal(session.Err.Contents()))
-		})
-
-		Context("when discarding the output of the command", func() {
-			BeforeEach(func() {
-				outWriter = ioutil.Discard
-				errWriter = ioutil.Discard
-			})
-
-			It("executes succesfuly", func() {
-				Eventually(session).Should(Exit())
-			})
-		})
-	})
-
-	Describe("when the command fails to start", func() {
-		It("should return an error", func() {
-			_, err := Start(exec.Command("agklsjdfas"), nil, nil)
-			Expect(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 894eae6d4..000000000
--- a/vendor/github.com/onsi/gomega/ghttp/handlers.go
+++ /dev/null
@@ -1,322 +0,0 @@
-package ghttp
-
-import (
-	"encoding/base64"
-	"encoding/json"
-	"fmt"
-	"io/ioutil"
-	"net/http"
-	"net/url"
-	"reflect"
-	"strings"
-
-	"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) {
-		Expect(req.Method).Should(Equal(method), "Method mismatch")
-		switch p := path.(type) {
-		case types.GomegaMatcher:
-			Expect(req.URL.Path).Should(p, "Path mismatch")
-		default:
-			Expect(req.URL.Path).Should(Equal(path), "Path mismatch")
-		}
-		if len(rawQuery) > 0 {
-			values, err := url.ParseQuery(rawQuery[0])
-			Expect(err).ShouldNot(HaveOccurred(), "Expected RawQuery is malformed")
-
-			Expect(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) {
-		Expect(req.Header.Get("Content-Type")).Should(Equal(contentType))
-	}
-}
-
-//VerifyMimeType returns a handler that verifies that a request has a specified mime type set
-//in Content-Type header
-func VerifyMimeType(mimeType string) http.HandlerFunc {
-	return func(w http.ResponseWriter, req *http.Request) {
-		Expect(strings.Split(req.Header.Get("Content-Type"), ";")[0]).Should(Equal(mimeType))
-	}
-}
-
-//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")
-		Expect(auth).ShouldNot(Equal(""), "Authorization header must be specified")
-
-		decoded, err := base64.StdEncoding.DecodeString(auth[6:])
-		Expect(err).ShouldNot(HaveOccurred())
-
-		Expect(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)
-			Expect(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()
-			Expect(err).ShouldNot(HaveOccurred())
-			Expect(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(
-		VerifyMimeType("application/json"),
-		func(w http.ResponseWriter, req *http.Request) {
-			body, err := ioutil.ReadAll(req.Body)
-			req.Body.Close()
-			Expect(err).ShouldNot(HaveOccurred())
-			Expect(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)
-	Expect(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()
-		Expect(err).ShouldNot(HaveOccurred())
-		for key, vals := range values {
-			Expect(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)
-			Expect(err).ShouldNot(HaveOccurred())
-			req.Body.Close()
-
-			expectedType := reflect.TypeOf(expected)
-			actualValuePtr := reflect.New(expectedType.Elem())
-
-			actual, ok := actualValuePtr.Interface().(proto.Message)
-			Expect(ok).Should(BeTrue(), "Message value is not a proto.Message")
-
-			err = proto.Unmarshal(body, actual)
-			Expect(err).ShouldNot(HaveOccurred(), "Failed to unmarshal protobuf")
-
-			Expect(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:
-			Expect(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:
-				Expect(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)
-	Expect(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)
-		Expect(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)
-		Expect(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 b2972bc9f..000000000
--- 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 c55a48448..000000000
--- 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 35b7145c2..000000000
--- 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 77535f309..000000000
--- a/vendor/github.com/onsi/gomega/ghttp/test_server.go
+++ /dev/null
@@ -1,422 +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() {
-						Expect(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() {
-						Expect(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()
-						Expect(sprockets).Should(BeEmpty())
-						Expect(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()
-						Expect(sprockets).Should(BeEmpty())
-						Expect(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() {
-					Expect(client.Sprockets("food")).Should(Equal(sprockets))
-				})
-			})
-		})
-	})
-*/
-package ghttp
-
-import (
-	"fmt"
-	"io"
-	"io/ioutil"
-	"net/http"
-	"net/http/httptest"
-	"net/http/httputil"
-	"reflect"
-	"regexp"
-	"strings"
-	"sync"
-
-	. "github.com/onsi/gomega"
-)
-
-func new() *Server {
-	return &Server{
-		AllowUnhandledRequests:     false,
-		UnhandledRequestStatusCode: http.StatusInternalServerError,
-		rwMutex:                    &sync.RWMutex{},
-	}
-}
-
-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.
-	//Direct use of this property is deprecated and is likely to be removed, use GetAllowUnhandledRequests and SetAllowUnhandledRequests instead.
-	AllowUnhandledRequests bool
-
-	//The status code returned when receiving an unhandled request.
-	//Defaults to http.StatusInternalServerError.
-	//Only applies if AllowUnhandledRequests is true
-	//Direct use of this property is deprecated and is likely to be removed, use GetUnhandledRequestStatusCode and SetUnhandledRequestStatusCode instead.
-	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
-
-	rwMutex *sync.RWMutex
-	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 {
-	s.rwMutex.RLock()
-	defer s.rwMutex.RUnlock()
-	return s.HTTPTestServer.URL
-}
-
-//Addr() returns the address on which the server is listening.
-func (s *Server) Addr() string {
-	s.rwMutex.RLock()
-	defer s.rwMutex.RUnlock()
-	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.rwMutex.Lock()
-	server := s.HTTPTestServer
-	s.HTTPTestServer = nil
-	s.rwMutex.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 set to 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.rwMutex.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()
-		}()
-		Expect(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.rwMutex.Unlock()
-		routedHandler(w, req)
-	} else if s.calls < len(s.requestHandlers) {
-		h := s.requestHandlers[s.calls]
-		s.calls++
-		s.rwMutex.Unlock()
-		h(w, req)
-	} else {
-		s.rwMutex.Unlock()
-		if s.GetAllowUnhandledRequests() {
-			ioutil.ReadAll(req.Body)
-			req.Body.Close()
-			w.WriteHeader(s.GetUnhandledRequestStatusCode())
-		} else {
-			formatted, err := httputil.DumpRequest(req, true)
-			Expect(err).NotTo(HaveOccurred(), "Encountered error while dumping HTTP request")
-			Expect(string(formatted)).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.rwMutex.RLock()
-	defer s.rwMutex.RUnlock()
-
-	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.rwMutex.Lock()
-	defer s.rwMutex.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.rwMutex.Lock()
-	defer s.rwMutex.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.rwMutex.Lock()
-	defer s.rwMutex.Unlock()
-
-	s.requestHandlers[index] = handler
-}
-
-//GetHandler returns the handler registered at the passed in index.
-func (s *Server) GetHandler(index int) http.HandlerFunc {
-	s.rwMutex.RLock()
-	defer s.rwMutex.RUnlock()
-
-	return s.requestHandlers[index]
-}
-
-func (s *Server) Reset() {
-	s.rwMutex.Lock()
-	defer s.rwMutex.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.rwMutex.Lock()
-	defer s.rwMutex.Unlock()
-
-	s.HTTPTestServer.CloseClientConnections()
-}
-
-//SetAllowUnhandledRequests enables the server to accept unhandled requests.
-func (s *Server) SetAllowUnhandledRequests(allowUnhandledRequests bool) {
-	s.rwMutex.Lock()
-	defer s.rwMutex.Unlock()
-
-	s.AllowUnhandledRequests = allowUnhandledRequests
-}
-
-//GetAllowUnhandledRequests returns true if the server accepts unhandled requests.
-func (s *Server) GetAllowUnhandledRequests() bool {
-	s.rwMutex.RLock()
-	defer s.rwMutex.RUnlock()
-
-	return s.AllowUnhandledRequests
-}
-
-//SetUnhandledRequestStatusCode status code to be returned when the server receives unhandled requests
-func (s *Server) SetUnhandledRequestStatusCode(statusCode int) {
-	s.rwMutex.Lock()
-	defer s.rwMutex.Unlock()
-
-	s.UnhandledRequestStatusCode = statusCode
-}
-
-//GetUnhandledRequestStatusCode returns the current status code being returned for unhandled requests
-func (s *Server) GetUnhandledRequestStatusCode() int {
-	s.rwMutex.RLock()
-	defer s.rwMutex.RUnlock()
-
-	return s.UnhandledRequestStatusCode
-}
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 7c1236082..000000000
--- 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 be1c58e82..000000000
--- a/vendor/github.com/onsi/gomega/ghttp/test_server_test.go
+++ /dev/null
@@ -1,1129 +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() + "/")
-
-			Expect(s.ReceivedRequests()).Should(HaveLen(1))
-		})
-
-		It("clears all handlers and call counts", func() {
-			s.Reset()
-			Expect(s.ReceivedRequests()).Should(HaveLen(0))
-			Expect(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())
-			Expect(err).ShouldNot(HaveOccurred())
-			Expect(resp.StatusCode).Should(Equal(200))
-
-			body, err := ioutil.ReadAll(resp.Body)
-			resp.Body.Close()
-			Expect(err).ShouldNot(HaveOccurred())
-
-			s.CloseClientConnections()
-
-			resp, err = client.Get(s.URL())
-			Expect(err).ShouldNot(HaveOccurred())
-			Expect(resp.StatusCode).Should(Equal(200))
-
-			body2, err := ioutil.ReadAll(resp.Body)
-			resp.Body.Close()
-			Expect(err).ShouldNot(HaveOccurred())
-
-			Expect(body2).ShouldNot(Equal(body))
-		})
-	})
-
-	Describe("closing server mulitple times", func() {
-		It("should not fail", func() {
-			s.Close()
-			Expect(s.Close).ShouldNot(Panic())
-		})
-	})
-
-	Describe("allowing unhandled requests", func() {
-		It("is not permitted by default", func() {
-			Expect(s.GetAllowUnhandledRequests()).To(BeFalse())
-		})
-
-		Context("when true", func() {
-			BeforeEach(func() {
-				s.SetAllowUnhandledRequests(true)
-				s.SetUnhandledRequestStatusCode(http.StatusForbidden)
-				resp, err = http.Get(s.URL() + "/foo")
-				Expect(err).ShouldNot(HaveOccurred())
-			})
-
-			It("should allow unhandled requests and respond with the passed in status code", func() {
-				Expect(err).ShouldNot(HaveOccurred())
-				Expect(resp.StatusCode).Should(Equal(http.StatusForbidden))
-
-				data, err := ioutil.ReadAll(resp.Body)
-				Expect(err).ShouldNot(HaveOccurred())
-				Expect(data).Should(BeEmpty())
-			})
-
-			It("should record the requests", func() {
-				Expect(s.ReceivedRequests()).Should(HaveLen(1))
-				Expect(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")
-				})
-
-				Expect(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)
-			})
-
-			Expect(failures[0]).Should(ContainSubstring("Received Unhandled Request"))
-			Expect(failures).Should(HaveLen(4))
-
-			http.Post(s.URL()+"/routed3", "application/json", nil)
-
-			Expect(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)
-
-			Expect(called).Should(Equal([]string{"r3", "r4"}))
-		})
-
-		It("should call the appended handlers, in order, as requests come in", func() {
-			http.Get(s.URL() + "/foo")
-			Expect(called).Should(Equal([]string{"A"}))
-
-			http.Get(s.URL() + "/foo")
-			Expect(called).Should(Equal([]string{"A", "B"}))
-
-			failures := InterceptGomegaFailures(func() {
-				http.Get(s.URL() + "/foo")
-			})
-
-			Expect(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")
-				Expect(called).Should(Equal([]string{"C", "B"}))
-			})
-		})
-
-		Describe("Getting an existing handler", func() {
-			It("should return the handler func", func() {
-				s.GetHandler(1)(nil, nil)
-				Expect(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")
-				Expect(called).Should(Equal([]string{"A", "C", "B"}))
-			})
-		})
-	})
-
-	Describe("When a handler fails", func() {
-		BeforeEach(func() {
-			s.SetUnhandledRequestStatusCode(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())
-				})
-
-				Expect(err).ShouldNot(HaveOccurred())
-				Expect(resp.StatusCode).Should(Equal(http.StatusInternalServerError))
-				Expect(failures).Should(ConsistOf(ContainSubstring("Handler Panicked")))
-			})
-		})
-
-		Context("because an assertion has failed", func() {
-			BeforeEach(func() {
-				s.AppendHandlers(func(w http.ResponseWriter, req *http.Request) {
-					// Expect(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())
-
-				Expect(err).ShouldNot(HaveOccurred())
-				Expect(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")
-			Expect(buf).Should(gbytes.Say("GHTTP Received Request: GET - /foo\n"))
-
-			http.Post(s.URL()+"/bar", "", nil)
-			Expect(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")
-				Expect(err).ShouldNot(HaveOccurred())
-			})
-
-			It("should verify the method, path", func() {
-				failures := InterceptGomegaFailures(func() {
-					http.Get(s.URL() + "/foo2")
-				})
-				Expect(failures).Should(HaveLen(1))
-			})
-
-			It("should verify the method, path", func() {
-				failures := InterceptGomegaFailures(func() {
-					http.Post(s.URL()+"/foo", "application/json", nil)
-				})
-				Expect(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")
-					Expect(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())
-					Expect(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")
-					Expect(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)
-				Expect(err).ShouldNot(HaveOccurred())
-				req.Header.Set("Content-Type", "application/octet-stream")
-
-				resp, err = http.DefaultClient.Do(req)
-				Expect(err).ShouldNot(HaveOccurred())
-			})
-
-			It("should verify the content type", func() {
-				req, err := http.NewRequest("GET", s.URL()+"/foo", nil)
-				Expect(err).ShouldNot(HaveOccurred())
-				req.Header.Set("Content-Type", "application/json")
-
-				failures := InterceptGomegaFailures(func() {
-					http.DefaultClient.Do(req)
-				})
-				Expect(failures).Should(HaveLen(1))
-			})
-
-			It("should verify the content type", func() {
-				req, err := http.NewRequest("GET", s.URL()+"/foo", nil)
-				Expect(err).ShouldNot(HaveOccurred())
-				req.Header.Set("Content-Type", "application/octet-stream; charset=utf-8")
-
-				failures := InterceptGomegaFailures(func() {
-					http.DefaultClient.Do(req)
-				})
-				Expect(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)
-				Expect(err).ShouldNot(HaveOccurred())
-				req.SetBasicAuth("bob", "password")
-
-				resp, err = http.DefaultClient.Do(req)
-				Expect(err).ShouldNot(HaveOccurred())
-			})
-
-			It("should verify basic auth", func() {
-				req, err := http.NewRequest("GET", s.URL()+"/foo", nil)
-				Expect(err).ShouldNot(HaveOccurred())
-				req.SetBasicAuth("bob", "bassword")
-
-				failures := InterceptGomegaFailures(func() {
-					http.DefaultClient.Do(req)
-				})
-				Expect(failures).Should(HaveLen(1))
-			})
-
-			It("should require basic auth header", func() {
-				req, err := http.NewRequest("GET", s.URL()+"/foo", nil)
-				Expect(err).ShouldNot(HaveOccurred())
-
-				failures := InterceptGomegaFailures(func() {
-					http.DefaultClient.Do(req)
-				})
-				Expect(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)
-				Expect(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)
-				Expect(err).ShouldNot(HaveOccurred())
-			})
-
-			It("should verify the headers", func() {
-				req, err := http.NewRequest("GET", s.URL()+"/foo", nil)
-				Expect(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)
-				})
-				Expect(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)
-				Expect(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)
-				Expect(err).ShouldNot(HaveOccurred())
-			})
-
-			It("should verify the headers", func() {
-				req, err := http.NewRequest("GET", s.URL()+"/foo", nil)
-				Expect(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)
-				})
-				Expect(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")))
-				Expect(err).ShouldNot(HaveOccurred())
-			})
-
-			It("should verify the body", func() {
-				failures := InterceptGomegaFailures(func() {
-					http.Post(s.URL()+"/foo", "", bytes.NewReader([]byte("wrong body")))
-				})
-				Expect(failures).Should(HaveLen(1))
-			})
-		})
-
-		Describe("VerifyMimeType", func() {
-			BeforeEach(func() {
-				s.AppendHandlers(CombineHandlers(
-					VerifyMimeType("application/json"),
-				))
-			})
-
-			It("should verify the mime type in content-type header", func() {
-				resp, err = http.Post(s.URL()+"/foo", "application/json; charset=utf-8", bytes.NewReader([]byte(`{}`)))
-				Expect(err).ShouldNot(HaveOccurred())
-			})
-
-			It("should verify the mime type in content-type header", func() {
-				failures := InterceptGomegaFailures(func() {
-					http.Post(s.URL()+"/foo", "text/plain", bytes.NewReader([]byte(`{}`)))
-				})
-				Expect(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}`)))
-				Expect(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}`)))
-				})
-				Expect(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}`)))
-				})
-				Expect(failures).Should(HaveLen(1))
-			})
-
-			It("should verify the json body and the content type", func() {
-				resp, err = http.Post(s.URL()+"/foo", "application/json; charset=utf-8", bytes.NewReader([]byte(`{"b":2, "a":3}`)))
-				Expect(err).ShouldNot(HaveOccurred())
-			})
-		})
-
-		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]`)))
-				Expect(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]`)))
-				})
-				Expect(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())
-					Expect(err).ShouldNot(HaveOccurred())
-				})
-
-				It("should ignore extra values", func() {
-					formValues.Add("extra", "value")
-					resp, err = http.Get(s.URL() + "/foo?" + formValues.Encode())
-					Expect(err).ShouldNot(HaveOccurred())
-				})
-
-				It("fail on missing values", func() {
-					formValues.Del("group")
-					failures := InterceptGomegaFailures(func() {
-						resp, err = http.Get(s.URL() + "/foo?" + formValues.Encode())
-					})
-					Expect(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())
-					})
-					Expect(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)
-					Expect(err).ShouldNot(HaveOccurred())
-				})
-
-				It("should ignore extra values", func() {
-					formValues.Add("extra", "value")
-					resp, err = http.PostForm(s.URL()+"/foo", formValues)
-					Expect(err).ShouldNot(HaveOccurred())
-				})
-
-				It("fail on missing values", func() {
-					formValues.Del("group")
-					failures := InterceptGomegaFailures(func() {
-						resp, err = http.PostForm(s.URL()+"/foo", formValues)
-					})
-					Expect(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)
-					})
-					Expect(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")
-					Expect(err).ShouldNot(HaveOccurred())
-				})
-
-				It("verifies the form value", func() {
-					failures := InterceptGomegaFailures(func() {
-						resp, err = http.Get(s.URL() + "/foo?users=user1")
-					})
-					Expect(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"}})
-					Expect(err).ShouldNot(HaveOccurred())
-				})
-
-				It("verifies the form value", func() {
-					failures := InterceptGomegaFailures(func() {
-						resp, err = http.PostForm(s.URL()+"/foo", url.Values{"users": []string{"user1"}})
-					})
-					Expect(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)
-				Expect(err).ShouldNot(HaveOccurred())
-
-				resp, err = http.Post(s.URL()+"/proto", "application/x-protobuf", bytes.NewReader(serialized))
-				Expect(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"),
-				})
-				Expect(err).ShouldNot(HaveOccurred())
-
-				failures := InterceptGomegaFailures(func() {
-					http.Post(s.URL()+"/proto", "application/x-protobuf", bytes.NewReader(serialized))
-				})
-				Expect(failures).Should(HaveLen(1))
-			})
-
-			It("should verify the proto body and the content type", func() {
-				serialized, err := proto.Marshal(message)
-				Expect(err).ShouldNot(HaveOccurred())
-
-				failures := InterceptGomegaFailures(func() {
-					http.Post(s.URL()+"/proto", "application/not-x-protobuf", bytes.NewReader(serialized))
-				})
-				Expect(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)
-					Expect(err).ShouldNot(HaveOccurred())
-
-					Expect(resp.StatusCode).Should(Equal(http.StatusCreated))
-
-					body, err := ioutil.ReadAll(resp.Body)
-					Expect(err).ShouldNot(HaveOccurred())
-					Expect(body).Should(Equal([]byte("sweet")))
-
-					resp, err = http.Post(s.URL()+"/foo", "application/json", nil)
-					Expect(err).ShouldNot(HaveOccurred())
-
-					Expect(resp.StatusCode).Should(Equal(http.StatusOK))
-
-					body, err = ioutil.ReadAll(resp.Body)
-					Expect(err).ShouldNot(HaveOccurred())
-					Expect(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)
-					Expect(err).ShouldNot(HaveOccurred())
-
-					Expect(resp.StatusCode).Should(Equal(http.StatusCreated))
-					Expect(ioutil.ReadAll(resp.Body)).Should(Equal([]byte("sweet")))
-					Expect(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)
-				Expect(err).ShouldNot(HaveOccurred())
-
-				Expect(resp.StatusCode).Should(Equal(http.StatusCreated))
-
-				body, err := ioutil.ReadAll(resp.Body)
-				Expect(err).ShouldNot(HaveOccurred())
-				Expect(body).Should(Equal([]byte("tasty")))
-
-				resp, err = http.Post(s.URL()+"/foo", "application/json", nil)
-				Expect(err).ShouldNot(HaveOccurred())
-
-				Expect(resp.StatusCode).Should(Equal(http.StatusCreated))
-
-				body, err = ioutil.ReadAll(resp.Body)
-				Expect(err).ShouldNot(HaveOccurred())
-				Expect(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)
-
-					Expect(err).ShouldNot(HaveOccurred())
-					Expect(resp.StatusCode).Should(Equal(http.StatusOK))
-					body, err := ioutil.ReadAll(resp.Body)
-					Expect(err).ShouldNot(HaveOccurred())
-					Expect(body).Should(BeEmpty())
-
-					Expect(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)
-					Expect(err).ShouldNot(HaveOccurred())
-
-					Expect(resp.StatusCode).Should(Equal(http.StatusCreated))
-
-					body, err := ioutil.ReadAll(resp.Body)
-					Expect(err).ShouldNot(HaveOccurred())
-					Expect(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)
-					Expect(err).ShouldNot(HaveOccurred())
-
-					Expect(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)
-					Expect(err).ShouldNot(HaveOccurred())
-
-					Expect(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)
-					Expect(err).ShouldNot(HaveOccurred())
-
-					Expect(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)
-						Expect(err).ShouldNot(HaveOccurred())
-
-						Expect(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)
-					Expect(err).ShouldNot(HaveOccurred())
-
-					Expect(resp.StatusCode).Should(Equal(http.StatusCreated))
-
-					body, err := ioutil.ReadAll(resp.Body)
-					Expect(err).ShouldNot(HaveOccurred())
-					Expect(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)
-					Expect(err).ShouldNot(HaveOccurred())
-
-					Expect(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)
-					Expect(err).ShouldNot(HaveOccurred())
-
-					Expect(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)
-					Expect(err).ShouldNot(HaveOccurred())
-
-					Expect(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)
-						Expect(err).ShouldNot(HaveOccurred())
-
-						Expect(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)
-					Expect(err).ShouldNot(HaveOccurred())
-
-					Expect(resp.StatusCode).Should(Equal(http.StatusCreated))
-
-					var received protobuf.SimpleMessage
-					body, err := ioutil.ReadAll(resp.Body)
-					err = proto.Unmarshal(body, &received)
-					Expect(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)
-					Expect(err).ShouldNot(HaveOccurred())
-
-					Expect(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)
-					Expect(err).ShouldNot(HaveOccurred())
-
-					Expect(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)
-					Expect(err).ShouldNot(HaveOccurred())
-
-					Expect(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)
-						Expect(err).ShouldNot(HaveOccurred())
-
-						Expect(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 13bf5b895..000000000
--- a/vendor/github.com/onsi/gomega/gstruct/elements.go
+++ /dev/null
@@ -1,159 +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.
-//    idFn := func(element interface{}) string {
-//        return fmt.Sprintf("%v", element)
-//    }
-//
-//    Expect([]string{"a", "b"}).To(MatchAllElements(idFn, Elements{
-//        "a": Equal("a"),
-//        "b": Equal("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.
-//    idFn := func(element interface{}) string {
-//        return fmt.Sprintf("%v", element)
-//    }
-//
-//    Expect([]string{"a", "b", "c"}).To(MatchElements(idFn, IgnoreExtras, Elements{
-//        "a": Equal("a"),
-//        "b": Equal("b"),
-//    }))
-//    Expect([]string{"a", "c"}).To(MatchElements(idFn, IgnoreMissing, Elements{
-//        "a": Equal("a"),
-//        "b": Equal("b"),
-//        "c": Equal("c"),
-//        "d": Equal("d"),
-//    }))
-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 355d463eb..000000000
--- 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"),
-		})
-		Expect(allElements).Should(m, "should match all elements")
-		Expect(missingElements).ShouldNot(m, "should fail with missing elements")
-		Expect(extraElements).ShouldNot(m, "should fail with extra elements")
-		Expect(duplicateElements).ShouldNot(m, "should fail with duplicate elements")
-		Expect(nils).ShouldNot(m, "should fail with an uninitialized slice")
-
-		m = MatchAllElements(id, Elements{
-			"a": Equal("a"),
-			"b": Equal("fail"),
-		})
-		Expect(allElements).ShouldNot(m, "should run nested matchers")
-
-		m = MatchAllElements(id, Elements{})
-		Expect(empty).Should(m, "should handle empty slices")
-		Expect(allElements).ShouldNot(m, "should handle only empty slices")
-		Expect(nils).Should(m, "should handle nil slices")
-	})
-
-	It("should ignore extra elements", func() {
-		m := MatchElements(id, IgnoreExtras, Elements{
-			"b": Equal("b"),
-			"a": Equal("a"),
-		})
-		Expect(allElements).Should(m, "should match all elements")
-		Expect(missingElements).ShouldNot(m, "should fail with missing elements")
-		Expect(extraElements).Should(m, "should ignore extra elements")
-		Expect(duplicateElements).ShouldNot(m, "should fail with duplicate elements")
-		Expect(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"),
-		})
-		Expect(allElements).Should(m, "should match all elements")
-		Expect(missingElements).Should(m, "should ignore missing elements")
-		Expect(extraElements).ShouldNot(m, "should fail with extra elements")
-		Expect(duplicateElements).ShouldNot(m, "should fail with duplicate elements")
-		Expect(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"),
-		})
-		Expect(allElements).Should(m, "should match all elements")
-		Expect(missingElements).Should(m, "should ignore missing elements")
-		Expect(extraElements).Should(m, "should ignore extra elements")
-		Expect(duplicateElements).ShouldNot(m, "should fail with duplicate elements")
-		Expect(nils).Should(m, "should ignore an uninitialized slice")
-
-		m = MatchElements(id, IgnoreExtras|IgnoreMissing, Elements{
-			"a": Equal("a"),
-			"b": Equal("fail"),
-		})
-		Expect(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"),
-			})
-			Expect(allElements).Should(m, "should match all elements")
-			Expect(includingBadElements).ShouldNot(m, "should reject if a member fails the matcher")
-			Expect(extraElements).ShouldNot(m, "should reject with extra keys")
-			Expect(missingElements).ShouldNot(m, "should reject with missing keys")
-			Expect(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"),
-			})
-			Expect(allElements).Should(m, "should match all elements")
-			Expect(includingBadElements).ShouldNot(m, "should reject if a member fails the matcher")
-			Expect(extraElements).ShouldNot(m, "should reject with extra keys")
-			Expect(missingElements).Should(m, "should allow missing keys")
-			Expect(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"),
-			})
-			Expect(allElements).Should(m, "should match all elements")
-			Expect(includingBadElements).ShouldNot(m, "should reject if a member fails the matcher")
-			Expect(extraElements).Should(m, "should allow extra keys")
-			Expect(missingElements).ShouldNot(m, "should reject missing keys")
-			Expect(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"),
-			})
-			Expect(allElements).Should(m, "should match all elements")
-			Expect(includingBadElements).ShouldNot(m, "should reject if a member fails the matcher")
-			Expect(extraElements).Should(m, "should allow extra keys")
-			Expect(missingElements).Should(m, "should allow missing keys")
-			Expect(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 188492b21..000000000
--- 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 2eb2d0887..000000000
--- a/vendor/github.com/onsi/gomega/gstruct/fields.go
+++ /dev/null
@@ -1,168 +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.
-//    actual := struct{
-//      A int
-//      B []bool
-//      C string
-//    }{
-//      A: 5,
-//      B: []bool{true, false},
-//      C: "foo",
-//    }
-//
-//    Expect(actual).To(MatchAllFields(Fields{
-//      "A": Equal(5),
-//      "B": ConsistOf(true, false),
-//      "C": Equal("foo"),
-//    }))
-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.
-//    actual := struct{
-//      A int
-//      B []bool
-//      C string
-//    }{
-//      A: 5,
-//      B: []bool{true, false},
-//      C: "foo",
-//    }
-//
-//    Expect(actual).To(MatchFields(IgnoreExtras, Fields{
-//      "A": Equal(5),
-//      "B": ConsistOf(true, false),
-//    }))
-//    Expect(actual).To(MatchFields(IgnoreMissing, Fields{
-//      "A": Equal(5),
-//      "B": ConsistOf(true, false),
-//      "C": Equal("foo"),
-//      "D": Equal("extra"),
-//    }))
-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 e4e039e21..000000000
--- 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"),
-		})
-		Expect(allFields).Should(m, "should match all fields")
-		Expect(missingFields).ShouldNot(m, "should fail with missing fields")
-		Expect(extraFields).ShouldNot(m, "should fail with extra fields")
-		Expect(emptyFields).ShouldNot(m, "should fail with empty fields")
-
-		m = MatchAllFields(Fields{
-			"A": Equal("a"),
-			"B": Equal("fail"),
-		})
-		Expect(allFields).ShouldNot(m, "should run nested matchers")
-	})
-
-	It("should handle empty structs", func() {
-		m := MatchAllFields(Fields{})
-		Expect(struct{}{}).Should(m, "should handle empty structs")
-		Expect(allFields).ShouldNot(m, "should fail with extra fields")
-	})
-
-	It("should ignore missing fields", func() {
-		m := MatchFields(IgnoreMissing, Fields{
-			"B": Equal("b"),
-			"A": Equal("a"),
-		})
-		Expect(allFields).Should(m, "should match all fields")
-		Expect(missingFields).Should(m, "should ignore missing fields")
-		Expect(extraFields).ShouldNot(m, "should fail with extra fields")
-		Expect(emptyFields).ShouldNot(m, "should fail with empty fields")
-	})
-
-	It("should ignore extra fields", func() {
-		m := MatchFields(IgnoreExtras, Fields{
-			"B": Equal("b"),
-			"A": Equal("a"),
-		})
-		Expect(allFields).Should(m, "should match all fields")
-		Expect(missingFields).ShouldNot(m, "should fail with missing fields")
-		Expect(extraFields).Should(m, "should ignore extra fields")
-		Expect(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"),
-		})
-		Expect(allFields).Should(m, "should match all fields")
-		Expect(missingFields).Should(m, "should ignore missing fields")
-		Expect(extraFields).Should(m, "should ignore extra fields")
-		Expect(emptyFields).ShouldNot(m, "should fail with empty fields")
-
-		m = MatchFields(IgnoreMissing|IgnoreExtras, Fields{
-			"A": Equal("a"),
-			"B": Equal("fail"),
-		})
-		Expect(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 d47566304..000000000
--- 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 0365f32ad..000000000
--- 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 07775e742..000000000
--- 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() {
-		Expect(nil).Should(Ignore())
-		Expect(struct{}{}).Should(Ignore())
-		Expect(0).Should(Ignore())
-		Expect(false).Should(Ignore())
-	})
-
-	It("should always fail", func() {
-		Expect(nil).ShouldNot(Reject())
-		Expect(struct{}{}).ShouldNot(Reject())
-		Expect(1).ShouldNot(Reject())
-		Expect(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 0a2f35de3..000000000
--- 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 805a92abe..000000000
--- 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{}
-		Expect(p).Should(BeNil())
-	})
-
-	It("should succeed when passed non-nil pointer", func() {
-		var s struct{}
-		Expect(&s).Should(PointTo(Ignore()))
-	})
-
-	It("should unwrap the pointee value", func() {
-		i := 1
-		Expect(&i).Should(PointTo(Equal(1)))
-		Expect(&i).ShouldNot(PointTo(Equal(2)))
-	})
-
-	It("should work with nested pointers", func() {
-		i := 1
-		ip := &i
-		ipp := &ip
-		Expect(ipp).Should(PointTo(PointTo(Equal(1))))
-		Expect(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 48cbbe8f6..000000000
--- 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 dae47a48b..000000000
--- 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 cac0d24c5..000000000
--- a/vendor/github.com/onsi/gomega/internal/assertion/assertion_test.go
+++ /dev/null
@@ -1,258 +0,0 @@
-package assertion_test
-
-import (
-	"errors"
-
-	"github.com/onsi/gomega/internal/testingtsupport"
-
-	. "github.com/onsi/ginkgo"
-	. "github.com/onsi/gomega"
-	. "github.com/onsi/gomega/internal/assertion"
-	"github.com/onsi/gomega/internal/fakematcher"
-	"github.com/onsi/gomega/types"
-)
-
-var _ = Describe("Assertion", func() {
-	var (
-		a                 *Assertion
-		failureMessage    string
-		failureCallerSkip int
-		matcher           *fakematcher.FakeMatcher
-	)
-
-	input := "The thing I'm testing"
-
-	var fakeFailWrapper = &types.GomegaFailWrapper{
-		Fail: func(message string, callerSkip ...int) {
-			failureMessage = message
-			if len(callerSkip) == 1 {
-				failureCallerSkip = callerSkip[0]
-			}
-		},
-		TWithHelper: testingtsupport.EmptyTWithHelper{},
-	}
-
-	BeforeEach(func() {
-		matcher = &fakematcher.FakeMatcher{}
-		failureMessage = ""
-		failureCallerSkip = 0
-		a = New(input, fakeFailWrapper, 1)
-	})
-
-	Context("when called", func() {
-		It("should pass the provided input value to the matcher", func() {
-			a.Should(matcher)
-
-			Expect(matcher.ReceivedActual).Should(Equal(input))
-			matcher.ReceivedActual = ""
-
-			a.ShouldNot(matcher)
-
-			Expect(matcher.ReceivedActual).Should(Equal(input))
-			matcher.ReceivedActual = ""
-
-			a.To(matcher)
-
-			Expect(matcher.ReceivedActual).Should(Equal(input))
-			matcher.ReceivedActual = ""
-
-			a.ToNot(matcher)
-
-			Expect(matcher.ReceivedActual).Should(Equal(input))
-			matcher.ReceivedActual = ""
-
-			a.NotTo(matcher)
-
-			Expect(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)
-				Expect(failureMessage).Should(Equal(""))
-			})
-
-			It("should be true", func() {
-				Expect(a.Should(matcher)).Should(BeTrue())
-			})
-		})
-
-		Context("and a negative assertion is being made", func() {
-			It("should call the failure callback", func() {
-				a.ShouldNot(matcher)
-				Expect(failureMessage).Should(Equal("negative: The thing I'm testing"))
-				Expect(failureCallerSkip).Should(Equal(3))
-			})
-
-			It("should be false", func() {
-				Expect(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)
-				Expect(failureMessage).Should(Equal("positive: The thing I'm testing"))
-				Expect(failureCallerSkip).Should(Equal(3))
-			})
-
-			It("should be false", func() {
-				Expect(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)
-				Expect(failureMessage).Should(Equal(""))
-			})
-
-			It("should be true", func() {
-				Expect(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")
-				Expect(failureMessage).Should(Equal("A description\npositive: The thing I'm testing"))
-				Expect(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)
-				Expect(failureMessage).Should(Equal("A description of [3]\npositive: The thing I'm testing"))
-				Expect(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)
-				Expect(failureMessage).Should(Equal("Kaboom!"))
-				Expect(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)
-				Expect(failureMessage).Should(Equal("Kaboom!"))
-				Expect(failureCallerSkip).Should(Equal(3))
-			})
-		})
-
-		It("should always be false", func() {
-			Expect(a.Should(matcher)).Should(BeFalse())
-			Expect(a.ShouldNot(matcher)).Should(BeFalse())
-		})
-	})
-
-	Context("when there are extra parameters", func() {
-		It("(a simple example)", func() {
-			Expect(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, fakeFailWrapper, 1, 0, nil, typedNil)
-
-				result := a.Should(matcher)
-				Expect(result).Should(BeTrue())
-				Expect(matcher.ReceivedActual).Should(Equal(input))
-
-				Expect(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, fakeFailWrapper, 1, errors.New("foo"))
-				result := a.Should(matcher)
-				Expect(result).Should(BeFalse())
-				Expect(matcher.ReceivedActual).Should(BeZero(), "The matcher doesn't even get called")
-				Expect(failureMessage).Should(ContainSubstring("foo"))
-				failureMessage = ""
-
-				a = New(input, fakeFailWrapper, 1, nil, 1)
-				result = a.ShouldNot(matcher)
-				Expect(result).Should(BeFalse())
-				Expect(failureMessage).Should(ContainSubstring("1"))
-				failureMessage = ""
-
-				a = New(input, fakeFailWrapper, 1, nil, 0, []string{"foo"})
-				result = a.To(matcher)
-				Expect(result).Should(BeFalse())
-				Expect(failureMessage).Should(ContainSubstring("foo"))
-				failureMessage = ""
-
-				a = New(input, fakeFailWrapper, 1, nil, 0, []string{"foo"})
-				result = a.ToNot(matcher)
-				Expect(result).Should(BeFalse())
-				Expect(failureMessage).Should(ContainSubstring("foo"))
-				failureMessage = ""
-
-				a = New(input, fakeFailWrapper, 1, nil, 0, []string{"foo"})
-				result = a.NotTo(matcher)
-				Expect(result).Should(BeFalse())
-				Expect(failureMessage).Should(ContainSubstring("foo"))
-				Expect(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)
-			Expect(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 bdb0c3d22..000000000
--- 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 afd61a7cd..000000000
--- a/vendor/github.com/onsi/gomega/internal/asyncassertion/async_assertion_test.go
+++ /dev/null
@@ -1,351 +0,0 @@
-package asyncassertion_test
-
-import (
-	"errors"
-	"time"
-
-	"github.com/onsi/gomega/internal/testingtsupport"
-
-	. "github.com/onsi/ginkgo"
-	. "github.com/onsi/gomega"
-	. "github.com/onsi/gomega/internal/asyncassertion"
-	"github.com/onsi/gomega/types"
-)
-
-var _ = Describe("Async Assertion", func() {
-	var (
-		failureMessage string
-		callerSkip     int
-	)
-
-	var fakeFailWrapper = &types.GomegaFailWrapper{
-		Fail: func(message string, skip ...int) {
-			failureMessage = message
-			callerSkip = skip[0]
-		},
-		TWithHelper: testingtsupport.EmptyTWithHelper{},
-	}
-
-	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
-				}, fakeFailWrapper, time.Duration(0.2*float64(time.Second)), time.Duration(0.02*float64(time.Second)), 1)
-
-				a.Should(BeNumerically("==", 5))
-				Expect(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
-				}, fakeFailWrapper, time.Duration(0.2*float64(time.Second)), time.Duration(0.02*float64(time.Second)), 1)
-
-				a.Should(BeNumerically("==", 5), "My description %d", 2)
-
-				Expect(failureMessage).Should(ContainSubstring("Timed out after"))
-				Expect(failureMessage).Should(ContainSubstring("My description 2"))
-				Expect(callerSkip).Should(Equal(4))
-			})
-
-			It("should be able to timeout", func() {
-				counter := 0
-				a := New(AsyncAssertionTypeEventually, func() int {
-					counter++
-					return counter
-				}, fakeFailWrapper, time.Duration(0.2*float64(time.Second)), time.Duration(0.02*float64(time.Second)), 1)
-
-				a.Should(BeNumerically(">", 100), "My description %d", 2)
-
-				Expect(counter).Should(BeNumerically(">", 8))
-				Expect(counter).Should(BeNumerically("<=", 10))
-				Expect(failureMessage).Should(ContainSubstring("Timed out after"))
-				Expect(failureMessage).Should(MatchRegexp(`\<int\>: \d`), "Should pass the correct value to the matcher message formatter.")
-				Expect(failureMessage).Should(ContainSubstring("My description 2"))
-				Expect(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
-				}, fakeFailWrapper, time.Duration(0.2*float64(time.Second)), time.Duration(0.02*float64(time.Second)), 1)
-
-				a.ShouldNot(BeNumerically("<", 3))
-
-				Expect(counter).Should(Equal(3))
-				Expect(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
-				}, fakeFailWrapper, time.Duration(0.2*float64(time.Second)), time.Duration(0.02*float64(time.Second)), 1)
-
-				a.ShouldNot(HaveLen(0), "My description %d", 2)
-
-				Expect(failureMessage).Should(ContainSubstring("Timed out after"))
-				Expect(failureMessage).Should(ContainSubstring("Error:"))
-				Expect(failureMessage).Should(ContainSubstring("My description 2"))
-				Expect(callerSkip).Should(Equal(4))
-			})
-
-			It("should be able to timeout", func() {
-				a := New(AsyncAssertionTypeEventually, func() int {
-					return 0
-				}, fakeFailWrapper, time.Duration(0.1*float64(time.Second)), time.Duration(0.02*float64(time.Second)), 1)
-
-				a.ShouldNot(Equal(0), "My description %d", 2)
-
-				Expect(failureMessage).Should(ContainSubstring("Timed out after"))
-				Expect(failureMessage).Should(ContainSubstring("<int>: 0"), "Should pass the correct value to the matcher message formatter.")
-				Expect(failureMessage).Should(ContainSubstring("My description 2"))
-				Expect(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")
-				}, fakeFailWrapper, time.Duration(0.2*float64(time.Second)), time.Duration(0.02*float64(time.Second)), 1)
-				a.Should(Equal(2))
-
-				Expect(failureMessage).Should(ContainSubstring("Timed out after"))
-				Expect(failureMessage).Should(ContainSubstring("Error:"))
-				Expect(failureMessage).Should(ContainSubstring("bam"))
-				Expect(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"
-					}, fakeFailWrapper, time.Duration(0.2*float64(time.Second)), time.Duration(0.02*float64(time.Second)), 1)
-
-					a.Should(Equal("foo"))
-					Expect(calls).Should(BeNumerically(">", 8))
-					Expect(calls).Should(BeNumerically("<=", 10))
-					Expect(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"
-					}, fakeFailWrapper, time.Duration(0.2*float64(time.Second)), time.Duration(0.02*float64(time.Second)), 1)
-
-					a.Should(Equal("foo"))
-					Expect(failureMessage).Should(ContainSubstring("to equal"))
-					Expect(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}
-					}, fakeFailWrapper, time.Duration(0.2*float64(time.Second)), time.Duration(0.02*float64(time.Second)), 1)
-
-					a.Should(HaveLen(3))
-					Expect(failureMessage).Should(ContainSubstring("HaveLen matcher expects"))
-					Expect(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, fakeFailWrapper, time.Duration(0.2*float64(time.Second)), time.Duration(0.02*float64(time.Second)), 1)
-
-					a.ShouldNot(Receive())
-					Expect(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, fakeFailWrapper, time.Duration(0.2*float64(time.Second)), time.Duration(0.02*float64(time.Second)), 1)
-
-					a.ShouldNot(Receive())
-					Expect(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
-					}, fakeFailWrapper, time.Duration(0.2*float64(time.Second)), time.Duration(0.02*float64(time.Second)), 1)
-
-					a.ShouldNot(BeNumerically(">", 5))
-					Expect(failureMessage).Should(ContainSubstring("not to be >"))
-					Expect(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")
-				}, fakeFailWrapper, time.Duration(0.2*float64(time.Second)), time.Duration(0.02*float64(time.Second)), 1)
-				a.Should(BeNumerically(">=", 2))
-
-				Expect(failureMessage).Should(ContainSubstring("Error:"))
-				Expect(failureMessage).Should(ContainSubstring("bam"))
-				Expect(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() {
-			Expect(func() {
-				New(AsyncAssertionTypeEventually, func() {}, fakeFailWrapper, 0, 0, 1)
-			}).Should(Panic())
-
-			Expect(func() {
-				New(AsyncAssertionTypeEventually, func(a string) int { return 0 }, fakeFailWrapper, 0, 0, 1)
-			}).Should(Panic())
-
-			Expect(func() {
-				New(AsyncAssertionTypeEventually, func() int { return 0 }, fakeFailWrapper, 0, 0, 1)
-			}).ShouldNot(Panic())
-
-			Expect(func() {
-				New(AsyncAssertionTypeEventually, func() (int, error) { return 0, nil }, fakeFailWrapper, 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())
-				})
-				Expect(time.Since(t)).Should(BeNumerically("<", 90*time.Millisecond))
-
-				Expect(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())
-				})
-				Expect(time.Since(t)).Should(BeNumerically(">=", 90*time.Millisecond))
-
-				Expect(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 6e351a7de..000000000
--- 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 8fd8f0a6c..000000000
--- a/vendor/github.com/onsi/gomega/internal/testingtsupport/testing_t_support_test.go
+++ /dev/null
@@ -1,92 +0,0 @@
-package testingtsupport_test
-
-import (
-	"regexp"
-	"time"
-
-	"github.com/onsi/gomega/internal/testingtsupport"
-
-	. "github.com/onsi/gomega"
-
-	"fmt"
-	"testing"
-)
-
-func TestTestingT(t *testing.T) {
-	RegisterTestingT(t)
-	Ω(true).Should(BeTrue())
-}
-
-type FakeTWithHelper struct {
-	LastFatal string
-}
-
-func (f *FakeTWithHelper) Fatalf(format string, args ...interface{}) {
-	f.LastFatal = fmt.Sprintf(format, args...)
-}
-
-func TestGomegaWithTWithoutHelper(t *testing.T) {
-	g := NewGomegaWithT(t)
-
-	testingtsupport.StackTracePruneRE = regexp.MustCompile(`\/ginkgo\/`)
-
-	f := &FakeTWithHelper{}
-	testG := NewGomegaWithT(f)
-
-	testG.Expect("foo").To(Equal("foo"))
-	g.Expect(f.LastFatal).To(BeZero())
-
-	testG.Expect("foo").To(Equal("bar"))
-	g.Expect(f.LastFatal).To(ContainSubstring("<string>: foo"))
-	g.Expect(f.LastFatal).To(ContainSubstring("testingtsupport_test"), "It should include a stacktrace")
-
-	testG.Eventually("foo2", time.Millisecond).Should(Equal("bar"))
-	g.Expect(f.LastFatal).To(ContainSubstring("<string>: foo2"))
-
-	testG.Consistently("foo3", time.Millisecond).Should(Equal("bar"))
-	g.Expect(f.LastFatal).To(ContainSubstring("<string>: foo3"))
-}
-
-type FakeTWithoutHelper struct {
-	LastFatal   string
-	HelperCount int
-}
-
-func (f *FakeTWithoutHelper) Fatalf(format string, args ...interface{}) {
-	f.LastFatal = fmt.Sprintf(format, args...)
-}
-
-func (f *FakeTWithoutHelper) Helper() {
-	f.HelperCount += 1
-}
-
-func (f *FakeTWithoutHelper) ResetHelper() {
-	f.HelperCount = 0
-}
-
-func TestGomegaWithTWithHelper(t *testing.T) {
-	g := NewGomegaWithT(t)
-
-	f := &FakeTWithoutHelper{}
-	testG := NewGomegaWithT(f)
-
-	testG.Expect("foo").To(Equal("foo"))
-	g.Expect(f.LastFatal).To(BeZero())
-	g.Expect(f.HelperCount).To(BeNumerically(">", 0))
-	f.ResetHelper()
-
-	testG.Expect("foo").To(Equal("bar"))
-	g.Expect(f.LastFatal).To(ContainSubstring("<string>: foo"))
-	g.Expect(f.LastFatal).NotTo(ContainSubstring("testingtsupport_test"), "It should _not_ include a stacktrace")
-	g.Expect(f.HelperCount).To(BeNumerically(">", 0))
-	f.ResetHelper()
-
-	testG.Eventually("foo2", time.Millisecond).Should(Equal("bar"))
-	g.Expect(f.LastFatal).To(ContainSubstring("<string>: foo2"))
-	g.Expect(f.HelperCount).To(BeNumerically(">", 0))
-	f.ResetHelper()
-
-	testG.Consistently("foo3", time.Millisecond).Should(Equal("bar"))
-	g.Expect(f.LastFatal).To(ContainSubstring("<string>: foo3"))
-	g.Expect(f.HelperCount).To(BeNumerically(">", 0))
-}
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 acf778cd6..000000000
--- 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 471a46d97..000000000
--- a/vendor/github.com/onsi/gomega/matchers/assignable_to_type_of_matcher_test.go
+++ /dev/null
@@ -1,46 +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() {
-			Expect(0).Should(BeAssignableToTypeOf(0))
-			Expect(5).Should(BeAssignableToTypeOf(-1))
-			Expect("foo").Should(BeAssignableToTypeOf("bar"))
-			Expect(struct{ Foo string }{}).Should(BeAssignableToTypeOf(struct{ Foo string }{}))
-
-			Expect(0).ShouldNot(BeAssignableToTypeOf("bar"))
-			Expect(5).ShouldNot(BeAssignableToTypeOf(struct{ Foo string }{}))
-			Expect("foo").ShouldNot(BeAssignableToTypeOf(42))
-		})
-	})
-
-	Context("When asserting nil values", func() {
-		It("should error", func() {
-			success, err := (&AssignableToTypeOfMatcher{Expected: nil}).Match(nil)
-			Expect(success).Should(BeFalse())
-			Expect(err).Should(HaveOccurred())
-		})
-
-		Context("When actual is nil and expected is not nil", func() {
-			It("should return false without error", func() {
-				success, err := (&AssignableToTypeOfMatcher{Expected: 17}).Match(nil)
-				Expect(success).Should(BeFalse())
-				Expect(err).ShouldNot(HaveOccurred())
-			})
-		})
-
-		Context("When actual is not nil and expected is nil", func() {
-			It("should error", func() {
-				success, err := (&AssignableToTypeOfMatcher{Expected: nil}).Match(17)
-				Expect(success).Should(BeFalse())
-				Expect(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 bc8742763..000000000
--- 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() {
-			Expect("/dne/test").ShouldNot(BeADirectory())
-
-			tmpFile, err := ioutil.TempFile("", "gomega-test-tempfile")
-			Expect(err).ShouldNot(HaveOccurred())
-			defer os.Remove(tmpFile.Name())
-			Expect(tmpFile.Name()).ShouldNot(BeADirectory())
-
-			tmpDir, err := ioutil.TempDir("", "gomega-test-tempdir")
-			Expect(err).ShouldNot(HaveOccurred())
-			defer os.Remove(tmpDir)
-			Expect(tmpDir).Should(BeADirectory())
-		})
-	})
-
-	Context("when passed something else", func() {
-		It("should error", func() {
-			success, err := (&BeADirectoryMatcher{}).Match(nil)
-			Expect(success).Should(BeFalse())
-			Expect(err).Should(HaveOccurred())
-
-			success, err = (&BeADirectoryMatcher{}).Match(true)
-			Expect(success).Should(BeFalse())
-			Expect(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 eae06a03e..000000000
--- 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() {
-			Expect("/dne/test").ShouldNot(BeARegularFile())
-
-			tmpFile, err := ioutil.TempFile("", "gomega-test-tempfile")
-			Expect(err).ShouldNot(HaveOccurred())
-			defer os.Remove(tmpFile.Name())
-			Expect(tmpFile.Name()).Should(BeARegularFile())
-
-			tmpDir, err := ioutil.TempDir("", "gomega-test-tempdir")
-			Expect(err).ShouldNot(HaveOccurred())
-			defer os.Remove(tmpDir)
-			Expect(tmpDir).ShouldNot(BeARegularFile())
-		})
-	})
-
-	Context("when passed something else", func() {
-		It("should error", func() {
-			success, err := (&BeARegularFileMatcher{}).Match(nil)
-			Expect(success).Should(BeFalse())
-			Expect(err).Should(HaveOccurred())
-
-			success, err = (&BeARegularFileMatcher{}).Match(true)
-			Expect(success).Should(BeFalse())
-			Expect(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 e28bd0d65..000000000
--- 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() {
-			Expect("/dne/test").ShouldNot(BeAnExistingFile())
-
-			tmpFile, err := ioutil.TempFile("", "gomega-test-tempfile")
-			Expect(err).ShouldNot(HaveOccurred())
-			defer os.Remove(tmpFile.Name())
-			Expect(tmpFile.Name()).Should(BeAnExistingFile())
-
-			tmpDir, err := ioutil.TempDir("", "gomega-test-tempdir")
-			Expect(err).ShouldNot(HaveOccurred())
-			defer os.Remove(tmpDir)
-			Expect(tmpDir).Should(BeAnExistingFile())
-		})
-	})
-
-	Context("when passed something else", func() {
-		It("should error", func() {
-			success, err := (&BeAnExistingFileMatcher{}).Match(nil)
-			Expect(success).Should(BeFalse())
-			Expect(err).Should(HaveOccurred())
-
-			success, err = (&BeAnExistingFileMatcher{}).Match(true)
-			Expect(success).Should(BeFalse())
-			Expect(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 c2e49ab50..000000000
--- 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)
-			Expect(openChannel).ShouldNot(BeClosed())
-
-			var openReaderChannel <-chan bool
-			openReaderChannel = openChannel
-			Expect(openReaderChannel).ShouldNot(BeClosed())
-
-			closedChannel := make(chan bool)
-			close(closedChannel)
-
-			Expect(closedChannel).Should(BeClosed())
-
-			var closedReaderChannel <-chan bool
-			closedReaderChannel = closedChannel
-			Expect(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)
-			Expect(success).Should(BeFalse())
-			Expect(err).Should(HaveOccurred())
-
-			closedChannel := make(chan bool)
-			close(closedChannel)
-
-			var closedWriterChannel chan<- bool
-			closedWriterChannel = closedChannel
-
-			success, err = (&BeClosedMatcher{}).Match(closedWriterChannel)
-			Expect(success).Should(BeFalse())
-			Expect(err).Should(HaveOccurred())
-
-		})
-	})
-
-	Context("when passed something else", func() {
-		It("should error", func() {
-			var nilChannel chan bool
-
-			success, err := (&BeClosedMatcher{}).Match(nilChannel)
-			Expect(success).Should(BeFalse())
-			Expect(err).Should(HaveOccurred())
-
-			success, err = (&BeClosedMatcher{}).Match(nil)
-			Expect(success).Should(BeFalse())
-			Expect(err).Should(HaveOccurred())
-
-			success, err = (&BeClosedMatcher{}).Match(7)
-			Expect(success).Should(BeFalse())
-			Expect(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 132480cfc..000000000
--- 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() {
-			Expect("").Should(BeEmpty())
-			Expect(" ").ShouldNot(BeEmpty())
-
-			Expect([0]int{}).Should(BeEmpty())
-			Expect([1]int{1}).ShouldNot(BeEmpty())
-
-			Expect([]int{}).Should(BeEmpty())
-			Expect([]int{1}).ShouldNot(BeEmpty())
-
-			Expect(map[string]int{}).Should(BeEmpty())
-			Expect(map[string]int{"a": 1}).ShouldNot(BeEmpty())
-
-			c := make(chan bool, 1)
-			Expect(c).Should(BeEmpty())
-			c <- true
-			Expect(c).ShouldNot(BeEmpty())
-		})
-	})
-
-	Context("when passed a correctly typed nil", func() {
-		It("should be true", func() {
-			var nilSlice []int
-			Expect(nilSlice).Should(BeEmpty())
-
-			var nilMap map[int]string
-			Expect(nilMap).Should(BeEmpty())
-		})
-	})
-
-	Context("when passed an unsupported type", func() {
-		It("should error", func() {
-			success, err := (&BeEmptyMatcher{}).Match(0)
-			Expect(success).Should(BeFalse())
-			Expect(err).Should(HaveOccurred())
-
-			success, err = (&BeEmptyMatcher{}).Match(nil)
-			Expect(success).Should(BeFalse())
-			Expect(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 4d9d11d2d..000000000
--- 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)
-
-			Expect(success).Should(BeFalse())
-			Expect(err).Should(HaveOccurred())
-		})
-	})
-
-	Context("When asserting on nil", func() {
-		It("should do the right thing", func() {
-			Expect("foo").ShouldNot(BeEquivalentTo(nil))
-			Expect(nil).ShouldNot(BeEquivalentTo(3))
-			Expect([]int{1, 2}).ShouldNot(BeEquivalentTo(nil))
-		})
-	})
-
-	Context("When asserting on type aliases", func() {
-		It("should the right thing", func() {
-			Expect(StringAlias("foo")).Should(BeEquivalentTo("foo"))
-			Expect("foo").Should(BeEquivalentTo(StringAlias("foo")))
-			Expect(StringAlias("foo")).ShouldNot(BeEquivalentTo("bar"))
-			Expect("foo").ShouldNot(BeEquivalentTo(StringAlias("bar")))
-		})
-	})
-
-	Context("When asserting on numbers", func() {
-		It("should convert actual to expected and do the right thing", func() {
-			Expect(5).Should(BeEquivalentTo(5))
-			Expect(5.0).Should(BeEquivalentTo(5.0))
-			Expect(5).Should(BeEquivalentTo(5.0))
-
-			Expect(5).ShouldNot(BeEquivalentTo("5"))
-			Expect(5).ShouldNot(BeEquivalentTo(3))
-
-			//Here be dragons!
-			Expect(5.1).Should(BeEquivalentTo(5))
-			Expect(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 25e70633d..000000000
--- 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() {
-		Expect(true).ShouldNot(BeFalse())
-		Expect(false).Should(BeFalse())
-	})
-
-	It("should only support booleans", func() {
-		success, err := (&BeFalseMatcher{}).Match("foo")
-		Expect(success).Should(BeFalse())
-		Expect(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 7fdd56eed..000000000
--- 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)
-
-			Expect(success).Should(BeFalse())
-			Expect(err).Should(HaveOccurred())
-		})
-	})
-
-	It("should treat the same pointer to a struct as identical", func() {
-		mySpecialStruct := myCustomType{}
-		Expect(&mySpecialStruct).Should(BeIdenticalTo(&mySpecialStruct))
-		Expect(&myCustomType{}).ShouldNot(BeIdenticalTo(&mySpecialStruct))
-	})
-
-	It("should be strict about types", func() {
-		Expect(5).ShouldNot(BeIdenticalTo("5"))
-		Expect(5).ShouldNot(BeIdenticalTo(5.0))
-		Expect(5).ShouldNot(BeIdenticalTo(3))
-	})
-
-	It("should treat primtives as identical", func() {
-		Expect("5").Should(BeIdenticalTo("5"))
-		Expect("5").ShouldNot(BeIdenticalTo("55"))
-
-		Expect(5.55).Should(BeIdenticalTo(5.55))
-		Expect(5.55).ShouldNot(BeIdenticalTo(6.66))
-
-		Expect(5).Should(BeIdenticalTo(5))
-		Expect(5).ShouldNot(BeIdenticalTo(55))
-	})
-
-	It("should treat the same pointers to a slice as identical", func() {
-		mySlice := []int{1, 2}
-		Expect(&mySlice).Should(BeIdenticalTo(&mySlice))
-		Expect(&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"}
-		Expect(&myMap).Should(BeIdenticalTo(&myMap))
-		Expect(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")
-		Expect(&myError).Should(BeIdenticalTo(&myError))
-		Expect(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 c35aa3d7c..000000000
--- 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() {
-		Expect(nil).Should(BeNil())
-	})
-
-	It("should succeed when passed a typed nil", func() {
-		var a []int
-		Expect(a).Should(BeNil())
-	})
-
-	It("should succeed when passing nil pointer", func() {
-		var f *struct{}
-		Expect(f).Should(BeNil())
-	})
-
-	It("should not succeed when not passed nil", func() {
-		Expect(0).ShouldNot(BeNil())
-		Expect(false).ShouldNot(BeNil())
-		Expect("").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 a32d2b8b1..000000000
--- a/vendor/github.com/onsi/gomega/matchers/be_numerically_matcher_test.go
+++ /dev/null
@@ -1,172 +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() {
-			Expect(uint32(5)).Should(BeNumerically("==", 5))
-			Expect(float64(5.0)).Should(BeNumerically("==", 5))
-			Expect(int8(5)).Should(BeNumerically("==", 5))
-		})
-
-		It("should not have false positives", func() {
-			Expect(5.1).ShouldNot(BeNumerically("==", 5))
-			Expect(5).ShouldNot(BeNumerically("==", 5.1))
-		})
-
-		It("should support >", func() {
-			Expect(uint32(5)).Should(BeNumerically(">", 4))
-			Expect(float64(5.0)).Should(BeNumerically(">", 4.9))
-			Expect(int8(5)).Should(BeNumerically(">", 4))
-
-			Expect(uint32(5)).ShouldNot(BeNumerically(">", 5))
-			Expect(float64(5.0)).ShouldNot(BeNumerically(">", 5.0))
-			Expect(int8(5)).ShouldNot(BeNumerically(">", 5))
-		})
-
-		It("should support <", func() {
-			Expect(uint32(5)).Should(BeNumerically("<", 6))
-			Expect(float64(5.0)).Should(BeNumerically("<", 5.1))
-			Expect(int8(5)).Should(BeNumerically("<", 6))
-
-			Expect(uint32(5)).ShouldNot(BeNumerically("<", 5))
-			Expect(float64(5.0)).ShouldNot(BeNumerically("<", 5.0))
-			Expect(int8(5)).ShouldNot(BeNumerically("<", 5))
-		})
-
-		It("should support >=", func() {
-			Expect(uint32(5)).Should(BeNumerically(">=", 4))
-			Expect(float64(5.0)).Should(BeNumerically(">=", 4.9))
-			Expect(int8(5)).Should(BeNumerically(">=", 4))
-
-			Expect(uint32(5)).Should(BeNumerically(">=", 5))
-			Expect(float64(5.0)).Should(BeNumerically(">=", 5.0))
-			Expect(int8(5)).Should(BeNumerically(">=", 5))
-
-			Expect(uint32(5)).ShouldNot(BeNumerically(">=", 6))
-			Expect(float64(5.0)).ShouldNot(BeNumerically(">=", 5.1))
-			Expect(int8(5)).ShouldNot(BeNumerically(">=", 6))
-		})
-
-		It("should support <=", func() {
-			Expect(uint32(5)).Should(BeNumerically("<=", 6))
-			Expect(float64(5.0)).Should(BeNumerically("<=", 5.1))
-			Expect(int8(5)).Should(BeNumerically("<=", 6))
-
-			Expect(uint32(5)).Should(BeNumerically("<=", 5))
-			Expect(float64(5.0)).Should(BeNumerically("<=", 5.0))
-			Expect(int8(5)).Should(BeNumerically("<=", 5))
-
-			Expect(uint32(5)).ShouldNot(BeNumerically("<=", 4))
-			Expect(float64(5.0)).ShouldNot(BeNumerically("<=", 4.9))
-			Expect(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() {
-						Expect(5.00000001).Should(BeNumerically("~", 5.00000002))
-						Expect(5.00000001).ShouldNot(BeNumerically("~", 5.0000001))
-					})
-
-					It("should show failure message", func() {
-						actual := BeNumerically("~", 4.98).FailureMessage(123)
-						expected := "Expected\n    <int>: 123\nto be ~\n    <float64>: 4.98"
-						Expect(actual).To(Equal(expected))
-					})
-
-					It("should show negated failure message", func() {
-						actual := BeNumerically("~", 4.98).NegatedFailureMessage(123)
-						expected := "Expected\n    <int>: 123\nnot to be ~\n    <float64>: 4.98"
-						Expect(actual).To(Equal(expected))
-					})
-				})
-
-				Context("and there is a precision parameter", func() {
-					It("should use the precision parameter", func() {
-						Expect(5.1).Should(BeNumerically("~", 5.19, 0.1))
-						Expect(5.1).Should(BeNumerically("~", 5.01, 0.1))
-						Expect(5.1).ShouldNot(BeNumerically("~", 5.22, 0.1))
-						Expect(5.1).ShouldNot(BeNumerically("~", 4.98, 0.1))
-					})
-
-					It("should show precision in failure message", func() {
-						actual := BeNumerically("~", 4.98, 0.1).FailureMessage(123)
-						expected := "Expected\n    <int>: 123\nto be within 0.1 of ~\n    <float64>: 4.98"
-						Expect(actual).To(Equal(expected))
-					})
-
-					It("should show precision in negated failure message", func() {
-						actual := BeNumerically("~", 4.98, 0.1).NegatedFailureMessage(123)
-						expected := "Expected\n    <int>: 123\nnot to be within 0.1 of ~\n    <float64>: 4.98"
-						Expect(actual).To(Equal(expected))
-					})
-				})
-			})
-
-			Context("when passed an int/uint", func() {
-				Context("and there is no precision parameter", func() {
-					It("should just do strict equality", func() {
-						Expect(5).Should(BeNumerically("~", 5))
-						Expect(5).ShouldNot(BeNumerically("~", 6))
-						Expect(uint(5)).ShouldNot(BeNumerically("~", 6))
-					})
-				})
-
-				Context("and there is a precision parameter", func() {
-					It("should use precision paramter", func() {
-						Expect(5).Should(BeNumerically("~", 6, 2))
-						Expect(5).ShouldNot(BeNumerically("~", 8, 2))
-						Expect(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")
-			Expect(success).Should(BeFalse())
-			Expect(err).Should(HaveOccurred())
-
-			success, err = (&BeNumericallyMatcher{Comparator: "=="}).Match(5)
-			Expect(success).Should(BeFalse())
-			Expect(err).Should(HaveOccurred())
-
-			success, err = (&BeNumericallyMatcher{Comparator: "~", CompareTo: []interface{}{3.0, "foo"}}).Match(5.0)
-			Expect(success).Should(BeFalse())
-			Expect(err).Should(HaveOccurred())
-
-			success, err = (&BeNumericallyMatcher{Comparator: "==", CompareTo: []interface{}{"bar"}}).Match(5)
-			Expect(success).Should(BeFalse())
-			Expect(err).Should(HaveOccurred())
-
-			success, err = (&BeNumericallyMatcher{Comparator: "==", CompareTo: []interface{}{"bar"}}).Match("foo")
-			Expect(success).Should(BeFalse())
-			Expect(err).Should(HaveOccurred())
-
-			success, err = (&BeNumericallyMatcher{Comparator: "==", CompareTo: []interface{}{nil}}).Match(0)
-			Expect(success).Should(BeFalse())
-			Expect(err).Should(HaveOccurred())
-
-			success, err = (&BeNumericallyMatcher{Comparator: "==", CompareTo: []interface{}{0}}).Match(nil)
-			Expect(success).Should(BeFalse())
-			Expect(err).Should(HaveOccurred())
-		})
-	})
-
-	Context("when passed an unsupported comparator", func() {
-		It("should error", func() {
-			success, err := (&BeNumericallyMatcher{Comparator: "!=", CompareTo: []interface{}{5}}).Match(4)
-			Expect(success).Should(BeFalse())
-			Expect(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 68ec72879..000000000
--- a/vendor/github.com/onsi/gomega/matchers/be_sent_matcher_test.go
+++ /dev/null
@@ -1,107 +0,0 @@
-package matchers_test
-
-import (
-	"time"
-
-	. "github.com/onsi/gomega/matchers"
-
-	. "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)
-
-				Expect(c).Should(BeSent("foo"))
-				Eventually(d).Should(Receive(Equal("foo")))
-			})
-
-			It("should succeed (with a buffered channel)", func() {
-				c := make(chan string, 1)
-				Expect(c).Should(BeSent("foo"))
-				Expect(<-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)
-				Expect(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)
-				Expect(success).Should(BeFalse())
-				Expect(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"))
-				})
-				Expect(failures).Should(HaveLen(1))
-				Expect(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))
-			Expect(success).Should(BeFalse())
-			Expect(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)
-			Expect(success).Should(BeFalse())
-			Expect(err).Should(HaveOccurred())
-		})
-	})
-
-	Context("when passed a nonchannel", func() {
-		It("should error", func() {
-			success, err := (&BeSentMatcher{Arg: "foo"}).Match("bar")
-			Expect(success).Should(BeFalse())
-			Expect(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 95a3a103e..000000000
--- a/vendor/github.com/onsi/gomega/matchers/be_temporally_matcher_test.go
+++ /dev/null
@@ -1,99 +0,0 @@
-package matchers_test
-
-import (
-	"time"
-
-	. "github.com/onsi/ginkgo"
-	. "github.com/onsi/gomega"
-	. "github.com/onsi/gomega/matchers"
-)
-
-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() {
-			Expect(t0).Should(BeTemporally("==", t0))
-			Expect(t1).ShouldNot(BeTemporally("==", t0))
-			Expect(t0).ShouldNot(BeTemporally("==", t1))
-			Expect(t0).ShouldNot(BeTemporally("==", time.Time{}))
-		})
-
-		It("should support >", func() {
-			Expect(t0).Should(BeTemporally(">", t2))
-			Expect(t0).ShouldNot(BeTemporally(">", t0))
-			Expect(t2).ShouldNot(BeTemporally(">", t0))
-		})
-
-		It("should support <", func() {
-			Expect(t0).Should(BeTemporally("<", t1))
-			Expect(t0).ShouldNot(BeTemporally("<", t0))
-			Expect(t1).ShouldNot(BeTemporally("<", t0))
-		})
-
-		It("should support >=", func() {
-			Expect(t0).Should(BeTemporally(">=", t2))
-			Expect(t0).Should(BeTemporally(">=", t0))
-			Expect(t0).ShouldNot(BeTemporally(">=", t1))
-		})
-
-		It("should support <=", func() {
-			Expect(t0).Should(BeTemporally("<=", t1))
-			Expect(t0).Should(BeTemporally("<=", t0))
-			Expect(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() {
-					Expect(t0).Should(BeTemporally("~", t0))
-					Expect(t0).Should(BeTemporally("~", t1))
-					Expect(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
-					Expect(t0).Should(BeTemporally("~", t0, d))
-					Expect(t0).Should(BeTemporally("~", t1, d))
-					Expect(t0).ShouldNot(BeTemporally("~", t2, d))
-				})
-			})
-		})
-	})
-
-	Context("when passed a non-time", func() {
-		It("should error", func() {
-			success, err := (&BeTemporallyMatcher{Comparator: "==", CompareTo: t0}).Match("foo")
-			Expect(success).Should(BeFalse())
-			Expect(err).Should(HaveOccurred())
-
-			success, err = (&BeTemporallyMatcher{Comparator: "=="}).Match(nil)
-			Expect(success).Should(BeFalse())
-			Expect(err).Should(HaveOccurred())
-		})
-	})
-
-	Context("when passed an unsupported comparator", func() {
-		It("should error", func() {
-			success, err := (&BeTemporallyMatcher{Comparator: "!=", CompareTo: t0}).Match(t2)
-			Expect(success).Should(BeFalse())
-			Expect(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 9eda62c33..000000000
--- 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() {
-		Expect(true).Should(BeTrue())
-		Expect(false).ShouldNot(BeTrue())
-	})
-
-	It("should only support booleans", func() {
-		success, err := (&BeTrueMatcher{}).Match("foo")
-		Expect(success).Should(BeFalse())
-		Expect(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 c89e10330..000000000
--- a/vendor/github.com/onsi/gomega/matchers/be_zero_matcher_test.go
+++ /dev/null
@@ -1,40 +0,0 @@
-package matchers_test
-
-import (
-	. "github.com/onsi/ginkgo"
-	. "github.com/onsi/gomega"
-)
-
-var _ = Describe("BeZero", func() {
-	It("succeeds for zero values for its type", func() {
-		Expect(nil).Should(BeZero())
-
-		Expect("").Should(BeZero())
-		Expect(" ").ShouldNot(BeZero())
-
-		Expect(0).Should(BeZero())
-		Expect(1).ShouldNot(BeZero())
-
-		Expect(0.0).Should(BeZero())
-		Expect(0.1).ShouldNot(BeZero())
-
-		// Expect([]int{}).Should(BeZero())
-		Expect([]int{1}).ShouldNot(BeZero())
-
-		// Expect(map[string]int{}).Should(BeZero())
-		Expect(map[string]int{"a": 1}).ShouldNot(BeZero())
-
-		Expect(myCustomType{}).Should(BeZero())
-		Expect(myCustomType{s: "a"}).ShouldNot(BeZero())
-	})
-
-	It("builds failure message", func() {
-		actual := BeZero().FailureMessage(123)
-		Expect(actual).To(Equal("Expected\n    <int>: 123\nto be zero-valued"))
-	})
-
-	It("builds negated failure message", func() {
-		actual := BeZero().NegatedFailureMessage(123)
-		Expect(actual).To(Equal("Expected\n    <int>: 123\nnot to be zero-valued"))
-	})
-})
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 f6971c4f5..000000000
--- 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() {
-			Expect([]string{"foo", "bar", "baz"}).Should(ConsistOf("foo", "bar", "baz"))
-			Expect([]string{"foo", "bar", "baz"}).Should(ConsistOf("foo", "bar", "baz"))
-			Expect([]string{"foo", "bar", "baz"}).Should(ConsistOf("baz", "bar", "foo"))
-			Expect([]string{"foo", "bar", "baz"}).ShouldNot(ConsistOf("baz", "bar", "foo", "foo"))
-			Expect([]string{"foo", "bar", "baz"}).ShouldNot(ConsistOf("baz", "foo"))
-		})
-	})
-
-	Context("with an array", func() {
-		It("should do the right thing", func() {
-			Expect([3]string{"foo", "bar", "baz"}).Should(ConsistOf("foo", "bar", "baz"))
-			Expect([3]string{"foo", "bar", "baz"}).Should(ConsistOf("baz", "bar", "foo"))
-			Expect([3]string{"foo", "bar", "baz"}).ShouldNot(ConsistOf("baz", "bar", "foo", "foo"))
-			Expect([3]string{"foo", "bar", "baz"}).ShouldNot(ConsistOf("baz", "foo"))
-		})
-	})
-
-	Context("with a map", func() {
-		It("should apply to the values", func() {
-			Expect(map[int]string{1: "foo", 2: "bar", 3: "baz"}).Should(ConsistOf("foo", "bar", "baz"))
-			Expect(map[int]string{1: "foo", 2: "bar", 3: "baz"}).Should(ConsistOf("baz", "bar", "foo"))
-			Expect(map[int]string{1: "foo", 2: "bar", 3: "baz"}).ShouldNot(ConsistOf("baz", "bar", "foo", "foo"))
-			Expect(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() {
-				Expect("foo").Should(ConsistOf("f", "o", "o"))
-			})
-
-			Expect(failures).Should(HaveLen(1))
-		})
-	})
-
-	Context("when passed matchers", func() {
-		It("should pass if the matchers pass", func() {
-			Expect([]string{"foo", "bar", "baz"}).Should(ConsistOf("foo", MatchRegexp("^ba"), "baz"))
-			Expect([]string{"foo", "bar", "baz"}).ShouldNot(ConsistOf("foo", MatchRegexp("^ba")))
-			Expect([]string{"foo", "bar", "baz"}).ShouldNot(ConsistOf("foo", MatchRegexp("^ba"), MatchRegexp("foo")))
-			Expect([]string{"foo", "bar", "baz"}).Should(ConsistOf("foo", MatchRegexp("^ba"), MatchRegexp("^ba")))
-			Expect([]string{"foo", "bar", "baz"}).ShouldNot(ConsistOf("foo", MatchRegexp("^ba"), MatchRegexp("turducken")))
-		})
-
-		It("should not depend on the order of the matchers", func() {
-			Expect([][]int{{1, 2}, {2}}).Should(ConsistOf(ContainElement(1), ContainElement(2)))
-			Expect([][]int{{1, 2}, {2}}).Should(ConsistOf(ContainElement(2), ContainElement(1)))
-		})
-
-		Context("when a matcher errors", func() {
-			It("should soldier on", func() {
-				Expect([]string{"foo", "bar", "baz"}).ShouldNot(ConsistOf(BeFalse(), "foo", "bar"))
-				Expect([]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() {
-			Expect([]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 60fb55e96..000000000
--- 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() {
-				Expect([2]int{1, 2}).Should(ContainElement(2))
-				Expect([2]int{1, 2}).ShouldNot(ContainElement(3))
-
-				Expect([]int{1, 2}).Should(ContainElement(2))
-				Expect([]int{1, 2}).ShouldNot(ContainElement(3))
-
-				Expect(map[string]int{"foo": 1, "bar": 2}).Should(ContainElement(2))
-				Expect(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"}}
-				Expect(arr).Should(ContainElement(myCustomType{s: "foo", n: 3, f: 2.0, arr: []string{"a", "b"}}))
-				Expect(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() {
-				Expect([]int{1, 2, 3}).Should(ContainElement(BeNumerically(">=", 3)))
-				Expect([]int{1, 2, 3}).ShouldNot(ContainElement(BeNumerically(">", 3)))
-				Expect(map[string]int{"foo": 1, "bar": 2}).Should(ContainElement(BeNumerically(">=", 2)))
-				Expect(map[string]int{"foo": 1, "bar": 2}).ShouldNot(ContainElement(BeNumerically(">", 2)))
-			})
-
-			It("should power through even if the matcher ever fails", func() {
-				Expect([]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)
-				Expect(success).Should(BeFalse())
-				Expect(err).Should(HaveOccurred())
-			})
-		})
-	})
-
-	Context("when passed a correctly typed nil", func() {
-		It("should operate succesfully on the passed in value", func() {
-			var nilSlice []int
-			Expect(nilSlice).ShouldNot(ContainElement(1))
-
-			var nilMap map[int]string
-			Expect(nilMap).ShouldNot(ContainElement("foo"))
-		})
-	})
-
-	Context("when passed an unsupported type", func() {
-		It("should error", func() {
-			success, err := (&ContainElementMatcher{Element: 0}).Match(0)
-			Expect(success).Should(BeFalse())
-			Expect(err).Should(HaveOccurred())
-
-			success, err = (&ContainElementMatcher{Element: 0}).Match("abc")
-			Expect(success).Should(BeFalse())
-			Expect(err).Should(HaveOccurred())
-
-			success, err = (&ContainElementMatcher{Element: 0}).Match(nil)
-			Expect(success).Should(BeFalse())
-			Expect(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 efffb4732..000000000
--- 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() {
-			Expect("Marvelous").Should(ContainSubstring("rve"))
-			Expect("Marvelous").ShouldNot(ContainSubstring("boo"))
-		})
-	})
-
-	Context("when the matcher is called with multiple arguments", func() {
-		It("should pass the string and arguments to sprintf", func() {
-			Expect("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() {
-			Expect(&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)
-			Expect(success).Should(BeFalse())
-			Expect(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 3ab991e4f..000000000
--- a/vendor/github.com/onsi/gomega/matchers/equal_matcher_test.go
+++ /dev/null
@@ -1,80 +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)
-
-			Expect(success).Should(BeFalse())
-			Expect(err).Should(HaveOccurred())
-		})
-	})
-
-	Context("When asserting equality between objects", func() {
-		It("should do the right thing", func() {
-			Expect(5).Should(Equal(5))
-			Expect(5.0).Should(Equal(5.0))
-
-			Expect(5).ShouldNot(Equal("5"))
-			Expect(5).ShouldNot(Equal(5.0))
-			Expect(5).ShouldNot(Equal(3))
-
-			Expect("5").Should(Equal("5"))
-			Expect([]int{1, 2}).Should(Equal([]int{1, 2}))
-			Expect([]int{1, 2}).ShouldNot(Equal([]int{2, 1}))
-			Expect([]byte{'f', 'o', 'o'}).Should(Equal([]byte{'f', 'o', 'o'}))
-			Expect([]byte{'f', 'o', 'o'}).ShouldNot(Equal([]byte{'b', 'a', 'r'}))
-			Expect(map[string]string{"a": "b", "c": "d"}).Should(Equal(map[string]string{"a": "b", "c": "d"}))
-			Expect(map[string]string{"a": "b", "c": "d"}).ShouldNot(Equal(map[string]string{"a": "b", "c": "e"}))
-			Expect(errors.New("foo")).Should(Equal(errors.New("foo")))
-			Expect(errors.New("foo")).ShouldNot(Equal(errors.New("bar")))
-
-			Expect(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"}}))
-			Expect(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"}}))
-			Expect(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"}}))
-			Expect(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"}}))
-			Expect(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")
-			Expect(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)
-			Expect(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 8a61f2e2c..000000000
--- 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() {
-			Expect([0]int{}).Should(HaveCap(0))
-			Expect([2]int{1}).Should(HaveCap(2))
-
-			Expect([]int{}).Should(HaveCap(0))
-			Expect([]int{1, 2, 3, 4, 5}[:2]).Should(HaveCap(5))
-			Expect(make([]int, 0, 5)).Should(HaveCap(5))
-
-			c := make(chan bool, 3)
-			Expect(c).Should(HaveCap(3))
-			c <- true
-			c <- true
-			Expect(c).Should(HaveCap(3))
-
-			Expect(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
-			Expect(nilSlice).Should(HaveCap(0))
-
-			var nilChan chan int
-			Expect(nilChan).Should(HaveCap(0))
-		})
-	})
-
-	Context("when passed an unsupported type", func() {
-		It("should error", func() {
-			success, err := (&HaveCapMatcher{Count: 0}).Match(0)
-			Expect(success).Should(BeFalse())
-			Expect(err).Should(HaveOccurred())
-
-			success, err = (&HaveCapMatcher{Count: 0}).Match(nil)
-			Expect(success).Should(BeFalse())
-			Expect(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 0f1561b7d..000000000
--- 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() {
-			Expect(stringKeys).Should(HaveKey("foo"))
-			Expect(stringKeys).ShouldNot(HaveKey("baz"))
-
-			Expect(intKeys).Should(HaveKey(2))
-			Expect(intKeys).ShouldNot(HaveKey(4))
-
-			Expect(objKeys).Should(HaveKey(customA))
-			Expect(objKeys).Should(HaveKey(&myCustomType{s: "b", n: 4, f: 3.1, arr: []string{"cake"}}))
-			Expect(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
-			Expect(nilMap).ShouldNot(HaveKey("foo"))
-		})
-	})
-
-	Context("when the passed in key is actually a matcher", func() {
-		It("should pass each element through the matcher", func() {
-			Expect(stringKeys).Should(HaveKey(ContainSubstring("oo")))
-			Expect(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)
-			Expect(success).Should(BeFalse())
-			Expect(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"})
-			Expect(success).Should(BeFalse())
-			Expect(err).Should(HaveOccurred())
-
-			success, err = (&HaveKeyMatcher{Key: "foo"}).Match(nil)
-			Expect(success).Should(BeFalse())
-			Expect(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 0a49ec993..000000000
--- 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() {
-			Expect(stringKeys).Should(HaveKeyWithValue("foo", 2))
-			Expect(stringKeys).ShouldNot(HaveKeyWithValue("foo", 1))
-			Expect(stringKeys).ShouldNot(HaveKeyWithValue("baz", 2))
-			Expect(stringKeys).ShouldNot(HaveKeyWithValue("baz", 1))
-
-			Expect(intKeys).Should(HaveKeyWithValue(2, "foo"))
-			Expect(intKeys).ShouldNot(HaveKeyWithValue(4, "foo"))
-			Expect(intKeys).ShouldNot(HaveKeyWithValue(2, "baz"))
-
-			Expect(objKeys).Should(HaveKeyWithValue(customA, customA))
-			Expect(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"}}))
-			Expect(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
-			Expect(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() {
-			Expect(stringKeys).Should(HaveKeyWithValue(ContainSubstring("oo"), 2))
-			Expect(intKeys).Should(HaveKeyWithValue(2, ContainSubstring("oo")))
-			Expect(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)
-			Expect(success).Should(BeFalse())
-			Expect(err).Should(HaveOccurred())
-
-			otherActual := map[string]int{"a": 1, "b": 2, "c": 3}
-			success, err = (&HaveKeyWithValueMatcher{Key: "a", Value: ContainSubstring("1")}).Match(otherActual)
-			Expect(success).Should(BeFalse())
-			Expect(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"})
-			Expect(success).Should(BeFalse())
-			Expect(err).Should(HaveOccurred())
-
-			success, err = (&HaveKeyWithValueMatcher{Key: "foo", Value: "bar"}).Match(nil)
-			Expect(success).Should(BeFalse())
-			Expect(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 c60f63886..000000000
--- 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() {
-			Expect("").Should(HaveLen(0))
-			Expect("AA").Should(HaveLen(2))
-
-			Expect([0]int{}).Should(HaveLen(0))
-			Expect([2]int{1, 2}).Should(HaveLen(2))
-
-			Expect([]int{}).Should(HaveLen(0))
-			Expect([]int{1, 2, 3}).Should(HaveLen(3))
-
-			Expect(map[string]int{}).Should(HaveLen(0))
-			Expect(map[string]int{"a": 1, "b": 2, "c": 3, "d": 4}).Should(HaveLen(4))
-
-			c := make(chan bool, 3)
-			Expect(c).Should(HaveLen(0))
-			c <- true
-			c <- true
-			Expect(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
-			Expect(nilSlice).Should(HaveLen(0))
-
-			var nilMap map[int]string
-			Expect(nilMap).Should(HaveLen(0))
-		})
-	})
-
-	Context("when passed an unsupported type", func() {
-		It("should error", func() {
-			success, err := (&HaveLenMatcher{Count: 0}).Match(0)
-			Expect(success).Should(BeFalse())
-			Expect(err).Should(HaveOccurred())
-
-			success, err = (&HaveLenMatcher{Count: 0}).Match(nil)
-			Expect(success).Should(BeFalse())
-			Expect(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 0ad632ec1..000000000
--- a/vendor/github.com/onsi/gomega/matchers/have_occurred_matcher_test.go
+++ /dev/null
@@ -1,59 +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() {
-		Expect(errors.New("Foo")).Should(HaveOccurred())
-	})
-
-	It("should not succeed with nil", func() {
-		Expect(nil).ShouldNot(HaveOccurred())
-	})
-
-	It("should only support errors and nil", func() {
-		success, err := (&HaveOccurredMatcher{}).Match("foo")
-		Expect(success).Should(BeFalse())
-		Expect(err).Should(HaveOccurred())
-
-		success, err = (&HaveOccurredMatcher{}).Match("")
-		Expect(success).Should(BeFalse())
-		Expect(err).Should(HaveOccurred())
-	})
-
-	It("doesn't support non-error type", func() {
-		success, err := (&HaveOccurredMatcher{}).Match(AnyType{})
-		Expect(success).Should(BeFalse())
-		Expect(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{})
-		Expect(success).Should(BeFalse())
-		Expect(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"}
-		Expect(err).Should(HaveOccurred())
-	})
-
-	It("should not succeed with nil pointers to types that conform to error interface", func() {
-		var err *CustomErr = nil
-		Expect(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 fe29b7b5d..000000000
--- 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() {
-			Expect("Ab").Should(HavePrefix("A"))
-			Expect("A").ShouldNot(HavePrefix("Ab"))
-		})
-	})
-
-	Context("when the matcher is called with multiple arguments", func() {
-		It("should pass the string and arguments to sprintf", func() {
-			Expect("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() {
-			Expect(&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)
-			Expect(success).Should(BeFalse())
-			Expect(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 2ae29821a..000000000
--- 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() {
-			Expect("Ab").Should(HaveSuffix("b"))
-			Expect("A").ShouldNot(HaveSuffix("Ab"))
-		})
-	})
-
-	Context("when the matcher is called with multiple arguments", func() {
-		It("should pass the string and arguments to sprintf", func() {
-			Expect("C3PO").Should(HaveSuffix("%dPO", 3))
-		})
-	})
-
-	Context("when actual is a stringer", func() {
-		It("should call the stringer and match against the returned string", func() {
-			Expect(&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)
-			Expect(success).Should(BeFalse())
-			Expect(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 9bf89fc46..000000000
--- a/vendor/github.com/onsi/gomega/matchers/match_error_matcher_test.go
+++ /dev/null
@@ -1,107 +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{}
-
-			Expect(err).Should(MatchError(errors.New("an error")))
-			Expect(err).ShouldNot(MatchError(errors.New("another error")))
-
-			Expect(fmtErr).Should(MatchError(errors.New("an error")))
-			Expect(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{}
-
-			Expect(err).Should(MatchError("an error"))
-			Expect(err).ShouldNot(MatchError("another error"))
-
-			Expect(fmtErr).Should(MatchError("an error"))
-			Expect(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")
-
-				Expect(err).Should(MatchError(MatchRegexp(`\d{3}`)))
-			})
-
-			It("should fail if the matcher fails against the error string", func() {
-				err := errors.New("no digits")
-				Expect(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)
-			Expect(err).Should(HaveOccurred())
-
-			_, err = (&MatchErrorMatcher{
-				Expected: 3,
-			}).Match(actualErr)
-			Expect(err).Should(HaveOccurred())
-		})
-	})
-
-	Context("when passed nil", func() {
-		It("should fail", func() {
-			_, err := (&MatchErrorMatcher{
-				Expected: "an error",
-			}).Match(nil)
-			Expect(err).Should(HaveOccurred())
-		})
-	})
-
-	Context("when passed a non-error", func() {
-		It("should fail", func() {
-			_, err := (&MatchErrorMatcher{
-				Expected: "an error",
-			}).Match("an error")
-			Expect(err).Should(HaveOccurred())
-
-			_, err = (&MatchErrorMatcher{
-				Expected: "an error",
-			}).Match(3)
-			Expect(err).Should(HaveOccurred())
-		})
-	})
-
-	Context("when passed an error that is also a string", func() {
-		It("should use it as an error", func() {
-			var e mockErr = "mockErr"
-
-			// this fails if the matcher casts e to a string before comparison
-			Expect(e).Should(MatchError(e))
-		})
-	})
-})
-
-type mockErr string
-
-func (m mockErr) Error() string { return string(m) }
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 4a1a9db20..000000000
--- a/vendor/github.com/onsi/gomega/matchers/match_json_matcher_test.go
+++ /dev/null
@@ -1,103 +0,0 @@
-package matchers_test
-
-import (
-	"encoding/json"
-
-	. "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() {
-			Expect("{}").Should(MatchJSON("{}"))
-			Expect(`{"a":1}`).Should(MatchJSON(`{"a":1}`))
-			Expect(`{
-			             "a":1
-			         }`).Should(MatchJSON(`{"a":1}`))
-			Expect(`{"a":1, "b":2}`).Should(MatchJSON(`{"b":2, "a":1}`))
-			Expect(`{"a":1}`).ShouldNot(MatchJSON(`{"b":2, "a":1}`))
-
-			Expect(`{"a":"a", "b":"b"}`).ShouldNot(MatchJSON(`{"a":"a", "b":"b", "c":"c"}`))
-			Expect(`{"a":"a", "b":"b", "c":"c"}`).ShouldNot(MatchJSON(`{"a":"a", "b":"b"}`))
-
-			Expect(`{"a":null, "b":null}`).ShouldNot(MatchJSON(`{"c":"c", "d":"d"}`))
-			Expect(`{"a":null, "b":null, "c":null}`).ShouldNot(MatchJSON(`{"a":null, "b":null, "d":null}`))
-		})
-
-		It("should work with byte arrays", func() {
-			Expect([]byte("{}")).Should(MatchJSON([]byte("{}")))
-			Expect("{}").Should(MatchJSON([]byte("{}")))
-			Expect([]byte("{}")).Should(MatchJSON("{}"))
-		})
-
-		It("should work with json.RawMessage", func() {
-			Expect([]byte(`{"a": 1}`)).Should(MatchJSON(json.RawMessage(`{"a": 1}`)))
-		})
-	})
-
-	Context("when a key mismatch is found", func() {
-		It("reports the first found mismatch", func() {
-			subject := MatchJSONMatcher{JSONToMatch: `5`}
-			actual := `7`
-			subject.Match(actual)
-
-			failureMessage := subject.FailureMessage(`7`)
-			Expect(failureMessage).ToNot(ContainSubstring("first mismatched key"))
-
-			subject = MatchJSONMatcher{JSONToMatch: `{"a": 1, "b.g": {"c": 2, "1": ["hello", "see ya"]}}`}
-			actual = `{"a": 1, "b.g": {"c": 2, "1": ["hello", "goodbye"]}}`
-			subject.Match(actual)
-
-			failureMessage = subject.FailureMessage(actual)
-			Expect(failureMessage).To(ContainSubstring(`first mismatched key: "b.g"."1"[1]`))
-		})
-	})
-
-	Context("when the expected is not valid JSON", func() {
-		It("should error and explain why", func() {
-			success, err := (&MatchJSONMatcher{JSONToMatch: `{}`}).Match(`oops`)
-			Expect(success).Should(BeFalse())
-			Expect(err).Should(HaveOccurred())
-			Expect(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(`{}`)
-			Expect(success).Should(BeFalse())
-			Expect(err).Should(HaveOccurred())
-			Expect(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("{}")
-			Expect(success).Should(BeFalse())
-			Expect(err).Should(HaveOccurred())
-			Expect(err.Error()).Should(ContainSubstring("MatchJSONMatcher matcher requires a string, stringer, or []byte.  Got expected:\n    <int>: 2"))
-
-			success, err = (&MatchJSONMatcher{JSONToMatch: nil}).Match("{}")
-			Expect(success).Should(BeFalse())
-			Expect(err).Should(HaveOccurred())
-			Expect(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)
-			Expect(success).Should(BeFalse())
-			Expect(err).Should(HaveOccurred())
-			Expect(err.Error()).Should(ContainSubstring("MatchJSONMatcher matcher requires a string, stringer, or []byte.  Got actual:\n    <int>: 2"))
-
-			success, err = (&MatchJSONMatcher{JSONToMatch: "{}"}).Match(nil)
-			Expect(success).Should(BeFalse())
-			Expect(err).Should(HaveOccurred())
-			Expect(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 ac2538bb4..000000000
--- 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() {
-			Expect(" a2!bla").Should(MatchRegexp(`\d!`))
-			Expect(" 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() {
-			Expect(&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() {
-			Expect(" 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)
-			Expect(success).Should(BeFalse())
-			Expect(err).Should(HaveOccurred())
-		})
-	})
-
-	Context("when the passed in regexp fails to compile", func() {
-		It("should error", func() {
-			success, err := (&MatchRegexpMatcher{Regexp: "("}).Match("Foo")
-			Expect(success).Should(BeFalse())
-			Expect(err).Should(HaveOccurred())
-		})
-	})
-})
diff --git a/vendor/github.com/onsi/gomega/matchers/match_xml_matcher_test.go b/vendor/github.com/onsi/gomega/matchers/match_xml_matcher_test.go
deleted file mode 100644
index 0b559b22e..000000000
--- a/vendor/github.com/onsi/gomega/matchers/match_xml_matcher_test.go
+++ /dev/null
@@ -1,97 +0,0 @@
-package matchers_test
-
-import (
-	. "github.com/onsi/ginkgo"
-	. "github.com/onsi/gomega"
-	. "github.com/onsi/gomega/matchers"
-)
-
-var _ = Describe("MatchXMLMatcher", func() {
-
-	var (
-		sample_01 = readFileContents("test_data/xml/sample_01.xml")
-		sample_02 = readFileContents("test_data/xml/sample_02.xml")
-		sample_03 = readFileContents("test_data/xml/sample_03.xml")
-		sample_04 = readFileContents("test_data/xml/sample_04.xml")
-		sample_05 = readFileContents("test_data/xml/sample_05.xml")
-		sample_06 = readFileContents("test_data/xml/sample_06.xml")
-		sample_07 = readFileContents("test_data/xml/sample_07.xml")
-		sample_08 = readFileContents("test_data/xml/sample_08.xml")
-		sample_09 = readFileContents("test_data/xml/sample_09.xml")
-		sample_10 = readFileContents("test_data/xml/sample_10.xml")
-		sample_11 = readFileContents("test_data/xml/sample_11.xml")
-	)
-
-	Context("When passed stringifiables", func() {
-		It("matches documents regardless of the attribute order", func() {
-			a := `<a foo="bar" ka="boom"></a>`
-			b := `<a ka="boom" foo="bar"></a>`
-			Expect(b).Should(MatchXML(a))
-			Expect(a).Should(MatchXML(b))
-		})
-
-		It("should succeed if the XML matches", func() {
-			Expect(sample_01).Should(MatchXML(sample_01))    // same XML
-			Expect(sample_01).Should(MatchXML(sample_02))    // same XML with blank lines
-			Expect(sample_01).Should(MatchXML(sample_03))    // same XML with different formatting
-			Expect(sample_01).ShouldNot(MatchXML(sample_04)) // same structures with different values
-			Expect(sample_01).ShouldNot(MatchXML(sample_05)) // different structures
-			Expect(sample_06).ShouldNot(MatchXML(sample_07)) // same xml names with different namespaces
-			Expect(sample_07).ShouldNot(MatchXML(sample_08)) // same structures with different values
-			Expect(sample_09).ShouldNot(MatchXML(sample_10)) // same structures with different attribute values
-			Expect(sample_11).Should(MatchXML(sample_11))    // with non UTF-8 encoding
-		})
-
-		It("should work with byte arrays", func() {
-			Expect([]byte(sample_01)).Should(MatchXML([]byte(sample_01)))
-			Expect([]byte(sample_01)).Should(MatchXML(sample_01))
-			Expect(sample_01).Should(MatchXML([]byte(sample_01)))
-		})
-	})
-
-	Context("when the expected is not valid XML", func() {
-		It("should error and explain why", func() {
-			success, err := (&MatchXMLMatcher{XMLToMatch: sample_01}).Match(`oops`)
-			Expect(success).Should(BeFalse())
-			Expect(err).Should(HaveOccurred())
-			Expect(err.Error()).Should(ContainSubstring("Actual 'oops' should be valid XML"))
-		})
-	})
-
-	Context("when the actual is not valid XML", func() {
-		It("should error and explain why", func() {
-			success, err := (&MatchXMLMatcher{XMLToMatch: `oops`}).Match(sample_01)
-			Expect(success).Should(BeFalse())
-			Expect(err).Should(HaveOccurred())
-			Expect(err.Error()).Should(ContainSubstring("Expected 'oops' should be valid XML"))
-		})
-	})
-
-	Context("when the expected is neither a string nor a stringer nor a byte array", func() {
-		It("should error", func() {
-			success, err := (&MatchXMLMatcher{XMLToMatch: 2}).Match(sample_01)
-			Expect(success).Should(BeFalse())
-			Expect(err).Should(HaveOccurred())
-			Expect(err.Error()).Should(ContainSubstring("MatchXMLMatcher matcher requires a string, stringer, or []byte.  Got expected:\n    <int>: 2"))
-
-			success, err = (&MatchXMLMatcher{XMLToMatch: nil}).Match(sample_01)
-			Expect(success).Should(BeFalse())
-			Expect(err).Should(HaveOccurred())
-			Expect(err.Error()).Should(ContainSubstring("MatchXMLMatcher 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 := (&MatchXMLMatcher{XMLToMatch: sample_01}).Match(2)
-			Expect(success).Should(BeFalse())
-			Expect(err).Should(HaveOccurred())
-			Expect(err.Error()).Should(ContainSubstring("MatchXMLMatcher matcher requires a string, stringer, or []byte.  Got actual:\n    <int>: 2"))
-
-			success, err = (&MatchXMLMatcher{XMLToMatch: sample_01}).Match(nil)
-			Expect(success).Should(BeFalse())
-			Expect(err).Should(HaveOccurred())
-			Expect(err.Error()).Should(ContainSubstring("MatchXMLMatcher matcher requires a string, stringer, or []byte.  Got actual:\n    <nil>: nil"))
-		})
-	})
-})
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 1b0044fd0..000000000
--- a/vendor/github.com/onsi/gomega/matchers/match_yaml_matcher_test.go
+++ /dev/null
@@ -1,101 +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"))
-		})
-
-		It("errors when passed directly to Message", func() {
-			Expect(func() {
-				matcher := MatchYAMLMatcher{YAMLToMatch: "good"}
-				matcher.FailureMessage("good:\nbad")
-			}).To(Panic())
-		})
-	})
-
-	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 b5f76c995..000000000
--- a/vendor/github.com/onsi/gomega/matchers/matcher_tests_suite_test.go
+++ /dev/null
@@ -1,50 +0,0 @@
-package matchers_test
-
-import (
-	"fmt"
-	"io/ioutil"
-	"os"
-	"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")
-}
-
-func readFileContents(filePath string) []byte {
-	f := openFile(filePath)
-	b, err := ioutil.ReadAll(f)
-	if err != nil {
-		panic(fmt.Errorf("failed to read file contents: %v", err))
-	}
-	return b
-}
-
-func openFile(filePath string) *os.File {
-	f, err := os.Open(filePath)
-	if err != nil {
-		panic(fmt.Errorf("failed to open file: %v", err))
-	}
-	return f
-}
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 06d3ebd17..000000000
--- a/vendor/github.com/onsi/gomega/matchers/not_test.go
+++ /dev/null
@@ -1,64 +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))))
-		})
-
-		It("fails on error", func() {
-			failuresMessages := InterceptGomegaFailures(func() {
-				Expect(input).To(Not(Panic()))
-			})
-			Expect(failuresMessages).To(Equal([]string{"PanicMatcher expects a function.  Got:\n    <string>: hi"}))
-		})
-	})
-
-	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 1f6dfaf61..000000000
--- a/vendor/github.com/onsi/gomega/matchers/or_test.go
+++ /dev/null
@@ -1,92 +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("stops on errors", func() {
-		failuresMessages := InterceptGomegaFailures(func() {
-			Expect(input).To(Or(Panic(), true1))
-		})
-		Expect(failuresMessages).To(Equal([]string{"PanicMatcher expects a function.  Got:\n    <string>: hi"}))
-	})
-
-	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 326bb10a4..000000000
--- a/vendor/github.com/onsi/gomega/matchers/panic_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("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")
-			Expect(success).To(BeFalse())
-			Expect(err).To(HaveOccurred())
-
-			success, err = (&PanicMatcher{}).Match(nil)
-			Expect(success).To(BeFalse())
-			Expect(err).To(HaveOccurred())
-
-			success, err = (&PanicMatcher{}).Match(func(foo string) {})
-			Expect(success).To(BeFalse())
-			Expect(err).To(HaveOccurred())
-
-			success, err = (&PanicMatcher{}).Match(func() string { return "bar" })
-			Expect(success).To(BeFalse())
-			Expect(err).To(HaveOccurred())
-		})
-	})
-
-	Context("when passed a function of the correct type", func() {
-		It("should call the function and pass if the function panics", func() {
-			Expect(func() { panic("ack!") }).To(Panic())
-			Expect(func() {}).NotTo(Panic())
-		})
-	})
-
-	Context("when assertion fails", func() {
-		It("prints the object passed to Panic when negative", func() {
-			failuresMessages := InterceptGomegaFailures(func() {
-				Expect(func() { panic("ack!") }).NotTo(Panic())
-			})
-			Expect(failuresMessages).To(ConsistOf(ContainSubstring("not to panic, but panicked with\n    <string>: ack!")))
-		})
-
-		It("prints simple message when positive", func() {
-			failuresMessages := InterceptGomegaFailures(func() {
-				Expect(func() {}).To(Panic())
-			})
-			Expect(failuresMessages).To(ConsistOf(MatchRegexp("Expected\n\\s+<func\\(\\)>: .+\nto panic")))
-		})
-	})
-})
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 cf04e85dd..000000000
--- a/vendor/github.com/onsi/gomega/matchers/receive_matcher_test.go
+++ /dev/null
@@ -1,304 +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
-}
-
-type someError struct{ s string }
-
-func (e *someError) Error() string { return e.s }
-
-var _ = Describe("ReceiveMatcher", func() {
-	Context("with no argument", func() {
-		Context("for a buffered channel", func() {
-			It("should succeed", func() {
-				channel := make(chan bool, 1)
-
-				Expect(channel).ShouldNot(Receive())
-
-				channel <- true
-
-				Expect(channel).Should(Receive())
-			})
-		})
-
-		Context("for an unbuffered channel", func() {
-			It("should succeed (eventually)", func() {
-				channel := make(chan bool)
-
-				Expect(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() {
-			Context("when the channel has an interface type", func() {
-				It("should write the value received on the channel to the pointer", func() {
-					channel := make(chan error, 1)
-
-					var value *someError
-
-					Ω(channel).ShouldNot(Receive(&value))
-					Ω(value).Should(BeZero())
-
-					channel <- &someError{"boooom!"}
-
-					Ω(channel).Should(Receive(&value))
-					Ω(value).Should(MatchError("boooom!"))
-				})
-			})
-		})
-
-		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
-
-				Expect(channel).ShouldNot(Receive(&value))
-				Expect(value).Should(BeZero())
-
-				channel <- 17
-
-				Expect(channel).Should(Receive(&value))
-				Expect(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
-				Expect(stringChan).Should(Receive(&s))
-				Expect(s).Should(Equal("foo"))
-
-				//channels of slices
-				sliceChan := make(chan []bool, 1)
-				sliceChan <- []bool{true, true, false}
-
-				var sl []bool
-				Expect(sliceChan).Should(Receive(&sl))
-				Expect(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
-				Expect(chanChan).Should(Receive(&receivedC))
-				Expect(receivedC).Should(Equal(c))
-
-				//channels of interfaces
-				jackieChan := make(chan kungFuActor, 1)
-				aJackie := &jackie{name: "Jackie Chan"}
-				jackieChan <- aJackie
-
-				var theJackie kungFuActor
-				Expect(jackieChan).Should(Receive(&theJackie))
-				Expect(theJackie).Should(Equal(aJackie))
-			})
-		})
-
-		Context("of the wrong type", func() {
-			It("should error", func() {
-				channel := make(chan int, 1)
-				channel <- 10
-
-				var incorrectType bool
-
-				success, err := (&ReceiveMatcher{Arg: &incorrectType}).Match(channel)
-				Expect(success).Should(BeFalse())
-				Expect(err).Should(HaveOccurred())
-
-				var notAPointer int
-				success, err = (&ReceiveMatcher{Arg: notAPointer}).Match(channel)
-				Expect(success).Should(BeFalse())
-				Expect(err).Should(HaveOccurred())
-			})
-		})
-	})
-
-	Context("with a matcher", func() {
-		It("should defer to the underlying matcher", func() {
-			intChannel := make(chan int, 1)
-			intChannel <- 3
-			Expect(intChannel).Should(Receive(Equal(3)))
-
-			intChannel <- 2
-			Expect(intChannel).ShouldNot(Receive(Equal(3)))
-
-			stringChannel := make(chan []string, 1)
-			stringChannel <- []string{"foo", "bar", "baz"}
-			Expect(stringChannel).Should(Receive(ContainElement(ContainSubstring("fo"))))
-
-			stringChannel <- []string{"foo", "bar", "baz"}
-			Expect(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)
-			Expect(matcher.FailureMessage(channel)).Should(MatchRegexp(`Expected\s+<int>: 2\s+to equal\s+<int>: 3`))
-
-			channel <- 3
-			matcher.Match(channel)
-			Expect(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)
-				Expect(success).Should(BeFalse())
-				Expect(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)
-				Expect(success).Should(BeFalse())
-				Expect(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)
-
-				Expect(channel).Should(Receive())
-				Expect(channel).ShouldNot(Receive())
-			})
-		})
-
-		Context("for an unbuffered channel", func() {
-			It("should always fail", func() {
-				channel := make(chan bool)
-				close(channel)
-
-				Expect(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)
-			Expect(success).Should(BeFalse())
-			Expect(err).Should(HaveOccurred())
-		})
-	})
-
-	Context("when acutal is a non-channel", func() {
-		It("should error", func() {
-			var nilChannel chan bool
-
-			success, err := (&ReceiveMatcher{}).Match(nilChannel)
-			Expect(success).Should(BeFalse())
-			Expect(err).Should(HaveOccurred())
-
-			success, err = (&ReceiveMatcher{}).Match(nil)
-			Expect(success).Should(BeFalse())
-			Expect(err).Should(HaveOccurred())
-
-			success, err = (&ReceiveMatcher{}).Match(3)
-			Expect(success).Should(BeFalse())
-			Expect(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")))
-			})
-			Expect(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")))
-			})
-			Expect(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())
-			})
-			Expect(time.Since(t)).Should(BeNumerically("<", 500*time.Millisecond))
-			Expect(failures).Should(HaveLen(1))
-		})
-
-		It("should bail early when passed a non-channel", func() {
-			t := time.Now()
-			failures := InterceptGomegaFailures(func() {
-				Eventually(3).Should(Receive())
-			})
-			Expect(time.Since(t)).Should(BeNumerically("<", 500*time.Millisecond))
-			Expect(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 e42dd8a6e..000000000
--- a/vendor/github.com/onsi/gomega/matchers/succeed_matcher_test.go
+++ /dev/null
@@ -1,72 +0,0 @@
-package matchers_test
-
-import (
-	"errors"
-	. "github.com/onsi/ginkgo"
-	. "github.com/onsi/gomega"
-	. "github.com/onsi/gomega/matchers"
-	"regexp"
-)
-
-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() {
-		Expect(NotErroring()).Should(Succeed())
-	})
-
-	It("should succeed (in the negated) if the function errored", func() {
-		Expect(Erroring()).ShouldNot(Succeed())
-	})
-
-	It("should not if passed a non-error", func() {
-		success, err := (&SucceedMatcher{}).Match(Invalid())
-		Expect(success).Should(BeFalse())
-		Expect(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{})
-		Expect(success).Should(BeFalse())
-		Expect(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{})
-		Expect(success).Should(BeFalse())
-		Expect(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"}
-		Expect(err).ShouldNot(Succeed())
-	})
-
-	It("should succeed with nil pointers to types that conform to error interface", func() {
-		var err *CustomErr = nil
-		Expect(err).Should(Succeed())
-	})
-
-	It("builds failure message", func() {
-		actual := Succeed().FailureMessage(errors.New("oops"))
-		actual = regexp.MustCompile(" 0x.*>").ReplaceAllString(actual, " 0x00000000>")
-		Expect(actual).To(Equal("Expected success, but got an error:\n    <*errors.errorString | 0x00000000>: {s: \"oops\"}\n    oops"))
-	})
-
-	It("builds negated failure message", func() {
-		actual := Succeed().NegatedFailureMessage(123)
-		Expect(actual).To(Equal("Expected failure, but got no error."))
-	})
-})
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 8edd8175a..000000000
--- 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/test_data/xml/sample_01.xml b/vendor/github.com/onsi/gomega/matchers/test_data/xml/sample_01.xml
deleted file mode 100644
index 90f0a1b45..000000000
--- a/vendor/github.com/onsi/gomega/matchers/test_data/xml/sample_01.xml
+++ /dev/null
@@ -1,6 +0,0 @@
-<note>
-    <to>Tove</to>
-    <from>Jani</from>
-    <heading>Reminder</heading>
-    <body>Don't forget me this weekend!</body>
-</note>
\ No newline at end of file
diff --git a/vendor/github.com/onsi/gomega/matchers/test_data/xml/sample_02.xml b/vendor/github.com/onsi/gomega/matchers/test_data/xml/sample_02.xml
deleted file mode 100644
index 3863b83c3..000000000
--- a/vendor/github.com/onsi/gomega/matchers/test_data/xml/sample_02.xml
+++ /dev/null
@@ -1,9 +0,0 @@
-
-
-<note>
-    <to>Tove</to>
-    <from>Jani</from>
-    <heading>Reminder</heading>
-    <body>Don't forget me this weekend!</body>
-</note>
-
diff --git a/vendor/github.com/onsi/gomega/matchers/test_data/xml/sample_03.xml b/vendor/github.com/onsi/gomega/matchers/test_data/xml/sample_03.xml
deleted file mode 100644
index a491c213c..000000000
--- a/vendor/github.com/onsi/gomega/matchers/test_data/xml/sample_03.xml
+++ /dev/null
@@ -1 +0,0 @@
-<note> <to>Tove</to> <from>Jani</from> <heading>Reminder</heading> <body>Don't forget me this weekend!</body> </note>
diff --git a/vendor/github.com/onsi/gomega/matchers/test_data/xml/sample_04.xml b/vendor/github.com/onsi/gomega/matchers/test_data/xml/sample_04.xml
deleted file mode 100644
index dcfd3db03..000000000
--- a/vendor/github.com/onsi/gomega/matchers/test_data/xml/sample_04.xml
+++ /dev/null
@@ -1,6 +0,0 @@
-<note>
-    <to>Tove</to>
-    <from>John</from>
-    <heading>Doe</heading>
-    <body>Don't forget me this weekend!</body>
-</note>
\ No newline at end of file
diff --git a/vendor/github.com/onsi/gomega/matchers/test_data/xml/sample_05.xml b/vendor/github.com/onsi/gomega/matchers/test_data/xml/sample_05.xml
deleted file mode 100644
index de15a6a55..000000000
--- a/vendor/github.com/onsi/gomega/matchers/test_data/xml/sample_05.xml
+++ /dev/null
@@ -1,211 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>

-<CATALOG>

-  <CD>

-    <TITLE>Empire Burlesque</TITLE>

-    <ARTIST>Bob Dylan</ARTIST>

-    <COUNTRY>USA</COUNTRY>

-    <COMPANY>Columbia</COMPANY>

-    <PRICE>10.90</PRICE>

-    <YEAR>1985</YEAR>

-  </CD>

-  <CD>

-    <TITLE>Hide your heart</TITLE>

-    <ARTIST>Bonnie Tyler</ARTIST>

-    <COUNTRY>UK</COUNTRY>

-    <COMPANY>CBS Records</COMPANY>

-    <PRICE>9.90</PRICE>

-    <YEAR>1988</YEAR>

-  </CD>

-  <CD>

-    <TITLE>Greatest Hits</TITLE>

-    <ARTIST>Dolly Parton</ARTIST>

-    <COUNTRY>USA</COUNTRY>

-    <COMPANY>RCA</COMPANY>

-    <PRICE>9.90</PRICE>

-    <YEAR>1982</YEAR>

-  </CD>

-  <CD>

-    <TITLE>Still got the blues</TITLE>

-    <ARTIST>Gary Moore</ARTIST>

-    <COUNTRY>UK</COUNTRY>

-    <COMPANY>Virgin records</COMPANY>

-    <PRICE>10.20</PRICE>

-    <YEAR>1990</YEAR>

-  </CD>

-  <CD>

-    <TITLE>Eros</TITLE>

-    <ARTIST>Eros Ramazzotti</ARTIST>

-    <COUNTRY>EU</COUNTRY>

-    <COMPANY>BMG</COMPANY>

-    <PRICE>9.90</PRICE>

-    <YEAR>1997</YEAR>

-  </CD>

-  <CD>

-    <TITLE>One night only</TITLE>

-    <ARTIST>Bee Gees</ARTIST>

-    <COUNTRY>UK</COUNTRY>

-    <COMPANY>Polydor</COMPANY>

-    <PRICE>10.90</PRICE>

-    <YEAR>1998</YEAR>

-  </CD>

-  <CD>

-    <TITLE>Sylvias Mother</TITLE>

-    <ARTIST>Dr.Hook</ARTIST>

-    <COUNTRY>UK</COUNTRY>

-    <COMPANY>CBS</COMPANY>

-    <PRICE>8.10</PRICE>

-    <YEAR>1973</YEAR>

-  </CD>

-  <CD>

-    <TITLE>Maggie May</TITLE>

-    <ARTIST>Rod Stewart</ARTIST>

-    <COUNTRY>UK</COUNTRY>

-    <COMPANY>Pickwick</COMPANY>

-    <PRICE>8.50</PRICE>

-    <YEAR>1990</YEAR>

-  </CD>

-  <CD>

-    <TITLE>Romanza</TITLE>

-    <ARTIST>Andrea Bocelli</ARTIST>

-    <COUNTRY>EU</COUNTRY>

-    <COMPANY>Polydor</COMPANY>

-    <PRICE>10.80</PRICE>

-    <YEAR>1996</YEAR>

-  </CD>

-  <CD>

-    <TITLE>When a man loves a woman</TITLE>

-    <ARTIST>Percy Sledge</ARTIST>

-    <COUNTRY>USA</COUNTRY>

-    <COMPANY>Atlantic</COMPANY>

-    <PRICE>8.70</PRICE>

-    <YEAR>1987</YEAR>

-  </CD>

-  <CD>

-    <TITLE>Black angel</TITLE>

-    <ARTIST>Savage Rose</ARTIST>

-    <COUNTRY>EU</COUNTRY>

-    <COMPANY>Mega</COMPANY>

-    <PRICE>10.90</PRICE>

-    <YEAR>1995</YEAR>

-  </CD>

-  <CD>

-    <TITLE>1999 Grammy Nominees</TITLE>

-    <ARTIST>Many</ARTIST>

-    <COUNTRY>USA</COUNTRY>

-    <COMPANY>Grammy</COMPANY>

-    <PRICE>10.20</PRICE>

-    <YEAR>1999</YEAR>

-  </CD>

-  <CD>

-    <TITLE>For the good times</TITLE>

-    <ARTIST>Kenny Rogers</ARTIST>

-    <COUNTRY>UK</COUNTRY>

-    <COMPANY>Mucik Master</COMPANY>

-    <PRICE>8.70</PRICE>

-    <YEAR>1995</YEAR>

-  </CD>

-  <CD>

-    <TITLE>Big Willie style</TITLE>

-    <ARTIST>Will Smith</ARTIST>

-    <COUNTRY>USA</COUNTRY>

-    <COMPANY>Columbia</COMPANY>

-    <PRICE>9.90</PRICE>

-    <YEAR>1997</YEAR>

-  </CD>

-  <CD>

-    <TITLE>Tupelo Honey</TITLE>

-    <ARTIST>Van Morrison</ARTIST>

-    <COUNTRY>UK</COUNTRY>

-    <COMPANY>Polydor</COMPANY>

-    <PRICE>8.20</PRICE>

-    <YEAR>1971</YEAR>

-  </CD>

-  <CD>

-    <TITLE>Soulsville</TITLE>

-    <ARTIST>Jorn Hoel</ARTIST>

-    <COUNTRY>Norway</COUNTRY>

-    <COMPANY>WEA</COMPANY>

-    <PRICE>7.90</PRICE>

-    <YEAR>1996</YEAR>

-  </CD>

-  <CD>

-    <TITLE>The very best of</TITLE>

-    <ARTIST>Cat Stevens</ARTIST>

-    <COUNTRY>UK</COUNTRY>

-    <COMPANY>Island</COMPANY>

-    <PRICE>8.90</PRICE>

-    <YEAR>1990</YEAR>

-  </CD>

-  <CD>

-    <TITLE>Stop</TITLE>

-    <ARTIST>Sam Brown</ARTIST>

-    <COUNTRY>UK</COUNTRY>

-    <COMPANY>A and M</COMPANY>

-    <PRICE>8.90</PRICE>

-    <YEAR>1988</YEAR>

-  </CD>

-  <CD>

-    <TITLE>Bridge of Spies</TITLE>

-    <ARTIST>T'Pau</ARTIST>

-    <COUNTRY>UK</COUNTRY>

-    <COMPANY>Siren</COMPANY>

-    <PRICE>7.90</PRICE>

-    <YEAR>1987</YEAR>

-  </CD>

-  <CD>

-    <TITLE>Private Dancer</TITLE>

-    <ARTIST>Tina Turner</ARTIST>

-    <COUNTRY>UK</COUNTRY>

-    <COMPANY>Capitol</COMPANY>

-    <PRICE>8.90</PRICE>

-    <YEAR>1983</YEAR>

-  </CD>

-  <CD>

-    <TITLE>Midt om natten</TITLE>

-    <ARTIST>Kim Larsen</ARTIST>

-    <COUNTRY>EU</COUNTRY>

-    <COMPANY>Medley</COMPANY>

-    <PRICE>7.80</PRICE>

-    <YEAR>1983</YEAR>

-  </CD>

-  <CD>

-    <TITLE>Pavarotti Gala Concert</TITLE>

-    <ARTIST>Luciano Pavarotti</ARTIST>

-    <COUNTRY>UK</COUNTRY>

-    <COMPANY>DECCA</COMPANY>

-    <PRICE>9.90</PRICE>

-    <YEAR>1991</YEAR>

-  </CD>

-  <CD>

-    <TITLE>The dock of the bay</TITLE>

-    <ARTIST>Otis Redding</ARTIST>

-    <COUNTRY>USA</COUNTRY>

-    <COMPANY>Stax Records</COMPANY>

-    <PRICE>7.90</PRICE>

-    <YEAR>1968</YEAR>

-  </CD>

-  <CD>

-    <TITLE>Picture book</TITLE>

-    <ARTIST>Simply Red</ARTIST>

-    <COUNTRY>EU</COUNTRY>

-    <COMPANY>Elektra</COMPANY>

-    <PRICE>7.20</PRICE>

-    <YEAR>1985</YEAR>

-  </CD>

-  <CD>

-    <TITLE>Red</TITLE>

-    <ARTIST>The Communards</ARTIST>

-    <COUNTRY>UK</COUNTRY>

-    <COMPANY>London</COMPANY>

-    <PRICE>7.80</PRICE>

-    <YEAR>1987</YEAR>

-  </CD>

-  <CD>

-    <TITLE>Unchain my heart</TITLE>

-    <ARTIST>Joe Cocker</ARTIST>

-    <COUNTRY>USA</COUNTRY>

-    <COMPANY>EMI</COMPANY>

-    <PRICE>8.20</PRICE>

-    <YEAR>1987</YEAR>

-  </CD>

-</CATALOG>

diff --git a/vendor/github.com/onsi/gomega/matchers/test_data/xml/sample_06.xml b/vendor/github.com/onsi/gomega/matchers/test_data/xml/sample_06.xml
deleted file mode 100644
index 4ba90fb97..000000000
--- a/vendor/github.com/onsi/gomega/matchers/test_data/xml/sample_06.xml
+++ /dev/null
@@ -1,13 +0,0 @@
-<root>
-    <table>
-        <tr>
-            <td>Apples</td>
-            <td>Bananas</td>
-        </tr>
-    </table>
-    <table>
-        <name>African Coffee Table</name>
-        <width>80</width>
-        <length>120</length>
-    </table>
-</root>
\ No newline at end of file
diff --git a/vendor/github.com/onsi/gomega/matchers/test_data/xml/sample_07.xml b/vendor/github.com/onsi/gomega/matchers/test_data/xml/sample_07.xml
deleted file mode 100644
index 34b9e9775..000000000
--- a/vendor/github.com/onsi/gomega/matchers/test_data/xml/sample_07.xml
+++ /dev/null
@@ -1,13 +0,0 @@
-<root>
-    <h:table xmlns:h="http://www.w3.org/TR/html4/">
-        <h:tr>
-            <h:td>Apples</h:td>
-            <h:td>Bananas</h:td>
-        </h:tr>
-    </h:table>
-    <f:table xmlns:f="https://www.w3schools.com/furniture">
-        <f:name>African Coffee Table</f:name>
-        <f:width>80</f:width>
-        <f:length>120</f:length>
-    </f:table>
-</root>
\ No newline at end of file
diff --git a/vendor/github.com/onsi/gomega/matchers/test_data/xml/sample_08.xml b/vendor/github.com/onsi/gomega/matchers/test_data/xml/sample_08.xml
deleted file mode 100644
index ccaee4e1a..000000000
--- a/vendor/github.com/onsi/gomega/matchers/test_data/xml/sample_08.xml
+++ /dev/null
@@ -1,13 +0,0 @@
-<root>
-    <h:table xmlns:h="http://www.w3.org/TR/html4/">
-        <h:tr>
-            <h:td>Apples</h:td>
-            <h:td>Oranges</h:td>
-        </h:tr>
-    </h:table>
-    <f:table xmlns:f="https://www.w3schools.com/furniture">
-        <f:name>African Coffee Table</f:name>
-        <f:width>80</f:width>
-        <f:length>120</f:length>
-    </f:table>
-</root>
\ No newline at end of file
diff --git a/vendor/github.com/onsi/gomega/matchers/test_data/xml/sample_09.xml b/vendor/github.com/onsi/gomega/matchers/test_data/xml/sample_09.xml
deleted file mode 100644
index 531f84d3f..000000000
--- a/vendor/github.com/onsi/gomega/matchers/test_data/xml/sample_09.xml
+++ /dev/null
@@ -1,4 +0,0 @@
-<person gender="female">
-    <firstname>Foo</firstname>
-    <lastname>Bar</lastname>
-</person>
\ No newline at end of file
diff --git a/vendor/github.com/onsi/gomega/matchers/test_data/xml/sample_10.xml b/vendor/github.com/onsi/gomega/matchers/test_data/xml/sample_10.xml
deleted file mode 100644
index b1e1e1fbe..000000000
--- a/vendor/github.com/onsi/gomega/matchers/test_data/xml/sample_10.xml
+++ /dev/null
@@ -1,4 +0,0 @@
-<person gender="male">
-    <firstname>Foo</firstname>
-    <lastname>Bar</lastname>
-</person>
\ No newline at end of file
diff --git a/vendor/github.com/onsi/gomega/matchers/test_data/xml/sample_11.xml b/vendor/github.com/onsi/gomega/matchers/test_data/xml/sample_11.xml
deleted file mode 100644
index 3132b0f90..000000000
--- a/vendor/github.com/onsi/gomega/matchers/test_data/xml/sample_11.xml
+++ /dev/null
@@ -1,7 +0,0 @@
-<?xml version="1.0" encoding="ISO-8859-1" standalone="no"?>
-<note>
-    <to>Tove</to>
-    <from>Jani</from>
-    <heading>Reminder</heading>
-    <body>Don't forget me this weekend!</body>
-</note>
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 e52bf8e63..000000000
--- 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
-		})
-	})
-})