1
0
Fork 0
mirror of https://github.com/moby/moby.git synced 2022-11-09 12:21:53 -05:00
moby--moby/integration/server_test.go

301 lines
7 KiB
Go
Raw Normal View History

2013-05-06 10:59:33 -04:00
package docker
import (
"bytes"
2013-05-06 10:59:33 -04:00
"testing"
"time"
"github.com/docker/docker/builder"
"github.com/docker/docker/engine"
2013-05-06 10:59:33 -04:00
)
func TestCreateNumberHostname(t *testing.T) {
eng := NewTestEngine(t)
defer mkDaemonFromEngine(eng, t).Nuke()
config, _, _, err := parseRun([]string{"-h", "web.0", unitTestImageID, "echo test"})
if err != nil {
t.Fatal(err)
}
createTestContainer(eng, config, t)
}
2013-07-25 11:20:56 -04:00
func TestCommit(t *testing.T) {
eng := NewTestEngine(t)
b := &builder.BuilderJob{Engine: eng}
b.Install()
defer mkDaemonFromEngine(eng, t).Nuke()
2013-07-25 11:20:56 -04:00
config, _, _, err := parseRun([]string{unitTestImageID, "/bin/cat"})
2013-07-25 11:20:56 -04:00
if err != nil {
t.Fatal(err)
}
id := createTestContainer(eng, config, t)
2013-07-25 11:20:56 -04:00
2013-12-13 17:29:27 -05:00
job := eng.Job("commit", id)
2013-12-11 20:03:48 -05:00
job.Setenv("repo", "testrepo")
job.Setenv("tag", "testtag")
job.SetenvJson("config", config)
if err := job.Run(); err != nil {
2013-07-25 11:20:56 -04:00
t.Fatal(err)
}
}
func TestMergeConfigOnCommit(t *testing.T) {
eng := NewTestEngine(t)
b := &builder.BuilderJob{Engine: eng}
b.Install()
runtime := mkDaemonFromEngine(eng, t)
defer runtime.Nuke()
container1, _, _ := mkContainer(runtime, []string{"-e", "FOO=bar", unitTestImageID, "echo test > /tmp/foo"}, t)
defer runtime.Rm(container1)
config, _, _, err := parseRun([]string{container1.ID, "cat /tmp/foo"})
if err != nil {
t.Error(err)
}
job := eng.Job("commit", container1.ID)
job.Setenv("repo", "testrepo")
job.Setenv("tag", "testtag")
job.SetenvJson("config", config)
var outputBuffer = bytes.NewBuffer(nil)
job.Stdout.Add(outputBuffer)
if err := job.Run(); err != nil {
t.Error(err)
}
container2, _, _ := mkContainer(runtime, []string{engine.Tail(outputBuffer, 1)}, t)
defer runtime.Rm(container2)
job = eng.Job("container_inspect", container1.Name)
baseContainer, _ := job.Stdout.AddEnv()
if err := job.Run(); err != nil {
t.Error(err)
}
job = eng.Job("container_inspect", container2.Name)
commitContainer, _ := job.Stdout.AddEnv()
if err := job.Run(); err != nil {
t.Error(err)
}
baseConfig := baseContainer.GetSubEnv("Config")
commitConfig := commitContainer.GetSubEnv("Config")
if commitConfig.Get("Env") != baseConfig.Get("Env") {
t.Fatalf("Env config in committed container should be %v, was %v",
baseConfig.Get("Env"), commitConfig.Get("Env"))
}
if baseConfig.Get("Cmd") != "[\"echo test \\u003e /tmp/foo\"]" {
t.Fatalf("Cmd in base container should be [\"echo test \\u003e /tmp/foo\"], was %s",
baseConfig.Get("Cmd"))
}
if commitConfig.Get("Cmd") != "[\"cat /tmp/foo\"]" {
t.Fatalf("Cmd in committed container should be [\"cat /tmp/foo\"], was %s",
commitConfig.Get("Cmd"))
}
}
func TestRestartKillWait(t *testing.T) {
eng := NewTestEngine(t)
runtime := mkDaemonFromEngine(eng, t)
defer runtime.Nuke()
config, hostConfig, _, err := parseRun([]string{"-i", unitTestImageID, "/bin/cat"})
if err != nil {
t.Fatal(err)
}
id := createTestContainer(eng, config, t)
job := eng.Job("containers")
job.SetenvBool("all", true)
outs, err := job.Stdout.AddListTable()
if err != nil {
t.Fatal(err)
}
if err := job.Run(); err != nil {
t.Fatal(err)
}
if len(outs.Data) != 1 {
t.Errorf("Expected 1 container, %v found", len(outs.Data))
}
job = eng.Job("start", id)
if err := job.ImportEnv(hostConfig); err != nil {
t.Fatal(err)
}
if err := job.Run(); err != nil {
t.Fatal(err)
}
job = eng.Job("kill", id)
if err := job.Run(); err != nil {
t.Fatal(err)
}
eng = newTestEngine(t, false, runtime.Config().Root)
job = eng.Job("containers")
job.SetenvBool("all", true)
outs, err = job.Stdout.AddListTable()
if err != nil {
t.Fatal(err)
}
if err := job.Run(); err != nil {
t.Fatal(err)
}
if len(outs.Data) != 1 {
t.Errorf("Expected 1 container, %v found", len(outs.Data))
}
setTimeout(t, "Waiting on stopped container timedout", 5*time.Second, func() {
job = eng.Job("wait", outs.Data[0].Get("Id"))
if err := job.Run(); err != nil {
t.Fatal(err)
}
})
}
func TestCreateStartRestartStopStartKillRm(t *testing.T) {
eng := NewTestEngine(t)
defer mkDaemonFromEngine(eng, t).Nuke()
2013-05-06 10:59:33 -04:00
config, hostConfig, _, err := parseRun([]string{"-i", unitTestImageID, "/bin/cat"})
2013-05-06 10:59:33 -04:00
if err != nil {
t.Fatal(err)
}
id := createTestContainer(eng, config, t)
2013-05-06 10:59:33 -04:00
job := eng.Job("containers")
job.SetenvBool("all", true)
outs, err := job.Stdout.AddListTable()
if err != nil {
t.Fatal(err)
}
if err := job.Run(); err != nil {
t.Fatal(err)
}
if len(outs.Data) != 1 {
t.Errorf("Expected 1 container, %v found", len(outs.Data))
2013-05-06 10:59:33 -04:00
}
job = eng.Job("start", id)
if err := job.ImportEnv(hostConfig); err != nil {
t.Fatal(err)
}
if err := job.Run(); err != nil {
2013-05-06 10:59:33 -04:00
t.Fatal(err)
}
job = eng.Job("restart", id)
job.SetenvInt("t", 2)
if err := job.Run(); err != nil {
2013-05-06 10:59:33 -04:00
t.Fatal(err)
}
job = eng.Job("stop", id)
job.SetenvInt("t", 2)
2013-12-11 18:36:50 -05:00
if err := job.Run(); err != nil {
2013-05-06 10:59:33 -04:00
t.Fatal(err)
}
job = eng.Job("start", id)
if err := job.ImportEnv(hostConfig); err != nil {
t.Fatal(err)
}
if err := job.Run(); err != nil {
2013-05-06 10:59:33 -04:00
t.Fatal(err)
}
if err := eng.Job("kill", id).Run(); err != nil {
2013-05-06 10:59:33 -04:00
t.Fatal(err)
}
// FIXME: this failed once with a race condition ("Unable to remove filesystem for xxx: directory not empty")
job = eng.Job("rm", id)
job.SetenvBool("removeVolume", true)
if err := job.Run(); err != nil {
2013-05-06 10:59:33 -04:00
t.Fatal(err)
}
job = eng.Job("containers")
job.SetenvBool("all", true)
outs, err = job.Stdout.AddListTable()
if err != nil {
t.Fatal(err)
}
if err := job.Run(); err != nil {
t.Fatal(err)
}
if len(outs.Data) != 0 {
t.Errorf("Expected 0 container, %v found", len(outs.Data))
2013-05-06 10:59:33 -04:00
}
}
func TestRunWithTooLowMemoryLimit(t *testing.T) {
eng := NewTestEngine(t)
defer mkDaemonFromEngine(eng, t).Nuke()
// Try to create a container with a memory limit of 1 byte less than the minimum allowed limit.
job := eng.Job("create")
job.Setenv("Image", unitTestImageID)
job.Setenv("Memory", "524287")
job.Setenv("CpuShares", "1000")
job.SetenvList("Cmd", []string{"/bin/cat"})
if err := job.Run(); err == nil {
t.Errorf("Memory limit is smaller than the allowed limit. Container creation should've failed!")
}
}
2013-09-06 16:16:10 -04:00
func TestImagesFilter(t *testing.T) {
eng := NewTestEngine(t)
defer nuke(mkDaemonFromEngine(eng, t))
2013-09-06 16:16:10 -04:00
2013-12-11 20:52:41 -05:00
if err := eng.Job("tag", unitTestImageName, "utest", "tag1").Run(); err != nil {
2013-09-06 16:16:10 -04:00
t.Fatal(err)
}
2013-12-11 20:52:41 -05:00
if err := eng.Job("tag", unitTestImageName, "utest/docker", "tag2").Run(); err != nil {
2013-09-06 16:16:10 -04:00
t.Fatal(err)
}
2013-12-11 20:52:41 -05:00
if err := eng.Job("tag", unitTestImageName, "utest:5000/docker", "tag3").Run(); err != nil {
2013-09-06 16:16:10 -04:00
t.Fatal(err)
}
images := getImages(eng, t, false, "utest*/*")
2013-09-06 16:16:10 -04:00
if len(images.Data[0].GetList("RepoTags")) != 2 {
2013-09-06 16:16:10 -04:00
t.Fatal("incorrect number of matches returned")
}
images = getImages(eng, t, false, "utest")
2013-09-06 16:16:10 -04:00
if len(images.Data[0].GetList("RepoTags")) != 1 {
2013-09-06 16:16:10 -04:00
t.Fatal("incorrect number of matches returned")
}
images = getImages(eng, t, false, "utest*")
2013-09-06 16:16:10 -04:00
if len(images.Data[0].GetList("RepoTags")) != 1 {
2013-09-06 16:16:10 -04:00
t.Fatal("incorrect number of matches returned")
}
images = getImages(eng, t, false, "*5000*/*")
2013-09-06 16:16:10 -04:00
if len(images.Data[0].GetList("RepoTags")) != 1 {
2013-09-06 16:16:10 -04:00
t.Fatal("incorrect number of matches returned")
}
}