ref(_tests): implementing cmd, replacing execute implementation with cmd

also spreading usage of cmd elsewhere in the test suite

Author: arschles

_tests/apps_test.go

@@ -14,30 +14,30 @@ var _ = Describe("Apps", func() {
 		})
 
 		It("can't get app info", func() {
-			Expect(execute("deis info -a %s", app1Name)).To(SucceedWithOutput(ContainSubstring("NOT FOUND")))
+			Expect(execute("deis info -a %s", app1Name)).To(BeASuccessfulCmdWithOutput(ContainSubstring("NOT FOUND")))
 		})
 
 		It("can't get app logs", func() {
-			out := execute("deis logs -a %s", app1Name)
-			Expect(out.err).To(HaveOccurred())
-			Expect(out.str).To(ContainSubstring("NOT FOUND"))
+			out, err := execute("deis logs -a %s", app1Name)
+			Expect(err).To(HaveOccurred())
+			Expect(out).To(ContainSubstring("NOT FOUND"))
 		})
 
 		// TODO: this currently returns "Error: json: cannot unmarshal object into Go value of type []interface {}"
 		XIt("can't run a command in the app environment", func() {
-			out := execute("deis apps:run echo Hello, 世界")
-			Expect(out.err).To(HaveOccurred())
-			Expect(out.str).To(ContainSubstring("NOT FOUND"))
+			out, err := execute("deis apps:run echo Hello, 世界")
+			Expect(err).To(HaveOccurred())
+			Expect(out).To(ContainSubstring("NOT FOUND"))
 		})
 
 		It("can create an app", func() {
-			Expect(execute("deis apps:create %s", app1Name)).To(SucceedWithOutput(
+			Expect(execute("deis apps:create %s", app1Name)).To(BeASuccessfulCmdWithOutput(
 				ContainSubstring("Creating Application... done, created %s", app1Name),
 				ContainSubstring("Git remote deis added"),
 				ContainSubstring("remote available at "),
 			))
 
-			Expect(execute("deis apps:destroy --confirm=%s", app1Name)).To(SucceedWithOutput(
+			Expect(execute("deis apps:destroy --confirm=%s", app1Name)).To(BeASuccessfulCmdWithOutput(
 				ContainSubstring("Destroying %s...", app1Name),
 				ContainSubstring("done in "),
 				ContainSubstring("Git remote deis removed"),

_tests/auth_test.go

@@ -12,7 +12,7 @@ var _ = Describe("Auth", func() {
 		})
 
 		It("won't print the current user", func() {
-			Expect(execute("deis auth:whoami")).To(BeASuccessfulCommandWithOutputMatching(
+			Expect(execute("deis auth:whoami")).To(BeASuccessfulCmdWithOutput(
 				ContainSubstring("Not logged in."),
 				ContainSubstring(testUser),
 			))
@@ -30,19 +30,19 @@ var _ = Describe("Auth", func() {
 
 		It("won't register twice", func() {
 			cmd := "deis register %s --username=%s --password=%s --email=%s"
-			out := execute(cmd, url, testUser, testPassword, testEmail)
-			Expect(out.err).To(HaveOccurred())
-			Expect(out.str).To(ContainSubstring("Registration failed"))
+			out, err := execute(cmd, url, testUser, testPassword, testEmail)
+			Expect(err).To(HaveOccurred())
+			Expect(out).To(ContainSubstring("Registration failed"))
 		})
 
 		It("prints the current user", func() {
-			Expect(execute("deis auth:whoami")).To(SucceedWithOutput(
+			Expect(execute("deis auth:whoami")).To(BeASuccessfulCmdWithOutput(
 				ContainSubstring("You are %s", testUser),
 			))
 		})
 
 		It("regenerates the token for the current user", func() {
-			Expect(execute("deis auth:regenerate")).To(SucceedWithOutput(
+			Expect(execute("deis auth:regenerate")).To(BeASuccessfulCmdWithOutput(
 				ContainSubstring("Token Regenerated"),
 			))
 		})

_tests/cmd_test.go

@@ -4,40 +4,54 @@ import (
 	"bytes"
 	"errors"
 	"fmt"
+	"github.com/onsi/gomega"
 	"github.com/onsi/gomega/types"
+	// "io"
+	"os"
 	"os/exec"
 	"strings"
 )
 
 // cmdOut is the output of a command. it's used by cmdMatcher to match on
 type cmdOut struct {
-	args []string
-	str  string
-	err  error
+	args   []string
+	stdout string
+	stderr string
+	err    error
 }
 
-// execute executes the command generated by fmt.Sprintf(cmdLine, args...) and returns its output as a cmdOut structure.
-// this structure can then be matched upon using the SucceedWithOutput matcher below
-func execute(cmdLine string, args ...interface{}) *cmdOut {
+func (c *cmdOut) String() string {
+	return strings.Join(c.args, " ")
+}
+
+func cmd(cmdLine string, args ...interface{}) *cmdOut {
 	var stdout, stderr bytes.Buffer
 	var cmd *exec.Cmd
 	cmd = exec.Command("/bin/sh", "-c", fmt.Sprintf(cmdLine, args...))
-	cmd.Stdout, cmd.Stderr = &stdout, &stderr
+	cmd.Stdout = &stdout
+	cmd.Stderr = &stderr
+	cmd.Env = os.Environ()
 	ret := &cmdOut{}
 	ret.args = cmd.Args
-	ret.str = stdout.String()
-	if err := cmd.Run(); err != nil {
-		ret.err = err
-		return ret
-	}
+	ret.err = cmd.Run()
+	ret.stdout = stdout.String()
+	ret.stderr = stderr.String()
 	return ret
 }
 
 var (
 	errExpectedCmdOut = errors.New("cmdMatcher expects a *cmdOut")
-	errFailedCmd      = errors.New("command failed")
 )
 
+func cmdErr(co *cmdOut) error {
+	return fmt.Errorf("COMMAND ERROR\n[%s]\nError: %s\nSTDOUT: %s\nSTDERR: %s",
+		strings.Join(co.args, " "),
+		co.err,
+		co.stdout,
+		co.stderr,
+	)
+}
+
 // Command
 type successfulCmdMatcher struct {
 	// will be filled in when Match is called
@@ -47,10 +61,14 @@ type successfulCmdMatcher struct {
 
 // SucceedWithOutput returns a matcher that will match on a *cmdOut, ensuring that the command returned no error
 // and its output matches all the given matchers
-func SucceedWithOutput(matchers ...types.GomegaMatcher) types.GomegaMatcher {
+func BeASuccessfulCmdWithOutput(matchers ...types.GomegaMatcher) types.GomegaMatcher {
 	return &successfulCmdMatcher{matchers: matchers}
 }
 
+func BeASuccessfulCmd() types.GomegaMatcher {
+	return &successfulCmdMatcher{matchers: nil}
+}
+
 // Match is the interface implementation of github.com/onsi/gomega/types.GomegaMatcher
 func (c *successfulCmdMatcher) Match(actual interface{}) (bool, error) {
 	cmdo, ok := actual.(*cmdOut)
@@ -59,21 +77,17 @@ func (c *successfulCmdMatcher) Match(actual interface{}) (bool, error) {
 	}
 	c.cmdo = cmdo
 	if cmdo.err != nil {
-		return false, errFailedCmd
+		return false, cmdErr(cmdo)
 	}
-	return SatisfyAll(c.matchers...)
+	return gomega.SatisfyAll(c.matchers...).Match(actual)
 }
 
 // FailureMessage is the interface implementation of github.com/onsi/gomega/types.GomegaMatcher
 func (c *successfulCmdMatcher) FailureMessage(actual interface{}) string {
 	if c.cmdo == nil {
 		return "command failed, but wasn't recorded"
 	}
-	return fmt.Sprintf("command %s errored.\noutput:\n%s\nerror:%s\n",
-		strings.Join(c.cmdo.args, " "),
-		c.cmdo.str,
-		c.cmdo.err,
-	)
+	return cmdErr(c.cmdo).Error()
 }
 
 // NegatedFailureMessage is the interface implementation of github.com/onsi/gomega/types.GomegaMatcher
@@ -82,9 +96,5 @@ func (c *successfulCmdMatcher) NegatedFailureMessage(actual interface{}) string
 		return "command failed, but wasn't recorded"
 	}
 
-	return fmt.Sprintf("command %s errored.\noutput:\n%s\nerror:%s\n",
-		strings.Join(c.cmdo.args, " "),
-		c.cmdo.str,
-		c.cmdo.err,
-	)
+	return cmdErr(c.cmdo).Error()
 }

_tests/tests_suite_test.go

@@ -9,11 +9,11 @@ import (
 	"path"
 
 	. "github.com/onsi/ginkgo"
-	. "github.com/onsi/ginkgo/config"
 
 	. "github.com/onsi/gomega"
 
 	"testing"
+	"time"
 )
 
 const (
@@ -52,15 +52,14 @@ var _ = BeforeSuite(func() {
 	// register the test-admin user
 	register(url, testAdminUser, testAdminPassword, testAdminEmail)
 	// verify this user is an admin by running a privileged command
-	_, err = execute("deis users:list")
-	Expect(err).NotTo(HaveOccurred())
+	Expect(cmd("deis users:list")).To(BeASuccessfulCmd())
 
 	// register the test user and add a key
 	register(url, testUser, testPassword, testEmail)
 	createKey("deis-test")
-	output, err := execute("deis keys:add ~/.ssh/deis-test.pub")
-	Expect(err).NotTo(HaveOccurred())
-	Expect(output).To(ContainSubstring("Uploading deis-test.pub to deis... done"))
+	Expect(cmd("deis keys:add ~/.ssh/deis-test.pub")).To(BeASuccessfulCmdWithOutput(
+		ContainSubstring("Uploading deis-test.pub to deis... done"),
+	))
 })
 
 var _ = AfterSuite(func() {
@@ -72,36 +71,39 @@ var _ = AfterSuite(func() {
 })
 
 func register(url, username, password, email string) {
-	cmd := "deis register %s --username=%s --password=%s --email=%s"
-	output, err := execute(cmd, url, username, password, email)
-	Expect(err).NotTo(HaveOccurred())
-	Expect(output).To(SatisfyAll(
+	Expect(cmd("deis register %s --username=%s --password=%s --email=%s", url, username, password, email)).To(BeASuccessfulCmdWithOutput(
 		ContainSubstring("Registered %s", username),
-		ContainSubstring("Logged in as %s", username)))
+		ContainSubstring("Logged in as %s", username),
+	))
 }
 
 func cancel(url, username, password string) {
 	// log in to the account
 	login(url, username, password)
 
 	// cancel the account
-	cmd := "deis auth:cancel --username=%s --password=%s --yes"
-	output, err := execute(cmd, username, password)
-	Expect(err).NotTo(HaveOccurred())
-	Expect(output).To(ContainSubstring("Account cancelled"))
+	Expect(cmd("deis auth:cancel --username=%s --password=%s --yes", username, password)).To(BeASuccessfulCmdWithOutput(
+		ContainSubstring("Account cancelled"),
+	))
 }
 
 func login(url, user, password string) {
-	cmd := "deis login %s --username=%s --password=%s"
-	output, err := execute(cmd, url, user, password)
-	Expect(err).NotTo(HaveOccurred())
-	Expect(output).To(ContainSubstring("Logged in as %s", user))
+	Expect(cmd("deis login %s --username=%s --password=%s", url, user, password)).To(BeASuccessfulCmdWithOutput(
+		ContainSubstring("Logged in as %s", user),
+	))
 }
 
 func logout() {
-	output, err := execute("deis auth:logout")
-	Expect(err).NotTo(HaveOccurred())
-	Expect(output).To(Equal("Logged out\n"))
+	Expect(cmd("deis auth:logout")).To(BeASuccessfulCmdWithOutput(
+		Equal("Logged out\n"),
+	))
+}
+
+// execute executes the command generated by fmt.Sprintf(cmdLine, args...) and returns its output as a cmdOut structure.
+// this structure can then be matched upon using the SucceedWithOutput matcher below
+func execute(cmdLine string, args ...interface{}) (string, error) {
+	c := cmd(cmdLine, args...)
+	return c.stdout, c.err
 }
 
 func createKey(name string) {
@@ -114,13 +116,10 @@ func createKey(name string) {
 	path := path.Join(home, ".ssh", name)
 	// create the key under ~/.ssh/<name> if it doesn't already exist
 	if _, err := os.Stat(path); os.IsNotExist(err) {
-		cmd := "ssh-keygen -q -t rsa -b 4096 -C %s -f %s -N ''"
-		_, err := execute(cmd, name, path)
-		Expect(err).NotTo(HaveOccurred())
+		Expect(cmd("ssh-keygen -q -t rsa -b 4096 -C %s -f %s -N ''", name, path)).To(BeASuccessfulCmd())
 	}
 	// add the key to ssh-agent
-	_, err := execute("eval $(ssh-agent) && ssh-add %s", path)
-	Expect(err).NotTo(HaveOccurred())
+	Expect(cmd("eval $(ssh-agent) && ssh-add %s", path)).To(BeASuccessfulCmd())
 }
 
 func getController() string {