From 8e5ab5bfca2a7077f4e85096808c8f309cf692df Mon Sep 17 00:00:00 2001 From: Victor Vieux Date: Mon, 18 Nov 2013 17:05:05 -0800 Subject: [PATCH] improve tests on the engine --- engine/engine_test.go | 55 ++++++++++++++++ engine/env_test.go | 94 ++++++++++++++++++++++++++++ engine/{utils.go => helpers_test.go} | 4 -- engine/job.go | 6 +- 4 files changed, 154 insertions(+), 5 deletions(-) create mode 100644 engine/engine_test.go rename engine/{utils.go => helpers_test.go} (92%) diff --git a/engine/engine_test.go b/engine/engine_test.go new file mode 100644 index 0000000000..fdc0b0ec7f --- /dev/null +++ b/engine/engine_test.go @@ -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") + } +} diff --git a/engine/env_test.go b/engine/env_test.go index 3acbddad77..343da31cec 100644 --- a/engine/env_test.go +++ b/engine/env_test.go @@ -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") + } +} diff --git a/engine/utils.go b/engine/helpers_test.go similarity index 92% rename from engine/utils.go rename to engine/helpers_test.go index 33b1269aca..5b1c0baf60 100644 --- a/engine/utils.go +++ b/engine/helpers_test.go @@ -11,10 +11,6 @@ import ( 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. diff --git a/engine/job.go b/engine/job.go index 3ccaa8d1a0..365c94e06b 100644 --- a/engine/job.go +++ b/engine/job.go @@ -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{})