vendor: bump ginkgo, gover

Signed-off-by: Casey Callendrello <cdc@redhat.com>

vendor/github.com/onsi/gomega/gexec/build.go

@@ -1,32 +1,62 @@
+// untested sections: 5
+
 package gexec
 
 import (
 	"errors"
 	"fmt"
+	"go/build"
 	"io/ioutil"
 	"os"
 	"os/exec"
 	"path"
 	"path/filepath"
 	"runtime"
+	"strings"
+	"sync"
 )
 
-var tmpDir string
+var (
+	mu     sync.Mutex
+	tmpDir string
+)
 
 /*
 Build uses go build to compile the package at packagePath.  The resulting binary is saved off in a temporary directory.
 A path pointing to this binary is returned.
 
-Build uses the $GOPATH set in your environment.  It passes the variadic args on to `go build`.
+Build uses the $GOPATH set in your environment. If $GOPATH is not set and you are using Go 1.8+,
+it will use the default GOPATH instead.  It passes the variadic args on to `go build`.
 */
 func Build(packagePath string, args ...string) (compiledPath string, err error) {
-	return BuildIn(os.Getenv("GOPATH"), packagePath, args...)
+	return doBuild(build.Default.GOPATH, packagePath, nil, args...)
+}
+
+/*
+BuildWithEnvironment is identical to Build but allows you to specify env vars to be set at build time.
+*/
+func BuildWithEnvironment(packagePath string, env []string, args ...string) (compiledPath string, err error) {
+	return doBuild(build.Default.GOPATH, packagePath, env, args...)
 }
 
 /*
 BuildIn is identical to Build but allows you to specify a custom $GOPATH (the first argument).
 */
 func BuildIn(gopath string, packagePath string, args ...string) (compiledPath string, err error) {
+	return doBuild(gopath, packagePath, nil, args...)
+}
+
+func replaceGoPath(environ []string, newGoPath string) []string {
+	newEnviron := []string{}
+	for _, v := range environ {
+		if !strings.HasPrefix(v, "GOPATH=") {
+			newEnviron = append(newEnviron, v)
+		}
+	}
+	return append(newEnviron, "GOPATH="+newGoPath)
+}
+
+func doBuild(gopath, packagePath string, env []string, args ...string) (compiledPath string, err error) {
 	tmpDir, err := temporaryDirectory()
 	if err != nil {
 		return "", err
@@ -38,14 +68,15 @@ func BuildIn(gopath string, packagePath string, args ...string) (compiledPath st
 
 	executable := filepath.Join(tmpDir, path.Base(packagePath))
 	if runtime.GOOS == "windows" {
-		executable = executable + ".exe"
+		executable += ".exe"
 	}
 
 	cmdArgs := append([]string{"build"}, args...)
 	cmdArgs = append(cmdArgs, "-o", executable, packagePath)
 
 	build := exec.Command("go", cmdArgs...)
-	build.Env = append([]string{"GOPATH=" + gopath}, os.Environ()...)
+	build.Env = replaceGoPath(os.Environ(), gopath)
+	build.Env = append(build.Env, env...)
 
 	output, err := build.CombinedOutput()
 	if err != nil {
@@ -60,13 +91,18 @@ You should call CleanupBuildArtifacts before your test ends to clean up any temp
 gexec. In Ginkgo this is typically done in an AfterSuite callback.
 */
 func CleanupBuildArtifacts() {
+	mu.Lock()
+	defer mu.Unlock()
 	if tmpDir != "" {
 		os.RemoveAll(tmpDir)
+		tmpDir = ""
 	}
 }
 
 func temporaryDirectory() (string, error) {
 	var err error
+	mu.Lock()
+	defer mu.Unlock()
 	if tmpDir == "" {
 		tmpDir, err = ioutil.TempDir("", "gexec_artifacts")
 		if err != nil {

vendor/github.com/onsi/gomega/gexec/exit_matcher.go

@@ -1,3 +1,5 @@
+// untested sections: 2
+
 package gexec
 
 import (
@@ -9,7 +11,7 @@ import (
 /*
 The Exit matcher operates on a session:
 
-	Ω(session).Should(Exit(<optional status code>))
+	Expect(session).Should(Exit(<optional status code>))
 
 Exit passes if the session has already exited.
 
@@ -62,9 +64,8 @@ func (m *exitMatcher) Match(actual interface{}) (success bool, err error) {
 func (m *exitMatcher) FailureMessage(actual interface{}) (message string) {
 	if m.actualExitCode == -1 {
 		return "Expected process to exit.  It did not."
-	} else {
-		return format.Message(m.actualExitCode, "to match exit code:", m.exitCode)
 	}
+	return format.Message(m.actualExitCode, "to match exit code:", m.exitCode)
 }
 
 func (m *exitMatcher) NegatedFailureMessage(actual interface{}) (message string) {
@@ -73,9 +74,8 @@ func (m *exitMatcher) NegatedFailureMessage(actual interface{}) (message string)
 	} else {
 		if m.exitCode == -1 {
 			return "Expected process not to exit.  It did."
-		} else {
-			return format.Message(m.actualExitCode, "not to match exit code:", m.exitCode)
 		}
+		return format.Message(m.actualExitCode, "not to match exit code:", m.exitCode)
 	}
 }
 

vendor/github.com/onsi/gomega/gexec/prefixed_writer.go

@@ -1,3 +1,5 @@
+// untested sections: 1
+
 package gexec
 
 import (
@@ -6,7 +8,7 @@ import (
 )
 
 /*
-PrefixedWriter wraps an io.Writer, emiting the passed in prefix at the beginning of each new line.
+PrefixedWriter wraps an io.Writer, emitting the passed in prefix at the beginning of each new line.
 This can be useful when running multiple gexec.Sessions concurrently - you can prefix the log output of each
 session by passing in a PrefixedWriter:
 

vendor/github.com/onsi/gomega/gexec/session.go

@@ -1,13 +1,15 @@
 /*
 Package gexec provides support for testing external processes.
 */
+
+// untested sections: 1
+
 package gexec
 
 import (
 	"io"
 	"os"
 	"os/exec"
-	"reflect"
 	"sync"
 	"syscall"
 
@@ -40,12 +42,12 @@ Start starts the passed-in *exec.Cmd command.  It wraps the command in a *gexec.
 The session pipes the command's stdout and stderr to two *gbytes.Buffers available as properties on the session: session.Out and session.Err.
 These buffers can be used with the gbytes.Say matcher to match against unread output:
 
-	Ω(session.Out).Should(gbytes.Say("foo-out"))
-	Ω(session.Err).Should(gbytes.Say("foo-err"))
+	Expect(session.Out).Should(gbytes.Say("foo-out"))
+	Expect(session.Err).Should(gbytes.Say("foo-err"))
 
 In addition, Session satisfies the gbytes.BufferProvider interface and provides the stdout *gbytes.Buffer.  This allows you to replace the first line, above, with:
 
-	Ω(session).Should(gbytes.Say("foo-out"))
+	Expect(session).Should(gbytes.Say("foo-out"))
 
 When outWriter and/or errWriter are non-nil, the session will pipe stdout and/or stderr output both into the session *gybtes.Buffers and to the passed-in outWriter/errWriter.
 This is useful for capturing the process's output or logging it to screen.  In particular, when using Ginkgo it can be convenient to direct output to the GinkgoWriter:
@@ -57,10 +59,10 @@ This will log output when running tests in verbose mode, but - otherwise - will
 The session wrapper is responsible for waiting on the *exec.Cmd command.  You *should not* call command.Wait() yourself.
 Instead, to assert that the command has exited you can use the gexec.Exit matcher:
 
-	Ω(session).Should(gexec.Exit())
+	Expect(session).Should(gexec.Exit())
 
 When the session exits it closes the stdout and stderr gbytes buffers.  This will short circuit any
-Eventuallys waiting fo the buffers to Say something.
+Eventuallys waiting for the buffers to Say something.
 */
 func Start(command *exec.Cmd, outWriter io.Writer, errWriter io.Writer) (*Session, error) {
 	exited := make(chan struct{})
@@ -78,11 +80,11 @@ func Start(command *exec.Cmd, outWriter io.Writer, errWriter io.Writer) (*Sessio
 
 	commandOut, commandErr = session.Out, session.Err
 
-	if outWriter != nil && !reflect.ValueOf(outWriter).IsNil() {
+	if outWriter != nil {
 		commandOut = io.MultiWriter(commandOut, outWriter)
 	}
 
-	if errWriter != nil && !reflect.ValueOf(errWriter).IsNil() {
+	if errWriter != nil {
 		commandErr = io.MultiWriter(commandErr, errWriter)
 	}
 
@@ -92,6 +94,9 @@ func Start(command *exec.Cmd, outWriter io.Writer, errWriter io.Writer) (*Sessio
 	err := command.Start()
 	if err == nil {
 		go session.monitorForExit(exited)
+		trackedSessionsMutex.Lock()
+		defer trackedSessionsMutex.Unlock()
+		trackedSessions = append(trackedSessions, session)
 	}
 
 	return session, err
@@ -149,11 +154,7 @@ If the command has already exited, Kill returns silently.
 The session is returned to enable chaining.
 */
 func (s *Session) Kill() *Session {
-	if s.ExitCode() != -1 {
-		return s
-	}
-	s.Command.Process.Kill()
-	return s
+	return s.Signal(syscall.SIGKILL)
 }
 
 /*
@@ -179,17 +180,16 @@ func (s *Session) Terminate() *Session {
 }
 
 /*
-Terminate sends the running command the passed in signal.  It does not wait for the process to exit.
+Signal sends the running command the passed in signal.  It does not wait for the process to exit.
 
 If the command has already exited, Signal returns silently.
 
 The session is returned to enable chaining.
 */
 func (s *Session) Signal(signal os.Signal) *Session {
-	if s.ExitCode() != -1 {
-		return s
+	if s.processIsAlive() {
+		s.Command.Process.Signal(signal)
 	}
-	s.Command.Process.Signal(signal)
 	return s
 }
 
@@ -212,3 +212,95 @@ func (s *Session) monitorForExit(exited chan<- struct{}) {
 
 	close(exited)
 }
+
+func (s *Session) processIsAlive() bool {
+	return s.ExitCode() == -1 && s.Command.Process != nil
+}
+
+var trackedSessions = []*Session{}
+var trackedSessionsMutex = &sync.Mutex{}
+
+/*
+Kill sends a SIGKILL signal to all the processes started by Run, and waits for them to exit.
+The timeout specified is applied to each process killed.
+
+If any of the processes already exited, KillAndWait returns silently.
+*/
+func KillAndWait(timeout ...interface{}) {
+	trackedSessionsMutex.Lock()
+	defer trackedSessionsMutex.Unlock()
+	for _, session := range trackedSessions {
+		session.Kill().Wait(timeout...)
+	}
+	trackedSessions = []*Session{}
+}
+
+/*
+Kill sends a SIGTERM signal to all the processes started by Run, and waits for them to exit.
+The timeout specified is applied to each process killed.
+
+If any of the processes already exited, TerminateAndWait returns silently.
+*/
+func TerminateAndWait(timeout ...interface{}) {
+	trackedSessionsMutex.Lock()
+	defer trackedSessionsMutex.Unlock()
+	for _, session := range trackedSessions {
+		session.Terminate().Wait(timeout...)
+	}
+}
+
+/*
+Kill sends a SIGKILL signal to all the processes started by Run.
+It does not wait for the processes to exit.
+
+If any of the processes already exited, Kill returns silently.
+*/
+func Kill() {
+	trackedSessionsMutex.Lock()
+	defer trackedSessionsMutex.Unlock()
+	for _, session := range trackedSessions {
+		session.Kill()
+	}
+}
+
+/*
+Terminate sends a SIGTERM signal to all the processes started by Run.
+It does not wait for the processes to exit.
+
+If any of the processes already exited, Terminate returns silently.
+*/
+func Terminate() {
+	trackedSessionsMutex.Lock()
+	defer trackedSessionsMutex.Unlock()
+	for _, session := range trackedSessions {
+		session.Terminate()
+	}
+}
+
+/*
+Signal sends the passed in signal to all the processes started by Run.
+It does not wait for the processes to exit.
+
+If any of the processes already exited, Signal returns silently.
+*/
+func Signal(signal os.Signal) {
+	trackedSessionsMutex.Lock()
+	defer trackedSessionsMutex.Unlock()
+	for _, session := range trackedSessions {
+		session.Signal(signal)
+	}
+}
+
+/*
+Interrupt sends the SIGINT signal to all the processes started by Run.
+It does not wait for the processes to exit.
+
+If any of the processes already exited, Interrupt returns silently.
+*/
+func Interrupt() {
+	trackedSessionsMutex.Lock()
+	defer trackedSessionsMutex.Unlock()
+	for _, session := range trackedSessions {
+		session.Interrupt()
+	}
+}