Add unit tests for integration cli utils function

- utils_test.go and docker_utils_test.go
- Moved docker related function to docker_utils.go
- add a test for integration-cli/checker

Signed-off-by: Vincent Demeester <vincent@sbr.pm>

integration/checker/checker.go

@@ -0,0 +1,59 @@
+// Package checker provide Docker specific implementations of the go-check.Checker interface.
+package checker
+
+import (
+	"fmt"
+	"strings"
+
+	"github.com/go-check/check"
+)
+
+// As a commodity, we bring all check.Checker variables into the current namespace to avoid having
+// to think about check.X versus checker.X.
+var (
+	DeepEquals   = check.DeepEquals
+	Equals       = check.Equals
+	ErrorMatches = check.ErrorMatches
+	FitsTypeOf   = check.FitsTypeOf
+	HasLen       = check.HasLen
+	Implements   = check.Implements
+	IsNil        = check.IsNil
+	Matches      = check.Matches
+	Not          = check.Not
+	NotNil       = check.NotNil
+	PanicMatches = check.PanicMatches
+	Panics       = check.Panics
+)
+
+// Contains checker verifies that string value contains a substring.
+var Contains check.Checker = &containsChecker{
+	&check.CheckerInfo{
+		Name:   "Contains",
+		Params: []string{"value", "substring"},
+	},
+}
+
+type containsChecker struct {
+	*check.CheckerInfo
+}
+
+func (checker *containsChecker) Check(params []interface{}, names []string) (bool, string) {
+	return contains(params[0], params[1])
+}
+
+func contains(value, substring interface{}) (bool, string) {
+	substringStr, ok := substring.(string)
+	if !ok {
+		return false, "Substring must be a string"
+	}
+	valueStr, valueIsStr := value.(string)
+	if !valueIsStr {
+		if valueWithStr, valueHasStr := value.(fmt.Stringer); valueHasStr {
+			valueStr, valueIsStr = valueWithStr.String(), true
+		}
+	}
+	if valueIsStr {
+		return strings.Contains(valueStr, substringStr), ""
+	}
+	return false, "Obtained value is not a string and has no .String()"
+}

integration/checker/checker_test.go

@@ -0,0 +1,57 @@
+package checker
+
+import (
+	"reflect"
+	"testing"
+
+	"github.com/go-check/check"
+)
+
+func Test(t *testing.T) {
+	check.TestingT(t)
+}
+
+func init() {
+	check.Suite(&CheckersS{})
+}
+
+type CheckersS struct{}
+
+var _ = check.Suite(&CheckersS{})
+
+func testInfo(c *check.C, checker check.Checker, name string, paramNames []string) {
+	info := checker.Info()
+	if info.Name != name {
+		c.Fatalf("Got name %s, expected %s", info.Name, name)
+	}
+	if !reflect.DeepEqual(info.Params, paramNames) {
+		c.Fatalf("Got param names %#v, expected %#v", info.Params, paramNames)
+	}
+}
+
+func testCheck(c *check.C, checker check.Checker, expectedResult bool, expectedError string, params ...interface{}) ([]interface{}, []string) {
+	info := checker.Info()
+	if len(params) != len(info.Params) {
+		c.Fatalf("unexpected param count in test; expected %d got %d", len(info.Params), len(params))
+	}
+	names := append([]string{}, info.Params...)
+	result, error := checker.Check(params, names)
+	if result != expectedResult || error != expectedError {
+		c.Fatalf("%s.Check(%#v) returned (%#v, %#v) rather than (%#v, %#v)",
+			info.Name, params, result, error, expectedResult, expectedError)
+	}
+	return params, names
+}
+
+func (s *CheckersS) TestContains(c *check.C) {
+	testInfo(c, Contains, "Contains", []string{"value", "substring"})
+
+	testCheck(c, Contains, true, "", "abcd", "bc")
+	testCheck(c, Contains, false, "", "abcd", "efg")
+	testCheck(c, Contains, false, "", "", "bc")
+	testCheck(c, Contains, true, "", "abcd", "")
+	testCheck(c, Contains, true, "", "", "")
+
+	testCheck(c, Contains, false, "Obtained value is not a string and has no .String()", 12, "1")
+	testCheck(c, Contains, false, "Substring must be a string", "", 1)
+}