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

459 lines
10 KiB
Go
Raw Normal View History

2013-05-06 10:59:33 -04:00
package docker
import (
"github.com/dotcloud/docker"
"github.com/dotcloud/docker/utils"
2013-11-08 00:34:54 -05:00
"io/ioutil"
2013-11-13 14:25:55 -05:00
"strings"
2013-05-06 10:59:33 -04:00
"testing"
)
2013-12-11 20:52:41 -05:00
func TestImageTagImageDelete(t *testing.T) {
eng := NewTestEngine(t)
defer mkRuntimeFromEngine(eng, t).Nuke()
2013-05-15 09:11:39 -04:00
srv := mkServerFromEngine(eng, t)
2013-05-15 09:11:39 -04:00
initialImages, err := srv.Images(false, "")
if err != nil {
t.Fatal(err)
}
2013-12-11 20:52:41 -05:00
if err := eng.Job("tag", unitTestImageName, "utest", "tag1").Run(); err != nil {
2013-05-15 09:11:39 -04:00
t.Fatal(err)
}
2013-07-31 03:56:53 -04:00
2013-12-11 20:52:41 -05:00
if err := eng.Job("tag", unitTestImageName, "utest/docker", "tag2").Run(); err != nil {
2013-05-15 09:11:39 -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-05-15 09:11:39 -04:00
t.Fatal(err)
}
images, err := srv.Images(false, "")
if err != nil {
t.Fatal(err)
}
2013-10-13 09:42:01 -04:00
if len(images[0].RepoTags) != len(initialImages[0].RepoTags)+3 {
t.Errorf("Expected %d images, %d found", len(initialImages)+3, len(images))
2013-05-15 09:11:39 -04:00
}
if _, err := srv.ImageDelete("utest/docker:tag2", true); err != nil {
2013-05-15 09:11:39 -04:00
t.Fatal(err)
}
images, err = srv.Images(false, "")
if err != nil {
t.Fatal(err)
}
2013-10-13 09:42:01 -04:00
if len(images[0].RepoTags) != len(initialImages[0].RepoTags)+2 {
2013-07-02 17:47:43 -04:00
t.Errorf("Expected %d images, %d found", len(initialImages)+2, len(images))
2013-05-15 09:11:39 -04:00
}
2013-07-31 03:56:53 -04:00
if _, err := srv.ImageDelete("utest:5000/docker:tag3", true); err != nil {
2013-05-15 09:11:39 -04:00
t.Fatal(err)
}
images, err = srv.Images(false, "")
if err != nil {
t.Fatal(err)
}
2013-10-13 09:42:01 -04:00
if len(images[0].RepoTags) != len(initialImages[0].RepoTags)+1 {
2013-07-02 17:47:43 -04:00
t.Errorf("Expected %d images, %d found", len(initialImages)+1, len(images))
2013-05-15 09:11:39 -04:00
}
if _, err := srv.ImageDelete("utest:tag1", true); err != nil {
2013-05-15 09:11:39 -04:00
t.Fatal(err)
}
images, err = srv.Images(false, "")
if err != nil {
t.Fatal(err)
}
if len(images) != len(initialImages) {
2013-07-02 17:47:43 -04:00
t.Errorf("Expected %d image, %d found", len(initialImages), len(images))
2013-05-15 09:11:39 -04:00
}
}
2013-05-06 10:59:33 -04:00
func TestCreateRm(t *testing.T) {
eng := NewTestEngine(t)
srv := mkServerFromEngine(eng, t)
defer mkRuntimeFromEngine(eng, t).Nuke()
2013-05-06 10:59:33 -04:00
config, _, _, err := docker.ParseRun([]string{unitTestImageID, "echo test"}, nil)
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
if c := srv.Containers(true, false, -1, "", ""); len(c) != 1 {
t.Errorf("Expected 1 container, %v found", len(c))
2013-05-06 10:59:33 -04:00
}
if err = srv.ContainerDestroy(id, true, false); err != nil {
2013-05-06 10:59:33 -04:00
t.Fatal(err)
}
if c := srv.Containers(true, false, -1, "", ""); len(c) != 0 {
t.Errorf("Expected 0 container, %v found", len(c))
2013-05-06 10:59:33 -04:00
}
}
2013-10-08 12:35:47 -04:00
func TestCreateRmVolumes(t *testing.T) {
eng := NewTestEngine(t)
srv := mkServerFromEngine(eng, t)
defer mkRuntimeFromEngine(eng, t).Nuke()
2013-10-08 12:35:47 -04:00
config, hostConfig, _, err := docker.ParseRun([]string{"-v", "/srv", unitTestImageID, "echo", "test"}, nil)
2013-10-08 12:35:47 -04:00
if err != nil {
t.Fatal(err)
}
id := createTestContainer(eng, config, t)
2013-10-08 12:35:47 -04:00
if c := srv.Containers(true, false, -1, "", ""); len(c) != 1 {
t.Errorf("Expected 1 container, %v found", len(c))
2013-10-08 12:35:47 -04:00
}
job := eng.Job("start", id)
if err := job.ImportEnv(hostConfig); err != nil {
t.Fatal(err)
}
if err := job.Run(); err != nil {
2013-10-08 12:35:47 -04:00
t.Fatal(err)
}
2013-12-11 18:36:50 -05:00
job = eng.Job("stop", id)
job.SetenvInt("t", 1)
if err := job.Run(); err != nil {
2013-10-08 12:35:47 -04:00
t.Fatal(err)
}
if err = srv.ContainerDestroy(id, true, false); err != nil {
2013-10-08 12:35:47 -04:00
t.Fatal(err)
}
if c := srv.Containers(true, false, -1, "", ""); len(c) != 0 {
t.Errorf("Expected 0 container, %v found", len(c))
2013-10-08 12:35:47 -04:00
}
}
2013-07-25 11:20:56 -04:00
func TestCommit(t *testing.T) {
eng := NewTestEngine(t)
defer mkRuntimeFromEngine(eng, t).Nuke()
2013-07-25 11:20:56 -04:00
config, _, _, err := docker.ParseRun([]string{unitTestImageID, "/bin/cat"}, nil)
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)
}
}
2013-05-06 10:59:33 -04:00
func TestCreateStartRestartStopStartKillRm(t *testing.T) {
eng := NewTestEngine(t)
srv := mkServerFromEngine(eng, t)
defer mkRuntimeFromEngine(eng, t).Nuke()
2013-05-06 10:59:33 -04:00
config, hostConfig, _, err := docker.ParseRun([]string{"-i", unitTestImageID, "/bin/cat"}, nil)
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
if c := srv.Containers(true, false, -1, "", ""); len(c) != 1 {
t.Errorf("Expected 1 container, %v found", len(c))
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)
}
if err := srv.ContainerRestart(id, 15); err != nil {
2013-05-06 10:59:33 -04:00
t.Fatal(err)
}
2013-12-11 18:36:50 -05:00
job = eng.Job("stop", id)
job.SetenvInt("t", 15)
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")
if err := srv.ContainerDestroy(id, true, false); err != nil {
2013-05-06 10:59:33 -04:00
t.Fatal(err)
}
if c := srv.Containers(true, false, -1, "", ""); len(c) != 0 {
t.Errorf("Expected 0 container, %v found", len(c))
2013-05-06 10:59:33 -04:00
}
}
func TestRunWithTooLowMemoryLimit(t *testing.T) {
eng := NewTestEngine(t)
defer mkRuntimeFromEngine(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"})
var id string
job.Stdout.AddString(&id)
if err := job.Run(); err == nil {
t.Errorf("Memory limit is smaller than the allowed limit. Container creation should've failed!")
}
}
2013-07-26 06:01:41 -04:00
func TestRmi(t *testing.T) {
eng := NewTestEngine(t)
srv := mkServerFromEngine(eng, t)
defer mkRuntimeFromEngine(eng, t).Nuke()
2013-07-26 06:01:41 -04:00
initialImages, err := srv.Images(false, "")
if err != nil {
t.Fatal(err)
}
config, hostConfig, _, err := docker.ParseRun([]string{unitTestImageID, "echo", "test"}, nil)
2013-07-26 06:01:41 -04:00
if err != nil {
t.Fatal(err)
}
containerID := createTestContainer(eng, config, t)
2013-07-26 06:01:41 -04:00
//To remove
job := eng.Job("start", containerID)
if err := job.ImportEnv(hostConfig); err != nil {
t.Fatal(err)
}
if err := job.Run(); err != nil {
2013-07-26 06:01:41 -04:00
t.Fatal(err)
}
2013-11-24 20:05:59 -05:00
if err := eng.Job("wait", containerID).Run(); err != nil {
2013-11-12 11:21:02 -05:00
t.Fatal(err)
}
2013-12-13 17:29:27 -05:00
job = eng.Job("commit", containerID)
2013-12-11 20:03:48 -05:00
job.Setenv("repo", "test")
var imageID string
job.Stdout.AddString(&imageID)
if err := job.Run(); err != nil {
2013-07-26 06:01:41 -04:00
t.Fatal(err)
}
2013-12-11 20:52:41 -05:00
if err := eng.Job("tag", imageID, "test", "0.1").Run(); err != nil {
2013-07-26 06:01:41 -04:00
t.Fatal(err)
}
containerID = createTestContainer(eng, config, t)
2013-07-26 06:01:41 -04:00
//To remove
job = eng.Job("start", containerID)
if err := job.ImportEnv(hostConfig); err != nil {
t.Fatal(err)
}
if err := job.Run(); err != nil {
2013-07-26 06:01:41 -04:00
t.Fatal(err)
}
2013-11-24 20:05:59 -05:00
if err := eng.Job("wait", containerID).Run(); err != nil {
2013-11-12 11:21:02 -05:00
t.Fatal(err)
}
2013-12-13 17:29:27 -05:00
job = eng.Job("commit", containerID)
2013-12-11 20:03:48 -05:00
job.Setenv("repo", "test")
if err := job.Run(); err != nil {
2013-07-26 06:01:41 -04:00
t.Fatal(err)
}
images, err := srv.Images(false, "")
if err != nil {
t.Fatal(err)
}
if len(images)-len(initialImages) != 2 {
t.Fatalf("Expected 2 new images, found %d.", len(images)-len(initialImages))
}
_, err = srv.ImageDelete(imageID, true)
if err != nil {
t.Fatal(err)
}
images, err = srv.Images(false, "")
if err != nil {
t.Fatal(err)
}
if len(images)-len(initialImages) != 1 {
t.Fatalf("Expected 1 new image, found %d.", len(images)-len(initialImages))
}
for _, image := range images {
if strings.Contains(unitTestImageID, image.ID) {
continue
}
2013-10-13 09:42:01 -04:00
if image.RepoTags[0] == "<none>:<none>" {
2013-07-26 06:01:41 -04:00
t.Fatalf("Expected tagged image, got untagged one.")
}
}
}
2013-09-06 16:16:10 -04:00
func TestImagesFilter(t *testing.T) {
eng := NewTestEngine(t)
defer nuke(mkRuntimeFromEngine(eng, t))
2013-09-06 16:16:10 -04:00
srv := mkServerFromEngine(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, err := srv.Images(false, "utest*/*")
if err != nil {
t.Fatal(err)
}
2013-10-13 09:42:01 -04:00
if len(images[0].RepoTags) != 2 {
2013-09-06 16:16:10 -04:00
t.Fatal("incorrect number of matches returned")
}
images, err = srv.Images(false, "utest")
if err != nil {
t.Fatal(err)
}
2013-10-13 09:42:01 -04:00
if len(images[0].RepoTags) != 1 {
2013-09-06 16:16:10 -04:00
t.Fatal("incorrect number of matches returned")
}
images, err = srv.Images(false, "utest*")
if err != nil {
t.Fatal(err)
}
2013-10-13 09:42:01 -04:00
if len(images[0].RepoTags) != 1 {
2013-09-06 16:16:10 -04:00
t.Fatal("incorrect number of matches returned")
}
images, err = srv.Images(false, "*5000*/*")
if err != nil {
t.Fatal(err)
}
2013-10-13 09:42:01 -04:00
if len(images[0].RepoTags) != 1 {
2013-09-06 16:16:10 -04:00
t.Fatal("incorrect number of matches returned")
}
}
2013-11-08 00:34:54 -05:00
func TestImageInsert(t *testing.T) {
eng := NewTestEngine(t)
defer mkRuntimeFromEngine(eng, t).Nuke()
srv := mkServerFromEngine(eng, t)
2013-11-08 00:34:54 -05:00
sf := utils.NewStreamFormatter(true)
// bad image name fails
if err := srv.ImageInsert("foo", "https://www.docker.io/static/img/docker-top-logo.png", "/foo", ioutil.Discard, sf); err == nil {
t.Fatal("expected an error and got none")
}
// bad url fails
if err := srv.ImageInsert(unitTestImageID, "http://bad_host_name_that_will_totally_fail.com/", "/foo", ioutil.Discard, sf); err == nil {
2013-11-08 00:34:54 -05:00
t.Fatal("expected an error and got none")
}
// success returns nil
if err := srv.ImageInsert(unitTestImageID, "https://www.docker.io/static/img/docker-top-logo.png", "/foo", ioutil.Discard, sf); err != nil {
2013-11-08 00:34:54 -05:00
t.Fatalf("expected no error, but got %v", err)
}
}
// Regression test for being able to untag an image with an existing
// container
func TestDeleteTagWithExistingContainers(t *testing.T) {
eng := NewTestEngine(t)
defer nuke(mkRuntimeFromEngine(eng, t))
srv := mkServerFromEngine(eng, t)
// Tag the image
if err := eng.Job("tag", unitTestImageID, "utest", "tag1").Run(); err != nil {
t.Fatal(err)
}
// Create a container from the image
config, _, _, err := docker.ParseRun([]string{unitTestImageID, "echo test"}, nil)
if err != nil {
t.Fatal(err)
}
id := createNamedTestContainer(eng, config, t, "testingtags")
if id == "" {
t.Fatal("No id returned")
}
containers := srv.Containers(true, false, -1, "", "")
if len(containers) != 1 {
t.Fatalf("Expected 1 container got %d", len(containers))
}
// Try to remove the tag
imgs, err := srv.ImageDelete("utest:tag1", true)
if err != nil {
t.Fatal(err)
}
if len(imgs) != 1 {
t.Fatalf("Should only have deleted one untag %d", len(imgs))
}
untag := imgs[0]
if untag.Untagged != unitTestImageID {
t.Fatalf("Expected %s got %s", unitTestImageID, untag.Untagged)
}
}