151 lines
3.4 KiB
Go
151 lines
3.4 KiB
Go
package engine
|
|
|
|
import (
|
|
"bytes"
|
|
"strings"
|
|
"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")
|
|
}
|
|
// Register is global so let's cleanup to avoid conflicts
|
|
defer unregister("dummy1")
|
|
|
|
eng := New()
|
|
|
|
//Should fail because global 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")
|
|
}
|
|
defer unregister("dummy2")
|
|
}
|
|
|
|
func TestJob(t *testing.T) {
|
|
eng := New()
|
|
job1 := eng.Job("dummy1", "--level=awesome")
|
|
|
|
if job1.handler != nil {
|
|
t.Fatalf("job1.handler should be empty")
|
|
}
|
|
|
|
h := func(j *Job) Status {
|
|
j.Printf("%s\n", j.Name)
|
|
return 42
|
|
}
|
|
|
|
eng.Register("dummy2", h)
|
|
defer unregister("dummy2")
|
|
job2 := eng.Job("dummy2", "--level=awesome")
|
|
|
|
if job2.handler == nil {
|
|
t.Fatalf("job2.handler shouldn't be nil")
|
|
}
|
|
|
|
if job2.handler(job2) != 42 {
|
|
t.Fatalf("handler dummy2 was not found in job2")
|
|
}
|
|
}
|
|
|
|
func TestEngineCommands(t *testing.T) {
|
|
eng := New()
|
|
handler := func(job *Job) Status { return StatusOK }
|
|
eng.Register("foo", handler)
|
|
eng.Register("bar", handler)
|
|
eng.Register("echo", handler)
|
|
eng.Register("die", handler)
|
|
var output bytes.Buffer
|
|
commands := eng.Job("commands")
|
|
commands.Stdout.Add(&output)
|
|
commands.Run()
|
|
expected := "bar\ncommands\ndie\necho\nfoo\n"
|
|
if result := output.String(); result != expected {
|
|
t.Fatalf("Unexpected output:\nExpected = %v\nResult = %v\n", expected, result)
|
|
}
|
|
}
|
|
|
|
func TestEngineString(t *testing.T) {
|
|
eng1 := New()
|
|
eng2 := New()
|
|
s1 := eng1.String()
|
|
s2 := eng2.String()
|
|
if eng1 == eng2 {
|
|
t.Fatalf("Different engines should have different names (%v == %v)", s1, s2)
|
|
}
|
|
}
|
|
|
|
func TestEngineLogf(t *testing.T) {
|
|
eng := New()
|
|
input := "Test log line"
|
|
if n, err := eng.Logf("%s\n", input); err != nil {
|
|
t.Fatal(err)
|
|
} else if n < len(input) {
|
|
t.Fatalf("Test: Logf() should print at least as much as the input\ninput=%d\nprinted=%d", len(input), n)
|
|
}
|
|
}
|
|
|
|
func TestParseJob(t *testing.T) {
|
|
eng := New()
|
|
// Verify that the resulting job calls to the right place
|
|
var called bool
|
|
eng.Register("echo", func(job *Job) Status {
|
|
called = true
|
|
return StatusOK
|
|
})
|
|
input := "echo DEBUG=1 hello world VERBOSITY=42"
|
|
job, err := eng.ParseJob(input)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if job.Name != "echo" {
|
|
t.Fatalf("Invalid job name: %v", job.Name)
|
|
}
|
|
if strings.Join(job.Args, ":::") != "hello:::world" {
|
|
t.Fatalf("Invalid job args: %v", job.Args)
|
|
}
|
|
if job.Env().Get("DEBUG") != "1" {
|
|
t.Fatalf("Invalid job env: %v", job.Env)
|
|
}
|
|
if job.Env().Get("VERBOSITY") != "42" {
|
|
t.Fatalf("Invalid job env: %v", job.Env)
|
|
}
|
|
if len(job.Env().Map()) != 2 {
|
|
t.Fatalf("Invalid job env: %v", job.Env)
|
|
}
|
|
if err := job.Run(); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if !called {
|
|
t.Fatalf("Job was not called")
|
|
}
|
|
}
|
|
|
|
func TestCatchallEmptyName(t *testing.T) {
|
|
eng := New()
|
|
var called bool
|
|
eng.RegisterCatchall(func(job *Job) Status {
|
|
called = true
|
|
return StatusOK
|
|
})
|
|
err := eng.Job("").Run()
|
|
if err == nil {
|
|
t.Fatalf("Engine.Job(\"\").Run() should return an error")
|
|
}
|
|
if called {
|
|
t.Fatalf("Engine.Job(\"\").Run() should return an error")
|
|
}
|
|
}
|