Use Go 1.5 vendoring instead of Godeps

Change made by:

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

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

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

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

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

vendor/github.com/onsi/gomega/internal/asyncassertion/async_assertion.go

@@ -0,0 +1,189 @@
+package asyncassertion
+
+import (
+	"errors"
+	"fmt"
+	"reflect"
+	"time"
+
+	"github.com/onsi/gomega/internal/oraclematcher"
+	"github.com/onsi/gomega/types"
+)
+
+type AsyncAssertionType uint
+
+const (
+	AsyncAssertionTypeEventually AsyncAssertionType = iota
+	AsyncAssertionTypeConsistently
+)
+
+type AsyncAssertion struct {
+	asyncType       AsyncAssertionType
+	actualInput     interface{}
+	timeoutInterval time.Duration
+	pollingInterval time.Duration
+	fail            types.GomegaFailHandler
+	offset          int
+}
+
+func New(asyncType AsyncAssertionType, actualInput interface{}, fail types.GomegaFailHandler, timeoutInterval time.Duration, pollingInterval time.Duration, offset int) *AsyncAssertion {
+	actualType := reflect.TypeOf(actualInput)
+	if actualType.Kind() == reflect.Func {
+		if actualType.NumIn() != 0 || actualType.NumOut() == 0 {
+			panic("Expected a function with no arguments and one or more return values.")
+		}
+	}
+
+	return &AsyncAssertion{
+		asyncType:       asyncType,
+		actualInput:     actualInput,
+		fail:            fail,
+		timeoutInterval: timeoutInterval,
+		pollingInterval: pollingInterval,
+		offset:          offset,
+	}
+}
+
+func (assertion *AsyncAssertion) Should(matcher types.GomegaMatcher, optionalDescription ...interface{}) bool {
+	return assertion.match(matcher, true, optionalDescription...)
+}
+
+func (assertion *AsyncAssertion) ShouldNot(matcher types.GomegaMatcher, optionalDescription ...interface{}) bool {
+	return assertion.match(matcher, false, optionalDescription...)
+}
+
+func (assertion *AsyncAssertion) buildDescription(optionalDescription ...interface{}) string {
+	switch len(optionalDescription) {
+	case 0:
+		return ""
+	default:
+		return fmt.Sprintf(optionalDescription[0].(string), optionalDescription[1:]...) + "\n"
+	}
+}
+
+func (assertion *AsyncAssertion) actualInputIsAFunction() bool {
+	actualType := reflect.TypeOf(assertion.actualInput)
+	return actualType.Kind() == reflect.Func && actualType.NumIn() == 0 && actualType.NumOut() > 0
+}
+
+func (assertion *AsyncAssertion) pollActual() (interface{}, error) {
+	if assertion.actualInputIsAFunction() {
+		values := reflect.ValueOf(assertion.actualInput).Call([]reflect.Value{})
+
+		extras := []interface{}{}
+		for _, value := range values[1:] {
+			extras = append(extras, value.Interface())
+		}
+
+		success, message := vetExtras(extras)
+
+		if !success {
+			return nil, errors.New(message)
+		}
+
+		return values[0].Interface(), nil
+	}
+
+	return assertion.actualInput, nil
+}
+
+func (assertion *AsyncAssertion) matcherMayChange(matcher types.GomegaMatcher, value interface{}) bool {
+	if assertion.actualInputIsAFunction() {
+		return true
+	}
+
+	return oraclematcher.MatchMayChangeInTheFuture(matcher, value)
+}
+
+func (assertion *AsyncAssertion) match(matcher types.GomegaMatcher, desiredMatch bool, optionalDescription ...interface{}) bool {
+	timer := time.Now()
+	timeout := time.After(assertion.timeoutInterval)
+
+	description := assertion.buildDescription(optionalDescription...)
+
+	var matches bool
+	var err error
+	mayChange := true
+	value, err := assertion.pollActual()
+	if err == nil {
+		mayChange = assertion.matcherMayChange(matcher, value)
+		matches, err = matcher.Match(value)
+	}
+
+	fail := func(preamble string) {
+		errMsg := ""
+		message := ""
+		if err != nil {
+			errMsg = "Error: " + err.Error()
+		} else {
+			if desiredMatch {
+				message = matcher.FailureMessage(value)
+			} else {
+				message = matcher.NegatedFailureMessage(value)
+			}
+		}
+		assertion.fail(fmt.Sprintf("%s after %.3fs.\n%s%s%s", preamble, time.Since(timer).Seconds(), description, message, errMsg), 3+assertion.offset)
+	}
+
+	if assertion.asyncType == AsyncAssertionTypeEventually {
+		for {
+			if err == nil && matches == desiredMatch {
+				return true
+			}
+
+			if !mayChange {
+				fail("No future change is possible.  Bailing out early")
+				return false
+			}
+
+			select {
+			case <-time.After(assertion.pollingInterval):
+				value, err = assertion.pollActual()
+				if err == nil {
+					mayChange = assertion.matcherMayChange(matcher, value)
+					matches, err = matcher.Match(value)
+				}
+			case <-timeout:
+				fail("Timed out")
+				return false
+			}
+		}
+	} else if assertion.asyncType == AsyncAssertionTypeConsistently {
+		for {
+			if !(err == nil && matches == desiredMatch) {
+				fail("Failed")
+				return false
+			}
+
+			if !mayChange {
+				return true
+			}
+
+			select {
+			case <-time.After(assertion.pollingInterval):
+				value, err = assertion.pollActual()
+				if err == nil {
+					mayChange = assertion.matcherMayChange(matcher, value)
+					matches, err = matcher.Match(value)
+				}
+			case <-timeout:
+				return true
+			}
+		}
+	}
+
+	return false
+}
+
+func vetExtras(extras []interface{}) (bool, string) {
+	for i, extra := range extras {
+		if extra != nil {
+			zeroValue := reflect.Zero(reflect.TypeOf(extra)).Interface()
+			if !reflect.DeepEqual(zeroValue, extra) {
+				message := fmt.Sprintf("Unexpected non-nil/non-zero extra argument at index %d:\n\t<%T>: %#v", i+1, extra, extra)
+				return false, message
+			}
+		}
+	}
+	return true, ""
+}

vendor/github.com/onsi/gomega/internal/asyncassertion/async_assertion_suite_test.go

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

vendor/github.com/onsi/gomega/internal/asyncassertion/async_assertion_test.go

@@ -0,0 +1,345 @@
+package asyncassertion_test
+
+import (
+	"errors"
+	"time"
+
+	. "github.com/onsi/ginkgo"
+	. "github.com/onsi/gomega"
+	. "github.com/onsi/gomega/internal/asyncassertion"
+)
+
+var _ = Describe("Async Assertion", func() {
+	var (
+		failureMessage string
+		callerSkip     int
+	)
+
+	var fakeFailHandler = func(message string, skip ...int) {
+		failureMessage = message
+		callerSkip = skip[0]
+	}
+
+	BeforeEach(func() {
+		failureMessage = ""
+		callerSkip = 0
+	})
+
+	Describe("Eventually", func() {
+		Context("the positive case", func() {
+			It("should poll the function and matcher", func() {
+				counter := 0
+				a := New(AsyncAssertionTypeEventually, func() int {
+					counter++
+					return counter
+				}, fakeFailHandler, time.Duration(0.2*float64(time.Second)), time.Duration(0.02*float64(time.Second)), 1)
+
+				a.Should(BeNumerically("==", 5))
+				Ω(failureMessage).Should(BeZero())
+			})
+
+			It("should continue when the matcher errors", func() {
+				counter := 0
+				a := New(AsyncAssertionTypeEventually, func() interface{} {
+					counter++
+					if counter == 5 {
+						return "not-a-number" //this should cause the matcher to error
+					}
+					return counter
+				}, fakeFailHandler, time.Duration(0.2*float64(time.Second)), time.Duration(0.02*float64(time.Second)), 1)
+
+				a.Should(BeNumerically("==", 5), "My description %d", 2)
+
+				Ω(failureMessage).Should(ContainSubstring("Timed out after"))
+				Ω(failureMessage).Should(ContainSubstring("My description 2"))
+				Ω(callerSkip).Should(Equal(4))
+			})
+
+			It("should be able to timeout", func() {
+				counter := 0
+				a := New(AsyncAssertionTypeEventually, func() int {
+					counter++
+					return counter
+				}, fakeFailHandler, time.Duration(0.2*float64(time.Second)), time.Duration(0.02*float64(time.Second)), 1)
+
+				a.Should(BeNumerically(">", 100), "My description %d", 2)
+
+				Ω(counter).Should(BeNumerically(">", 8))
+				Ω(counter).Should(BeNumerically("<=", 10))
+				Ω(failureMessage).Should(ContainSubstring("Timed out after"))
+				Ω(failureMessage).Should(MatchRegexp(`\<int\>: \d`), "Should pass the correct value to the matcher message formatter.")
+				Ω(failureMessage).Should(ContainSubstring("My description 2"))
+				Ω(callerSkip).Should(Equal(4))
+			})
+		})
+
+		Context("the negative case", func() {
+			It("should poll the function and matcher", func() {
+				counter := 0
+				a := New(AsyncAssertionTypeEventually, func() int {
+					counter += 1
+					return counter
+				}, fakeFailHandler, time.Duration(0.2*float64(time.Second)), time.Duration(0.02*float64(time.Second)), 1)
+
+				a.ShouldNot(BeNumerically("<", 3))
+
+				Ω(counter).Should(Equal(3))
+				Ω(failureMessage).Should(BeZero())
+			})
+
+			It("should timeout when the matcher errors", func() {
+				a := New(AsyncAssertionTypeEventually, func() interface{} {
+					return 0 //this should cause the matcher to error
+				}, fakeFailHandler, time.Duration(0.2*float64(time.Second)), time.Duration(0.02*float64(time.Second)), 1)
+
+				a.ShouldNot(HaveLen(0), "My description %d", 2)
+
+				Ω(failureMessage).Should(ContainSubstring("Timed out after"))
+				Ω(failureMessage).Should(ContainSubstring("Error:"))
+				Ω(failureMessage).Should(ContainSubstring("My description 2"))
+				Ω(callerSkip).Should(Equal(4))
+			})
+
+			It("should be able to timeout", func() {
+				a := New(AsyncAssertionTypeEventually, func() int {
+					return 0
+				}, fakeFailHandler, time.Duration(0.1*float64(time.Second)), time.Duration(0.02*float64(time.Second)), 1)
+
+				a.ShouldNot(Equal(0), "My description %d", 2)
+
+				Ω(failureMessage).Should(ContainSubstring("Timed out after"))
+				Ω(failureMessage).Should(ContainSubstring("<int>: 0"), "Should pass the correct value to the matcher message formatter.")
+				Ω(failureMessage).Should(ContainSubstring("My description 2"))
+				Ω(callerSkip).Should(Equal(4))
+			})
+		})
+
+		Context("with a function that returns multiple values", func() {
+			It("should eventually succeed if the additional arguments are nil", func() {
+				i := 0
+				Eventually(func() (int, error) {
+					i++
+					return i, nil
+				}).Should(Equal(10))
+			})
+
+			It("should eventually timeout if the additional arguments are not nil", func() {
+				i := 0
+				a := New(AsyncAssertionTypeEventually, func() (int, error) {
+					i++
+					return i, errors.New("bam")
+				}, fakeFailHandler, time.Duration(0.2*float64(time.Second)), time.Duration(0.02*float64(time.Second)), 1)
+				a.Should(Equal(2))
+
+				Ω(failureMessage).Should(ContainSubstring("Timed out after"))
+				Ω(failureMessage).Should(ContainSubstring("Error:"))
+				Ω(failureMessage).Should(ContainSubstring("bam"))
+				Ω(callerSkip).Should(Equal(4))
+			})
+		})
+
+		Context("Making an assertion without a registered fail handler", func() {
+			It("should panic", func() {
+				defer func() {
+					e := recover()
+					RegisterFailHandler(Fail)
+					if e == nil {
+						Fail("expected a panic to have occurred")
+					}
+				}()
+
+				RegisterFailHandler(nil)
+				c := make(chan bool, 1)
+				c <- true
+				Eventually(c).Should(Receive())
+			})
+		})
+	})
+
+	Describe("Consistently", func() {
+		Describe("The positive case", func() {
+			Context("when the matcher consistently passes for the duration", func() {
+				It("should pass", func() {
+					calls := 0
+					a := New(AsyncAssertionTypeConsistently, func() string {
+						calls++
+						return "foo"
+					}, fakeFailHandler, time.Duration(0.2*float64(time.Second)), time.Duration(0.02*float64(time.Second)), 1)
+
+					a.Should(Equal("foo"))
+					Ω(calls).Should(BeNumerically(">", 8))
+					Ω(calls).Should(BeNumerically("<=", 10))
+					Ω(failureMessage).Should(BeZero())
+				})
+			})
+
+			Context("when the matcher fails at some point", func() {
+				It("should fail", func() {
+					calls := 0
+					a := New(AsyncAssertionTypeConsistently, func() interface{} {
+						calls++
+						if calls > 5 {
+							return "bar"
+						}
+						return "foo"
+					}, fakeFailHandler, time.Duration(0.2*float64(time.Second)), time.Duration(0.02*float64(time.Second)), 1)
+
+					a.Should(Equal("foo"))
+					Ω(failureMessage).Should(ContainSubstring("to equal"))
+					Ω(callerSkip).Should(Equal(4))
+				})
+			})
+
+			Context("when the matcher errors at some point", func() {
+				It("should fail", func() {
+					calls := 0
+					a := New(AsyncAssertionTypeConsistently, func() interface{} {
+						calls++
+						if calls > 5 {
+							return 3
+						}
+						return []int{1, 2, 3}
+					}, fakeFailHandler, time.Duration(0.2*float64(time.Second)), time.Duration(0.02*float64(time.Second)), 1)
+
+					a.Should(HaveLen(3))
+					Ω(failureMessage).Should(ContainSubstring("HaveLen matcher expects"))
+					Ω(callerSkip).Should(Equal(4))
+				})
+			})
+		})
+
+		Describe("The negative case", func() {
+			Context("when the matcher consistently passes for the duration", func() {
+				It("should pass", func() {
+					c := make(chan bool)
+					a := New(AsyncAssertionTypeConsistently, c, fakeFailHandler, time.Duration(0.2*float64(time.Second)), time.Duration(0.02*float64(time.Second)), 1)
+
+					a.ShouldNot(Receive())
+					Ω(failureMessage).Should(BeZero())
+				})
+			})
+
+			Context("when the matcher fails at some point", func() {
+				It("should fail", func() {
+					c := make(chan bool)
+					go func() {
+						time.Sleep(time.Duration(100 * time.Millisecond))
+						c <- true
+					}()
+
+					a := New(AsyncAssertionTypeConsistently, c, fakeFailHandler, time.Duration(0.2*float64(time.Second)), time.Duration(0.02*float64(time.Second)), 1)
+
+					a.ShouldNot(Receive())
+					Ω(failureMessage).Should(ContainSubstring("not to receive anything"))
+				})
+			})
+
+			Context("when the matcher errors at some point", func() {
+				It("should fail", func() {
+					calls := 0
+					a := New(AsyncAssertionTypeConsistently, func() interface{} {
+						calls++
+						return calls
+					}, fakeFailHandler, time.Duration(0.2*float64(time.Second)), time.Duration(0.02*float64(time.Second)), 1)
+
+					a.ShouldNot(BeNumerically(">", 5))
+					Ω(failureMessage).Should(ContainSubstring("not to be >"))
+					Ω(callerSkip).Should(Equal(4))
+				})
+			})
+		})
+
+		Context("with a function that returns multiple values", func() {
+			It("should consistently succeed if the additional arguments are nil", func() {
+				i := 2
+				Consistently(func() (int, error) {
+					i++
+					return i, nil
+				}).Should(BeNumerically(">=", 2))
+			})
+
+			It("should eventually timeout if the additional arguments are not nil", func() {
+				i := 2
+				a := New(AsyncAssertionTypeEventually, func() (int, error) {
+					i++
+					return i, errors.New("bam")
+				}, fakeFailHandler, time.Duration(0.2*float64(time.Second)), time.Duration(0.02*float64(time.Second)), 1)
+				a.Should(BeNumerically(">=", 2))
+
+				Ω(failureMessage).Should(ContainSubstring("Error:"))
+				Ω(failureMessage).Should(ContainSubstring("bam"))
+				Ω(callerSkip).Should(Equal(4))
+			})
+		})
+
+		Context("Making an assertion without a registered fail handler", func() {
+			It("should panic", func() {
+				defer func() {
+					e := recover()
+					RegisterFailHandler(Fail)
+					if e == nil {
+						Fail("expected a panic to have occurred")
+					}
+				}()
+
+				RegisterFailHandler(nil)
+				c := make(chan bool)
+				Consistently(c).ShouldNot(Receive())
+			})
+		})
+	})
+
+	Context("when passed a function with the wrong # or arguments & returns", func() {
+		It("should panic", func() {
+			Ω(func() {
+				New(AsyncAssertionTypeEventually, func() {}, fakeFailHandler, 0, 0, 1)
+			}).Should(Panic())
+
+			Ω(func() {
+				New(AsyncAssertionTypeEventually, func(a string) int { return 0 }, fakeFailHandler, 0, 0, 1)
+			}).Should(Panic())
+
+			Ω(func() {
+				New(AsyncAssertionTypeEventually, func() int { return 0 }, fakeFailHandler, 0, 0, 1)
+			}).ShouldNot(Panic())
+
+			Ω(func() {
+				New(AsyncAssertionTypeEventually, func() (int, error) { return 0, nil }, fakeFailHandler, 0, 0, 1)
+			}).ShouldNot(Panic())
+		})
+	})
+
+	Describe("bailing early", func() {
+		Context("when actual is a value", func() {
+			It("Eventually should bail out and fail early if the matcher says to", func() {
+				c := make(chan bool)
+				close(c)
+
+				t := time.Now()
+				failures := InterceptGomegaFailures(func() {
+					Eventually(c, 0.1).Should(Receive())
+				})
+				Ω(time.Since(t)).Should(BeNumerically("<", 90*time.Millisecond))
+
+				Ω(failures).Should(HaveLen(1))
+			})
+		})
+
+		Context("when actual is a function", func() {
+			It("should never bail early", func() {
+				c := make(chan bool)
+				close(c)
+
+				t := time.Now()
+				failures := InterceptGomegaFailures(func() {
+					Eventually(func() chan bool {
+						return c
+					}, 0.1).Should(Receive())
+				})
+				Ω(time.Since(t)).Should(BeNumerically(">=", 90*time.Millisecond))
+
+				Ω(failures).Should(HaveLen(1))
+			})
+		})
+	})
+})