new file mode 100644

@@ -0,0 +1,55 @@

+package engine

+

+import (

+	"testing"

+)

+

+func TestRegister(t *testing.T) {

+	if err := Register("dummy1", nil); err != nil {

+		t.Fatal(err)

+	}

+

+	if err := Register("dummy1", nil); err == nil {

+		t.Fatalf("Expecting error, got none")

+	}

+

+	eng := newTestEngine(t)

+

+	//Should fail because globan handlers are copied

+	//at the engine creation

+	if err := eng.Register("dummy1", nil); err == nil {

+		t.Fatalf("Expecting error, got none")

+	}

+

+	if err := eng.Register("dummy2", nil); err != nil {

+		t.Fatal(err)

+	}

+

+	if err := eng.Register("dummy2", nil); err == nil {

+		t.Fatalf("Expecting error, got none")

+	}

+}

+

+func TestJob(t *testing.T) {

+	eng := newTestEngine(t)

+	job1 := eng.Job("dummy1", "--level=awesome")

+

+	if job1.handler != nil {

+		t.Fatalf("job1.handler should be empty")

+	}

+

+	h := func(j *Job) string {

+		return j.Name

+	}

+

+	eng.Register("dummy2", h)

+	job2 := eng.Job("dummy2", "--level=awesome")

+

+	if job2.handler == nil {

+		t.Fatalf("job2.handler shouldn't be nil")

+	}

+

+	if job2.handler(job2) != job2.Name {

+		t.Fatalf("handler dummy2 was not found in job2")

+	}

+}

@@ -23,7 +23,101 @@ func TestSetenv(t *testing.T) {

 	if val := job.Getenv("foo"); val != "bar" {

 		t.Fatalf("Getenv returns incorrect value: %s", val)

 	}

+

+	job.Setenv("bar", "")

+	if val := job.Getenv("bar"); val != "" {

+		t.Fatalf("Getenv returns incorrect value: %s", val)

+	}

 	if val := job.Getenv("nonexistent"); val != "" {

 		t.Fatalf("Getenv returns incorrect value: %s", val)

 	}

 }

+

+func TestSetenvBool(t *testing.T) {

+	job := mkJob(t, "dummy")

+	job.SetenvBool("foo", true)

+	if val := job.GetenvBool("foo"); !val {

+		t.Fatalf("GetenvBool returns incorrect value: %b", val)

+	}

+

+	job.SetenvBool("bar", false)

+	if val := job.GetenvBool("bar"); val {

+		t.Fatalf("GetenvBool returns incorrect value: %b", val)

+	}

+

+	if val := job.GetenvBool("nonexistent"); val {

+		t.Fatalf("GetenvBool returns incorrect value: %b", val)

+	}

+}

+

+func TestSetenvInt(t *testing.T) {

+	job := mkJob(t, "dummy")

+

+	job.SetenvInt("foo", -42)

+	if val := job.GetenvInt("foo"); val != -42 {

+		t.Fatalf("GetenvInt returns incorrect value: %d", val)

+	}

+

+	job.SetenvInt("bar", 42)

+	if val := job.GetenvInt("bar"); val != 42 {

+		t.Fatalf("GetenvInt returns incorrect value: %d", val)

+	}

+	if val := job.GetenvInt("nonexistent"); val != -1 {

+		t.Fatalf("GetenvInt returns incorrect value: %d", val)

+	}

+}

+

+func TestSetenvList(t *testing.T) {

+	job := mkJob(t, "dummy")

+

+	job.SetenvList("foo", []string{"bar"})

+	if val := job.GetenvList("foo"); len(val) != 1 || val[0] != "bar" {

+		t.Fatalf("GetenvList returns incorrect value: %v", val)

+	}

+

+	job.SetenvList("bar", nil)

+	if val := job.GetenvList("bar"); val != nil {

+		t.Fatalf("GetenvList returns incorrect value: %v", val)

+	}

+	if val := job.GetenvList("nonexistent"); val != nil {

+		t.Fatalf("GetenvList returns incorrect value: %v", val)

+	}

+}

+

+func TestImportEnv(t *testing.T) {

+	type dummy struct {

+		DummyInt         int

+		DummyStringArray []string

+	}

+

+	job := mkJob(t, "dummy")

+	if err := job.ImportEnv(&dummy{42, []string{"foo", "bar"}}); err != nil {

+		t.Fatal(err)

+	}

+

+	dmy := dummy{}

+	if err := job.ExportEnv(&dmy); err != nil {

+		t.Fatal(err)

+	}

+

+	if dmy.DummyInt != 42 {

+		t.Fatalf("Expected 42, got %d", dmy.DummyInt)

+	}

+

+	if len(dmy.DummyStringArray) != 2 || dmy.DummyStringArray[0] != "foo" || dmy.DummyStringArray[1] != "bar" {

+		t.Fatalf("Expected {foo, bar}, got %v", dmy.DummyStringArray)

+	}

+

+}

+

+func TestEnviron(t *testing.T) {

+	job := mkJob(t, "dummy")

+	job.Setenv("foo", "bar")

+	val, exists := job.Environ()["foo"]

+	if !exists {

+		t.Fatalf("foo not found in the environ")

+	}

+	if val != "bar" {

+		t.Fatalf("bar not found in the environ")

+	}

+}

new file mode 100644

@@ -0,0 +1,38 @@

+package engine

+

+import (

+	"fmt"

+	"github.com/dotcloud/docker/utils"

+	"io/ioutil"

+	"runtime"

+	"strings"

+	"testing"

+)

+

+var globalTestID string

+

+func newTestEngine(t *testing.T) *Engine {

+	// Use the caller function name as a prefix.

+	// This helps trace temp directories back to their test.

+	pc, _, _, _ := runtime.Caller(1)

+	callerLongName := runtime.FuncForPC(pc).Name()

+	parts := strings.Split(callerLongName, ".")

+	callerShortName := parts[len(parts)-1]

+	if globalTestID == "" {

+		globalTestID = utils.RandomString()[:4]

+	}

+	prefix := fmt.Sprintf("docker-test%s-%s-", globalTestID, callerShortName)

+	root, err := ioutil.TempDir("", prefix)

+	if err != nil {

+		t.Fatal(err)

+	}

+	eng, err := New(root)

+	if err != nil {

+		t.Fatal(err)

+	}

+	return eng

+}

+

+func mkJob(t *testing.T, name string, args ...string) *Job {

+	return newTestEngine(t).Job(name, args...)

+}

@@ -205,8 +205,12 @@ func (job *Job) SetenvInt(key string, value int64) {

 	job.Setenv(key, fmt.Sprintf("%d", value))

 }

+// Returns nil if key not found

 func (job *Job) GetenvList(key string) []string {

 	sval := job.Getenv(key)

+	if sval == "" {

+		return nil

+	}

 	l := make([]string, 0, 1)

 	if err := json.Unmarshal([]byte(sval), &l); err != nil {

 		l = append(l, sval)

@@ -234,7 +238,7 @@ func (job *Job) Setenv(key, value string) {

 // DecodeEnv decodes `src` as a json dictionary, and adds

 // each decoded key-value pair to the environment.

 //

-// If `text` cannot be decoded as a json dictionary, an error

+// If `src` cannot be decoded as a json dictionary, an error

 // is returned.

 func (job *Job) DecodeEnv(src io.Reader) error {

 	m := make(map[string]interface{})

deleted file mode 100644

@@ -1,42 +0,0 @@

-package engine

-

-import (

-	"fmt"

-	"github.com/dotcloud/docker/utils"

-	"io/ioutil"

-	"runtime"

-	"strings"

-	"testing"

-)

-

-var globalTestID string

-

-func init() {

-	Register("dummy", func(job *Job) string { return "" })

-}

-

-func newTestEngine(t *testing.T) *Engine {

-	// Use the caller function name as a prefix.

-	// This helps trace temp directories back to their test.

-	pc, _, _, _ := runtime.Caller(1)

-	callerLongName := runtime.FuncForPC(pc).Name()

-	parts := strings.Split(callerLongName, ".")

-	callerShortName := parts[len(parts)-1]

-	if globalTestID == "" {

-		globalTestID = utils.RandomString()[:4]

-	}

-	prefix := fmt.Sprintf("docker-test%s-%s-", globalTestID, callerShortName)

-	root, err := ioutil.TempDir("", prefix)

-	if err != nil {

-		t.Fatal(err)

-	}

-	eng, err := New(root)

-	if err != nil {

-		t.Fatal(err)

-	}

-	return eng

-}

-

-func mkJob(t *testing.T, name string, args ...string) *Job {

-	return newTestEngine(t).Job(name, args...)

-}