func TestTaskZombie(t *testing.T) {
image, err := chrootly.NewImageFromLocal("test_image.tar")
if err != nil {
t.Fatal("Could not create image: ", err)
}
task := chrootly.NewTask("sleep", []string{"100"}, image)
task.SetStdout(ioutil.Discard)
if err := task.Start(); err != nil {
t.Fatal("Could not start task: ", err)
}
assert.True(t, task.Alive())
assert.False(t, task.Zombie())
if err := task.Kill(); err != nil {
t.Fatal("Could not kill task: ", err)
}
// Give the system a beat to kill the process
time.Sleep(200 * time.Millisecond)
assert.True(t, task.Alive())
assert.True(t, task.Zombie())
if err := task.Wait(); err != nil {
t.Fatal("Could not wait task: ", err)
}
assert.False(t, task.Alive())
assert.False(t, task.Zombie())
}
func TestKillTask(t *testing.T) {
// https://code.google.com/p/go/issues/detail?id=7938
image, err := chrootly.NewImageFromLocal("test_image.tar")
if err != nil {
t.Fatal("Could not create image: ", err)
}
task := chrootly.NewTask("sleep", []string{"100"}, image)
task.SetStdout(ioutil.Discard)
if err := task.Start(); err != nil {
t.Fatal("Could not start task: ", err)
}
if err := task.Kill(); err != nil {
t.Fatal("Could not kill task: ", err)
}
if err := task.Wait(); err != nil {
t.Fatal("Could not wait task: ", err)
}
signaled, err := task.Signaled()
if err != nil {
t.Fatal("Could not get signaled: ", err)
}
assert.True(t, signaled)
}
func TestSignalWithSigterm(t *testing.T) {
image, err := chrootly.NewImageFromLocal("test_image.tar")
if err != nil {
t.Fatal("Could not create image: ", err)
}
task := chrootly.NewTask("sleep", []string{"10"}, image)
task.SetStdout(ioutil.Discard)
if err := task.Start(); err != nil {
t.Fatal("Could not start task: ", err)
}
if err := task.Command.Process.Signal(syscall.SIGTERM); err != nil {
t.Fatal("Could not signal process: ", err)
}
if err := task.Wait(); err != nil {
t.Fatal("Could not wait task: ", err)
}
signaled, err := task.Signaled()
if err != nil {
t.Fatal("Could not get signaled of task: ", err)
}
assert.True(t, signaled)
signal, err := task.Signal()
if err != nil {
t.Fatal("Could not get signal of task: ", err)
}
assert.Equal(t, syscall.SIGTERM, signal)
}
func TestTaskWaitStatusNoWait(t *testing.T) {
image, err := chrootly.NewImageFromLocal("test_image.tar")
if err != nil {
t.Fatal("Could not create image: ", err)
}
task := chrootly.NewTask("uname", []string{}, image)
waitstatus, err := task.WaitStatus()
assert.Nil(t, waitstatus)
assert.NotNil(t, err)
}
func TestErrorProcessStateNoWait(t *testing.T) {
image, err := chrootly.NewImageFromLocal("test_image.tar")
if err != nil {
t.Fatal("Could not create image: ", err)
}
task := chrootly.NewTask("uname", []string{}, image)
task.SetStdout(ioutil.Discard)
processstate, err := task.ProcessState()
assert.Nil(t, processstate)
assert.NotNil(t, err)
}
func TestTaskWaitStatusSignaled(t *testing.T) {
image, err := chrootly.NewImageFromLocal("test_image.tar")
if err != nil {
t.Fatal("Could not create image: ", err)
}
task := chrootly.NewTask("uname", []string{}, image)
task.SetStdout(ioutil.Discard)
if err := task.Start(); err != nil {
t.Fatal("Could not start task: ", err)
}
if err := task.Wait(); err != nil {
t.Fatal("Could not wait task: ", err)
}
waitStatus, _ := task.WaitStatus()
assert.False(t, waitStatus.Signaled())
}
func TestTaskProcessStateNoSuccess(t *testing.T) {
image, err := chrootly.NewImageFromLocal("test_image.tar")
if err != nil {
t.Fatal("Could not create image: ", err)
}
task := chrootly.NewTask("ls", []string{"/notarealdir"}, image)
task.SetStderr(ioutil.Discard)
if err := task.Start(); err != nil {
t.Fatal("Could not start task: ", err)
}
if err := task.Wait(); err == nil {
t.Fatal("Task waited successfully: ", err)
}
processState, _ := task.ProcessState()
assert.False(t, processState.Success())
}
func TestTaskProcessState(t *testing.T) {
image, err := chrootly.NewImageFromLocal("test_image.tar")
if err != nil {
t.Fatal("Could not create image: ", err)
}
task := chrootly.NewTask("uname", []string{}, image)
task.SetStdout(ioutil.Discard)
if err := task.Start(); err != nil {
t.Fatal("Could not start task: ", err)
}
if err := task.Wait(); err != nil {
t.Fatal("Could not wait task: ", err)
}
processState, _ := task.ProcessState()
assert.True(t, processState.Success())
}
func TestTaskAliveWithWait(t *testing.T) {
image, err := chrootly.NewImageFromLocal("test_image.tar")
if err != nil {
t.Fatal("Could not create image: ", err)
}
task := chrootly.NewTask("sleep", []string{"3"}, image)
task.SetStdout(ioutil.Discard)
if err := task.Start(); err != nil {
t.Fatal("Could not start task: ", err)
}
assert.True(t, task.Alive())
if err := task.Wait(); err != nil {
t.Fatal("Could not wait task: ", err)
}
assert.False(t, task.Alive())
}
func TestTask(t *testing.T) {
image, err := chrootly.NewImageFromLocal("test_image.tar")
if err != nil {
t.Fatal("Could not create image: ", err)
}
task := chrootly.NewTask("ls", []string{"-a", ".dockerenv"}, image)
output := bytes.NewBuffer(nil)
task.SetStdout(output)
if err := task.Start(); err != nil {
t.Fatal("Could not start task: ", err)
}
if err := task.Wait(); err != nil {
t.Fatal("Could not wait task: ", err)
}
stdoutLine, err := output.ReadString('\n')
if err != nil {
t.Fatal("Could not read output: ", err)
}
assert.Equal(t, ".dockerenv\n", stdoutLine)
}
func TestNewImageFromLocalErrorWithCrapPath(t *testing.T) {
_, err := chrootly.NewImageFromLocal("/tmp/jabberwocky")
assert.NotNil(t, err)
}
func TestNewImageFromLocalErrorWithCrapName(t *testing.T) {
_, err := chrootly.NewImageFromLocal("lknslnkef")
assert.NotNil(t, err)
}
func TestNewImageFromLocalErrorWithCrapFile(t *testing.T) {
_, err := chrootly.NewImageFromLocal("crap_image.tar")
assert.NotNil(t, err)
}
func TestNewImageFromLocal(t *testing.T) {
image, _ := chrootly.NewImageFromLocal("test_image.tar")
assert.NotNil(t, image)
assertImageSetup(t, image.Directory)
}