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/ginkgo/ginkgo/testsuite/test_suite.go

@@ -0,0 +1,116 @@
+package testsuite
+
+import (
+	"errors"
+	"io/ioutil"
+	"os"
+	"path"
+	"path/filepath"
+	"regexp"
+	"strings"
+)
+
+type TestSuite struct {
+	Path        string
+	PackageName string
+	IsGinkgo    bool
+	Precompiled bool
+}
+
+func PrecompiledTestSuite(path string) (TestSuite, error) {
+	info, err := os.Stat(path)
+	if err != nil {
+		return TestSuite{}, err
+	}
+
+	if info.IsDir() {
+		return TestSuite{}, errors.New("this is a directory, not a file")
+	}
+
+	if filepath.Ext(path) != ".test" {
+		return TestSuite{}, errors.New("this is not a .test binary")
+	}
+
+	if info.Mode()&0111 == 0 {
+		return TestSuite{}, errors.New("this is not executable")
+	}
+
+	dir := relPath(filepath.Dir(path))
+	packageName := strings.TrimSuffix(filepath.Base(path), filepath.Ext(path))
+
+	return TestSuite{
+		Path:        dir,
+		PackageName: packageName,
+		IsGinkgo:    true,
+		Precompiled: true,
+	}, nil
+}
+
+func SuitesInDir(dir string, recurse bool) []TestSuite {
+	suites := []TestSuite{}
+
+	// "This change will only be enabled if the go command is run with
+	// GO15VENDOREXPERIMENT=1 in its environment."
+	// c.f. the vendor-experiment proposal https://goo.gl/2ucMeC
+	vendorExperiment := os.Getenv("GO15VENDOREXPERIMENT")
+	if (vendorExperiment == "1") && path.Base(dir) == "vendor" {
+		return suites
+	}
+
+	files, _ := ioutil.ReadDir(dir)
+	re := regexp.MustCompile(`_test\.go$`)
+	for _, file := range files {
+		if !file.IsDir() && re.Match([]byte(file.Name())) {
+			suites = append(suites, New(dir, files))
+			break
+		}
+	}
+
+	if recurse {
+		re = regexp.MustCompile(`^[._]`)
+		for _, file := range files {
+			if file.IsDir() && !re.Match([]byte(file.Name())) {
+				suites = append(suites, SuitesInDir(dir+"/"+file.Name(), recurse)...)
+			}
+		}
+	}
+
+	return suites
+}
+
+func relPath(dir string) string {
+	dir, _ = filepath.Abs(dir)
+	cwd, _ := os.Getwd()
+	dir, _ = filepath.Rel(cwd, filepath.Clean(dir))
+	dir = "." + string(filepath.Separator) + dir
+	return dir
+}
+
+func New(dir string, files []os.FileInfo) TestSuite {
+	return TestSuite{
+		Path:        relPath(dir),
+		PackageName: packageNameForSuite(dir),
+		IsGinkgo:    filesHaveGinkgoSuite(dir, files),
+	}
+}
+
+func packageNameForSuite(dir string) string {
+	path, _ := filepath.Abs(dir)
+	return filepath.Base(path)
+}
+
+func filesHaveGinkgoSuite(dir string, files []os.FileInfo) bool {
+	reTestFile := regexp.MustCompile(`_test\.go$`)
+	reGinkgo := regexp.MustCompile(`package ginkgo|\/ginkgo"`)
+
+	for _, file := range files {
+		if !file.IsDir() && reTestFile.Match([]byte(file.Name())) {
+			contents, _ := ioutil.ReadFile(dir + "/" + file.Name())
+			if reGinkgo.Match(contents) {
+				return true
+			}
+		}
+	}
+
+	return false
+}

vendor/github.com/onsi/ginkgo/ginkgo/testsuite/testsuite_suite_test.go

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

vendor/github.com/onsi/ginkgo/ginkgo/testsuite/testsuite_test.go

@@ -0,0 +1,200 @@
+package testsuite_test
+
+import (
+	"io/ioutil"
+	"os"
+	"path/filepath"
+
+	. "github.com/onsi/ginkgo"
+	. "github.com/onsi/ginkgo/ginkgo/testsuite"
+	. "github.com/onsi/gomega"
+)
+
+var _ = Describe("TestSuite", func() {
+	var tmpDir string
+	var relTmpDir string
+
+	writeFile := func(folder string, filename string, content string, mode os.FileMode) {
+		path := filepath.Join(tmpDir, folder)
+		err := os.MkdirAll(path, 0700)
+		Ω(err).ShouldNot(HaveOccurred())
+
+		path = filepath.Join(path, filename)
+		ioutil.WriteFile(path, []byte(content), mode)
+	}
+
+	var origVendor string
+
+	BeforeSuite(func() {
+		origVendor = os.Getenv("GO15VENDOREXPERIMENT")
+	})
+
+	AfterSuite(func() {
+		os.Setenv("GO15VENDOREXPERIMENT", origVendor)
+	})
+
+	BeforeEach(func() {
+		var err error
+		tmpDir, err = ioutil.TempDir("/tmp", "ginkgo")
+		Ω(err).ShouldNot(HaveOccurred())
+
+		cwd, err := os.Getwd()
+		Ω(err).ShouldNot(HaveOccurred())
+		relTmpDir, err = filepath.Rel(cwd, tmpDir)
+		relTmpDir = "./" + relTmpDir
+		Ω(err).ShouldNot(HaveOccurred())
+
+		//go files in the root directory (no tests)
+		writeFile("/", "main.go", "package main", 0666)
+
+		//non-go files in a nested directory
+		writeFile("/redherring", "big_test.jpg", "package ginkgo", 0666)
+
+		//non-ginkgo tests in a nested directory
+		writeFile("/professorplum", "professorplum_test.go", `import "testing"`, 0666)
+
+		//ginkgo tests in a nested directory
+		writeFile("/colonelmustard", "colonelmustard_test.go", `import "github.com/onsi/ginkgo"`, 0666)
+
+		//ginkgo tests in a deeply nested directory
+		writeFile("/colonelmustard/library", "library_test.go", `import "github.com/onsi/ginkgo"`, 0666)
+
+		//ginkgo tests deeply nested in a vendored dependency
+		writeFile("/vendor/mrspeacock/lounge", "lounge_test.go", `import "github.com/onsi/ginkgo"`, 0666)
+
+		//a precompiled ginkgo test
+		writeFile("/precompiled-dir", "precompiled.test", `fake-binary-file`, 0777)
+		writeFile("/precompiled-dir", "some-other-binary", `fake-binary-file`, 0777)
+		writeFile("/precompiled-dir", "nonexecutable.test", `fake-binary-file`, 0666)
+	})
+
+	AfterEach(func() {
+		os.RemoveAll(tmpDir)
+	})
+
+	Describe("Finding precompiled test suites", func() {
+		Context("if pointed at an executable file that ends with .test", func() {
+			It("should return a precompiled test suite", func() {
+				suite, err := PrecompiledTestSuite(filepath.Join(tmpDir, "precompiled-dir", "precompiled.test"))
+				Ω(err).ShouldNot(HaveOccurred())
+				Ω(suite).Should(Equal(TestSuite{
+					Path:        relTmpDir + "/precompiled-dir",
+					PackageName: "precompiled",
+					IsGinkgo:    true,
+					Precompiled: true,
+				}))
+			})
+		})
+
+		Context("if pointed at a directory", func() {
+			It("should error", func() {
+				suite, err := PrecompiledTestSuite(filepath.Join(tmpDir, "precompiled-dir"))
+				Ω(suite).Should(BeZero())
+				Ω(err).Should(HaveOccurred())
+			})
+		})
+
+		Context("if pointed at an executable that doesn't have .test", func() {
+			It("should error", func() {
+				suite, err := PrecompiledTestSuite(filepath.Join(tmpDir, "precompiled-dir", "some-other-binary"))
+				Ω(suite).Should(BeZero())
+				Ω(err).Should(HaveOccurred())
+			})
+		})
+
+		Context("if pointed at a .test that isn't executable", func() {
+			It("should error", func() {
+				suite, err := PrecompiledTestSuite(filepath.Join(tmpDir, "precompiled-dir", "nonexecutable.test"))
+				Ω(suite).Should(BeZero())
+				Ω(err).Should(HaveOccurred())
+			})
+		})
+
+		Context("if pointed at a nonexisting file", func() {
+			It("should error", func() {
+				suite, err := PrecompiledTestSuite(filepath.Join(tmpDir, "precompiled-dir", "nope-nothing-to-see-here"))
+				Ω(suite).Should(BeZero())
+				Ω(err).Should(HaveOccurred())
+			})
+		})
+	})
+
+	Describe("scanning for suites in a directory", func() {
+		Context("when there are no tests in the specified directory", func() {
+			It("should come up empty", func() {
+				suites := SuitesInDir(tmpDir, false)
+				Ω(suites).Should(BeEmpty())
+			})
+		})
+
+		Context("when there are ginkgo tests in the specified directory", func() {
+			It("should return an appropriately configured suite", func() {
+				suites := SuitesInDir(filepath.Join(tmpDir, "colonelmustard"), false)
+				Ω(suites).Should(HaveLen(1))
+
+				Ω(suites[0].Path).Should(Equal(relTmpDir + "/colonelmustard"))
+				Ω(suites[0].PackageName).Should(Equal("colonelmustard"))
+				Ω(suites[0].IsGinkgo).Should(BeTrue())
+				Ω(suites[0].Precompiled).Should(BeFalse())
+			})
+		})
+
+		Context("when there are non-ginkgo tests in the specified directory", func() {
+			It("should return an appropriately configured suite", func() {
+				suites := SuitesInDir(filepath.Join(tmpDir, "professorplum"), false)
+				Ω(suites).Should(HaveLen(1))
+
+				Ω(suites[0].Path).Should(Equal(relTmpDir + "/professorplum"))
+				Ω(suites[0].PackageName).Should(Equal("professorplum"))
+				Ω(suites[0].IsGinkgo).Should(BeFalse())
+				Ω(suites[0].Precompiled).Should(BeFalse())
+			})
+		})
+
+		Context("given GO15VENDOREXPERIMENT", func() {
+			BeforeEach(func() {
+				os.Setenv("GO15VENDOREXPERIMENT", "1")
+			})
+
+			AfterEach(func() {
+				os.Setenv("GO15VENDOREXPERIMENT", "")
+			})
+
+			It("should skip vendor dirs", func() {
+				suites := SuitesInDir(filepath.Join(tmpDir+"/vendor"), false)
+				Ω(suites).Should(HaveLen(0))
+			})
+
+			It("should not recurse into vendor dirs", func() {
+				suites := SuitesInDir(filepath.Join(tmpDir), true)
+				Ω(suites).Should(HaveLen(3))
+			})
+		})
+
+		Context("when recursively scanning", func() {
+			It("should return suites for corresponding test suites, only", func() {
+				suites := SuitesInDir(tmpDir, true)
+				Ω(suites).Should(HaveLen(4))
+
+				Ω(suites).Should(ContainElement(TestSuite{
+					Path:        relTmpDir + "/colonelmustard",
+					PackageName: "colonelmustard",
+					IsGinkgo:    true,
+					Precompiled: false,
+				}))
+				Ω(suites).Should(ContainElement(TestSuite{
+					Path:        relTmpDir + "/professorplum",
+					PackageName: "professorplum",
+					IsGinkgo:    false,
+					Precompiled: false,
+				}))
+				Ω(suites).Should(ContainElement(TestSuite{
+					Path:        relTmpDir + "/colonelmustard/library",
+					PackageName: "library",
+					IsGinkgo:    true,
+					Precompiled: false,
+				}))
+			})
+		})
+	})
+})