596810d8 |
package docker
import ( |
fb3d60f2 |
"errors" |
6871b9b1 |
"github.com/docker/docker/autogen/dockerversion" |
b3ee9ac7 |
"github.com/docker/docker/daemon/graphdriver"
"github.com/docker/docker/graph"
"github.com/docker/docker/image" |
30d5a42c |
"github.com/docker/docker/pkg/archive" |
7a9c944b |
"github.com/docker/docker/pkg/common" |
b3ee9ac7 |
"github.com/docker/docker/utils" |
fb3d60f2 |
"io" |
596810d8 |
"io/ioutil"
"os"
"path"
"testing" |
fb3d60f2 |
"time" |
596810d8 |
)
func TestMount(t *testing.T) { |
12e99354 |
graph, driver := tempGraph(t) |
596810d8 |
defer os.RemoveAll(graph.Root) |
12e99354 |
defer driver.Cleanup()
|
596810d8 |
archive, err := fakeTar()
if err != nil {
t.Fatal(err)
} |
01b6b2be |
image, err := graph.Create(archive, "", "", "Testing", "", nil, nil) |
596810d8 |
if err != nil {
t.Fatal(err)
}
tmp, err := ioutil.TempDir("", "docker-test-graph-mount-")
if err != nil {
t.Fatal(err)
}
defer os.RemoveAll(tmp)
rootfs := path.Join(tmp, "rootfs")
if err := os.MkdirAll(rootfs, 0700); err != nil {
t.Fatal(err)
}
rw := path.Join(tmp, "rw")
if err := os.MkdirAll(rw, 0700); err != nil {
t.Fatal(err)
} |
12e99354 |
|
f0e6e135 |
if _, err := driver.Get(image.ID, ""); err != nil { |
596810d8 |
t.Fatal(err)
}
}
|
fb3d60f2 |
func TestInit(t *testing.T) {
graph, _ := tempGraph(t)
defer nukeGraph(graph)
// Root should exist
if _, err := os.Stat(graph.Root); err != nil {
t.Fatal(err)
}
// Map() should be empty
if l, err := graph.Map(); err != nil {
t.Fatal(err)
} else if len(l) != 0 {
t.Fatalf("len(Map()) should return %d, not %d", 0, len(l))
}
}
// Test that Register can be interrupted cleanly without side effects
func TestInterruptedRegister(t *testing.T) {
graph, _ := tempGraph(t)
defer nukeGraph(graph)
badArchive, w := io.Pipe() // Use a pipe reader as a fake archive which never yields data |
82a54398 |
image := &image.Image{ |
7a9c944b |
ID: common.GenerateRandomID(), |
fb3d60f2 |
Comment: "testing",
Created: time.Now(),
}
w.CloseWithError(errors.New("But I'm not a tarball!")) // (Nobody's perfect, darling) |
26184de8 |
graph.Register(image, badArchive) |
fb3d60f2 |
if _, err := graph.Get(image.ID); err == nil {
t.Fatal("Image should not exist after Register is interrupted")
}
// Registering the same image again should succeed if the first register was interrupted
goodArchive, err := fakeTar()
if err != nil {
t.Fatal(err)
} |
26184de8 |
if err := graph.Register(image, goodArchive); err != nil { |
fb3d60f2 |
t.Fatal(err)
}
}
// FIXME: Do more extensive tests (ex: create multiple, delete, recreate;
// create multiple, check the amount of images and paths, etc..)
func TestGraphCreate(t *testing.T) {
graph, _ := tempGraph(t)
defer nukeGraph(graph)
archive, err := fakeTar()
if err != nil {
t.Fatal(err)
} |
01b6b2be |
img, err := graph.Create(archive, "", "", "Testing", "", nil, nil) |
fb3d60f2 |
if err != nil {
t.Fatal(err)
} |
82a54398 |
if err := utils.ValidateID(img.ID); err != nil { |
fb3d60f2 |
t.Fatal(err)
} |
82a54398 |
if img.Comment != "Testing" {
t.Fatalf("Wrong comment: should be '%s', not '%s'", "Testing", img.Comment) |
fb3d60f2 |
} |
82a54398 |
if img.DockerVersion != dockerversion.VERSION {
t.Fatalf("Wrong docker_version: should be '%s', not '%s'", dockerversion.VERSION, img.DockerVersion) |
fb3d60f2 |
}
images, err := graph.Map()
if err != nil {
t.Fatal(err)
} else if l := len(images); l != 1 {
t.Fatalf("Wrong number of images. Should be %d, not %d", 1, l)
} |
82a54398 |
if images[img.ID] == nil {
t.Fatalf("Could not find image with id %s", img.ID) |
fb3d60f2 |
}
}
func TestRegister(t *testing.T) {
graph, _ := tempGraph(t)
defer nukeGraph(graph)
archive, err := fakeTar()
if err != nil {
t.Fatal(err)
} |
82a54398 |
image := &image.Image{ |
7a9c944b |
ID: common.GenerateRandomID(), |
fb3d60f2 |
Comment: "testing",
Created: time.Now(),
} |
26184de8 |
err = graph.Register(image, archive) |
fb3d60f2 |
if err != nil {
t.Fatal(err)
}
if images, err := graph.Map(); err != nil {
t.Fatal(err)
} else if l := len(images); l != 1 {
t.Fatalf("Wrong number of images. Should be %d, not %d", 1, l)
}
if resultImg, err := graph.Get(image.ID); err != nil {
t.Fatal(err)
} else {
if resultImg.ID != image.ID {
t.Fatalf("Wrong image ID. Should be '%s', not '%s'", image.ID, resultImg.ID)
}
if resultImg.Comment != image.Comment {
t.Fatalf("Wrong image comment. Should be '%s', not '%s'", image.Comment, resultImg.Comment)
}
}
}
// Test that an image can be deleted by its shorthand prefix
func TestDeletePrefix(t *testing.T) {
graph, _ := tempGraph(t)
defer nukeGraph(graph)
img := createTestImage(graph, t) |
7a9c944b |
if err := graph.Delete(common.TruncateID(img.ID)); err != nil { |
fb3d60f2 |
t.Fatal(err)
}
assertNImages(graph, t, 0)
}
|
01b6b2be |
func createTestImage(graph *graph.Graph, t *testing.T) *image.Image { |
fb3d60f2 |
archive, err := fakeTar()
if err != nil {
t.Fatal(err)
} |
01b6b2be |
img, err := graph.Create(archive, "", "", "Test image", "", nil, nil) |
596810d8 |
if err != nil {
t.Fatal(err)
} |
fb3d60f2 |
return img
}
func TestDelete(t *testing.T) {
graph, _ := tempGraph(t)
defer nukeGraph(graph)
archive, err := fakeTar()
if err != nil {
t.Fatal(err)
}
assertNImages(graph, t, 0) |
01b6b2be |
img, err := graph.Create(archive, "", "", "Bla bla", "", nil, nil) |
fb3d60f2 |
if err != nil {
t.Fatal(err)
}
assertNImages(graph, t, 1)
if err := graph.Delete(img.ID); err != nil {
t.Fatal(err)
}
assertNImages(graph, t, 0)
archive, err = fakeTar()
if err != nil {
t.Fatal(err)
}
// Test 2 create (same name) / 1 delete |
01b6b2be |
img1, err := graph.Create(archive, "", "", "Testing", "", nil, nil) |
fb3d60f2 |
if err != nil {
t.Fatal(err)
}
archive, err = fakeTar()
if err != nil {
t.Fatal(err)
} |
01b6b2be |
if _, err = graph.Create(archive, "", "", "Testing", "", nil, nil); err != nil { |
fb3d60f2 |
t.Fatal(err)
}
assertNImages(graph, t, 2)
if err := graph.Delete(img1.ID); err != nil {
t.Fatal(err)
}
assertNImages(graph, t, 1)
// Test delete wrong name
if err := graph.Delete("Not_foo"); err == nil {
t.Fatalf("Deleting wrong ID should return an error")
}
assertNImages(graph, t, 1)
archive, err = fakeTar() |
12e99354 |
if err != nil {
t.Fatal(err)
} |
fb3d60f2 |
// Test delete twice (pull -> rm -> pull -> rm) |
26184de8 |
if err := graph.Register(img1, archive); err != nil { |
fb3d60f2 |
t.Fatal(err)
}
if err := graph.Delete(img1.ID); err != nil {
t.Fatal(err)
}
assertNImages(graph, t, 1)
}
func TestByParent(t *testing.T) {
archive1, _ := fakeTar()
archive2, _ := fakeTar()
archive3, _ := fakeTar()
graph, _ := tempGraph(t)
defer nukeGraph(graph) |
82a54398 |
parentImage := &image.Image{ |
7a9c944b |
ID: common.GenerateRandomID(), |
fb3d60f2 |
Comment: "parent",
Created: time.Now(),
Parent: "",
} |
82a54398 |
childImage1 := &image.Image{ |
7a9c944b |
ID: common.GenerateRandomID(), |
fb3d60f2 |
Comment: "child1",
Created: time.Now(),
Parent: parentImage.ID,
} |
82a54398 |
childImage2 := &image.Image{ |
7a9c944b |
ID: common.GenerateRandomID(), |
fb3d60f2 |
Comment: "child2",
Created: time.Now(),
Parent: parentImage.ID,
} |
26184de8 |
_ = graph.Register(parentImage, archive1)
_ = graph.Register(childImage1, archive2)
_ = graph.Register(childImage2, archive3) |
fb3d60f2 |
byParent, err := graph.ByParent()
if err != nil {
t.Fatal(err)
}
numChildren := len(byParent[parentImage.ID])
if numChildren != 2 {
t.Fatalf("Expected 2 children, found %d", numChildren)
}
}
/*
* HELPER FUNCTIONS
*/
|
01b6b2be |
func assertNImages(graph *graph.Graph, t *testing.T, n int) { |
fb3d60f2 |
if images, err := graph.Map(); err != nil {
t.Fatal(err)
} else if actualN := len(images); actualN != n {
t.Fatalf("Expected %d images, found %d", n, actualN)
}
}
|
01b6b2be |
func tempGraph(t *testing.T) (*graph.Graph, graphdriver.Driver) { |
fe72f15e |
tmp, err := ioutil.TempDir("", "docker-graph-")
if err != nil {
t.Fatal(err)
} |
822ea97f |
driver, err := graphdriver.New(tmp, nil) |
fe72f15e |
if err != nil {
t.Fatal(err)
} |
01b6b2be |
graph, err := graph.NewGraph(tmp, driver) |
fe72f15e |
if err != nil {
t.Fatal(err)
}
return graph, driver |
fb3d60f2 |
}
|
01b6b2be |
func nukeGraph(graph *graph.Graph) { |
fb3d60f2 |
graph.Driver().Cleanup()
os.RemoveAll(graph.Root)
}
func testArchive(t *testing.T) archive.Archive {
archive, err := fakeTar() |
596810d8 |
if err != nil {
t.Fatal(err)
} |
fb3d60f2 |
return archive |
596810d8 |
} |