Merge lp:~xavi-garcia-mena/go-unityscopes/utils-command into lp:go-unityscopes/v2

[Xavi Garcia]

Adding the initial utils directory to go-unityscopes.
It includes 2 packages:
* testutils
    With common test utilities
* command
    For executing system commands capturing the output, stderror and exit code.

Adding the initial utils directory to go-unityscopes.
It includes 2 packages:
* testutils
    With common test utilities
* command
    For executing system commands capturing the output, stderror and exit code.

Unmerged revisions

70. By Xavi Garcia on 2015-07-24

Added utils directory with tools for building. Added common test utils package. Added utils command package to run system commands

=== added directory 'utils'
=== added directory 'utils/command'
=== added file 'utils/command/command.go'
--- utils/command/command.go	1970-01-01 00:00:00 +0000
+++ utils/command/command.go	2015-07-24 14:19:30 +0000
@@ -0,0 +1,109 @@
+package command
+
+import (
+	"bytes"
+	"fmt"
+	"os"
+	"os/exec"
+	"strings"
+	"syscall"
+)
+
+// Command represents a command to be executed, checking its exit code for errors
+type Command struct {
+	ExitCode int
+	Cmd      string
+	Output   string
+}
+
+// BuildCommand splits the received string command and returns the first item (command) and the arguments.
+func (c Command) BuildCommand(cmd string) (string, []string) {
+	items := strings.Split(cmd, " ")
+	return items[0], items[1:]
+}
+
+// captureOutput is a helper method to capture stderr and, depending on the give boolean parameter, capures stdout as well
+// Parameters:
+// cmd: the command to capture from
+// captureOutput: if true, captures the stdout, it prints the output to the system stdout otherwise
+// Return: the stderr and stdout buffers created to capture the command output and errors.
+func (c *Command) captureOutput(cmd *exec.Cmd, captureOutput bool) (*bytes.Buffer, *bytes.Buffer) {
+	cmdStdErr := &bytes.Buffer{}
+	cmdStdOut := &bytes.Buffer{}
+	cmd.Stderr = cmdStdErr
+	cmd.Stdin = os.Stdin
+	if captureOutput == true {
+		cmd.Stdout = cmdStdOut
+	} else {
+		cmd.Stdout = os.Stdout
+	}
+	return cmdStdOut, cmdStdErr
+}
+
+// runCommand is the method that runs the command and checks the exit code.
+// Parameters:
+// name: system command to be executed
+// captureOutput: if set to true it captures and stores the output, otherwise it uses os.Stdout
+// arg: arguments to the command to be executed
+//
+// Return:
+// If the exit code matches the expected nil is returned, otherwise it returns an error.
+// If the command itself returns an error (command does not exists in the system or similar)
+// it also returns an error.
+func (c *Command) runCommand(name string, captureOutput bool, arg ...string) error {
+	c.Cmd = fmt.Sprintf("%s %s", name, strings.Join(arg, " "))
+	cmd := exec.Command(name, arg...)
+	cmdStdOut, cmdStdErr := c.captureOutput(cmd, captureOutput)
+	err := cmd.Run()
+	errorMessage := ""
+	c.Output = ""
+	if err != nil {
+		// retrieve exit code and error message
+		if exitError, ok := err.(*exec.ExitError); ok {
+			waitStatus := exitError.Sys().(syscall.WaitStatus)
+			c.ExitCode = waitStatus.ExitStatus()
+			// get the error message from the command stderr
+			errorMessage = fmt.Sprintf("%s", cmdStdErr.Bytes())
+		} else {
+			// the command did not execute properly
+			c.ExitCode = -1
+			return fmt.Errorf("Error running command. %s", err.Error())
+		}
+	} else {
+		c.ExitCode = 0
+	}
+	if captureOutput {
+		c.Output = fmt.Sprintf("%s", cmdStdOut.Bytes())
+	}
+	if c.ExitCode != 0 {
+		return fmt.Errorf("Error exit code %d. Error message: %s", c.ExitCode, errorMessage)
+	} else {
+		return nil
+	}
+}
+
+// Execute runs a system command and checks that its exit code is 0.
+// Parameters:
+// cmd: system command to be executed
+//
+// Return:
+// If the exit code is 0 nil is returned, otherwise it returns an error.
+// If the command itself returns an error (command does not exists in the system or similar)
+// it also returns an error.
+func (c *Command) Execute(cmd string) error {
+	name, arg := c.BuildCommand(cmd)
+	return c.runCommand(name, true, arg...)
+}
+
+// ExecuteWithStdout runs a system command, checks that its exit code is 0, and prints the output of the command to stdout.
+// Parameters:
+// cmd: system command to be executed
+//
+// Return:
+// If the exit code is 0 nil is returned, otherwise it returns an error.
+// If the command itself returns an error (command does not exists in the system or similar)
+// it also returns an error.
+func (c *Command) ExecuteWithStdout(cmd string) error {
+	name, arg := c.BuildCommand(cmd)
+	return c.runCommand(name, false, arg...)
+}
 
=== added file 'utils/command/command_test.go'
--- utils/command/command_test.go	1970-01-01 00:00:00 +0000
+++ utils/command/command_test.go	2015-07-24 14:19:30 +0000
@@ -0,0 +1,144 @@
+package command_test
+
+import (
+	. "gopkg.in/check.v1"
+	"io/ioutil"
+	"launchpad.net/go-unityscopes/v2/utils/command"
+	"launchpad.net/go-unityscopes/v2/utils/testutils"
+	"os"
+	"testing"
+)
+
+const (
+	TEST_DIR = "testDir"
+)
+
+type S struct{}
+
+func init() {
+	Suite(&S{})
+}
+
+func TestAll(t *testing.T) {
+	TestingT(t)
+}
+
+func setupTestDir() error {
+	err := os.RemoveAll(TEST_DIR)
+	if err != nil {
+		return err
+	}
+	err = os.Mkdir(TEST_DIR, 0777)
+	if err != nil {
+		return err
+	}
+	err = ioutil.WriteFile("testDir/test_1.txt", []byte("blah"), 0777)
+	if err != nil {
+		return err
+	}
+	err = ioutil.WriteFile("testDir/test_2.txt", []byte("blah"), 0777)
+	if err != nil {
+		return err
+	}
+	return nil
+}
+
+func tearDownTestDir() error {
+	return os.RemoveAll(TEST_DIR)
+}
+
+func (s *S) TestCommandIsExecutedOk(c *C) {
+	err := setupTestDir()
+	c.Assert(err, IsNil)
+
+	var cmd command.Command
+	err = cmd.Execute("ls ./" + TEST_DIR)
+	c.Check(err, IsNil)
+	c.Check(cmd.Cmd, Equals, "ls ./"+TEST_DIR)
+	c.Check(cmd.ExitCode, Equals, 0)
+	c.Check(cmd.Output, Equals, ""+"test_1.txt\n"+"test_2.txt\n")
+
+	err = tearDownTestDir()
+	c.Check(err, IsNil)
+}
+
+func (s *S) TestCommandIsExecutedOkWithStdOut(c *C) {
+	err := setupTestDir()
+	c.Assert(err, IsNil)
+
+	var capture testutils.CaptureStdOut
+	// capture stdout to instpect that the result of the print method is correct.
+	capture.Capture()
+
+	var cmd command.Command
+	err = cmd.ExecuteWithStdout("ls ./" + TEST_DIR)
+	c.Check(err, IsNil)
+	c.Check(cmd.Cmd, Equals, "ls ./"+TEST_DIR)
+	c.Check(cmd.ExitCode, Equals, 0)
+	c.Check(cmd.Output, Equals, "")
+
+	capture.StopCapture()
+	c.Check(capture.GetCapuredOut(), Equals, ""+"test_1.txt\n"+"test_2.txt\n")
+
+	err = tearDownTestDir()
+	c.Check(err, IsNil)
+}
+
+func (s *S) TestCommandFailedBadParameters(c *C) {
+	var cmd command.Command
+	err := cmd.Execute("ls ./blah")
+	c.Assert(err, Not(Equals), nil)
+	c.Check(cmd.Cmd, Equals, "ls ./blah")
+	c.Check(cmd.ExitCode, Equals, 2)
+	c.Check(err.Error(), Equals, "Error exit code 2. Error message: ls: cannot access ./blah: No such file or directory\n")
+}
+
+func (s *S) TestCommandFailedBadParametersWithStdout(c *C) {
+	var cmd command.Command
+	err := cmd.ExecuteWithStdout("ls ./blah")
+	c.Assert(err, Not(Equals), nil)
+	c.Check(cmd.Cmd, Equals, "ls ./blah")
+	c.Check(cmd.ExitCode, Equals, 2)
+	c.Check(cmd.Output, Equals, "")
+	c.Check(err.Error(), Equals, "Error exit code 2. Error message: ls: cannot access ./blah: No such file or directory\n")
+}
+
+func (s *S) TestCommandFailedCommandDoesNotExist(c *C) {
+	var cmd command.Command
+	err := cmd.Execute("lslslslslsnot-exists ./blah")
+	c.Assert(err, Not(Equals), nil)
+	c.Check(cmd.Cmd, Equals, "lslslslslsnot-exists ./blah")
+	c.Check(cmd.ExitCode, Equals, -1)
+	c.Check(err.Error(), Equals, "Error running command. exec: \"lslslslslsnot-exists\": executable file not found in $PATH")
+}
+
+func (s *S) TestCommandFailedCommandDoesNotExistWithStdOut(c *C) {
+	var cmd command.Command
+	err := cmd.ExecuteWithStdout("lslslslslsnot-exists ./blah")
+	c.Assert(err, Not(Equals), nil)
+	c.Check(cmd.Cmd, Equals, "lslslslslsnot-exists ./blah")
+	c.Check(cmd.ExitCode, Equals, -1)
+	c.Check(cmd.Output, Equals, "")
+	c.Check(err.Error(), Equals, "Error running command. exec: \"lslslslslsnot-exists\": executable file not found in $PATH")
+}
+
+func (s *S) TestSplitCommandOK(c *C) {
+	var cmd command.Command
+	name, args := cmd.BuildCommand("ls -la ./")
+	c.Check(name, Equals, "ls")
+	c.Check(args, DeepEquals, []string{"-la", "./"})
+}
+
+func (s *S) TestSplitCommandNoArgs(c *C) {
+	var cmd command.Command
+	name, args := cmd.BuildCommand("ls")
+	c.Check(name, Equals, "ls")
+	c.Check(args, DeepEquals, []string{})
+}
+
+func (s *S) TestSplitCommandEmpty(c *C) {
+	var cmd command.Command
+	name, args := cmd.BuildCommand("")
+	c.Check(name, Equals, "")
+	c.Check(args, DeepEquals, []string{})
+}
 
=== added directory 'utils/testutils'
=== added file 'utils/testutils/testutils.go'
--- utils/testutils/testutils.go	1970-01-01 00:00:00 +0000
+++ utils/testutils/testutils.go	2015-07-24 14:19:30 +0000
@@ -0,0 +1,34 @@
+package testutils
+
+import (
+	"bytes"
+	"io"
+	"os"
+)
+
+// CaptureStdOut is a struct that holds pointers to stdout and its redirection in order to capture stdout for some time.
+type CaptureStdOut struct {
+	StdOut    *os.File
+	NewOut    *os.File
+	NewReader *os.File
+}
+
+// Capture captures the system stdout and stores it for restoring it in the future.
+func (c *CaptureStdOut) Capture() {
+	c.StdOut = os.Stdout
+	c.NewReader, c.NewOut, _ = os.Pipe()
+	os.Stdout = c.NewOut
+}
+
+// StopCapture restores the system stdout
+func (c *CaptureStdOut) StopCapture() {
+	c.NewOut.Close()
+	os.Stdout = c.StdOut
+}
+
+// GetCapuredOut returns the stdout captured as a string.
+func (c CaptureStdOut) GetCapuredOut() string {
+	var buf bytes.Buffer
+	io.Copy(&buf, c.NewReader)
+	return buf.String()
+}