| package service // import "github.com/docker/docker/volume/service" |
| |
| import ( |
| "context" |
| "errors" |
| "fmt" |
| "io/ioutil" |
| "net" |
| "os" |
| "strings" |
| "testing" |
| |
| "github.com/docker/docker/volume" |
| volumedrivers "github.com/docker/docker/volume/drivers" |
| "github.com/docker/docker/volume/service/opts" |
| volumetestutils "github.com/docker/docker/volume/testutils" |
| "github.com/google/go-cmp/cmp" |
| "gotest.tools/assert" |
| is "gotest.tools/assert/cmp" |
| ) |
| |
| func TestCreate(t *testing.T) { |
| t.Parallel() |
| |
| s, cleanup := setupTest(t) |
| defer cleanup() |
| s.drivers.Register(volumetestutils.NewFakeDriver("fake"), "fake") |
| |
| ctx := context.Background() |
| v, err := s.Create(ctx, "fake1", "fake") |
| if err != nil { |
| t.Fatal(err) |
| } |
| if v.Name() != "fake1" { |
| t.Fatalf("Expected fake1 volume, got %v", v) |
| } |
| if l, _, _ := s.Find(ctx, nil); len(l) != 1 { |
| t.Fatalf("Expected 1 volume in the store, got %v: %v", len(l), l) |
| } |
| |
| if _, err := s.Create(ctx, "none", "none"); err == nil { |
| t.Fatalf("Expected unknown driver error, got nil") |
| } |
| |
| _, err = s.Create(ctx, "fakeerror", "fake", opts.WithCreateOptions(map[string]string{"error": "create error"})) |
| expected := &OpErr{Op: "create", Name: "fakeerror", Err: errors.New("create error")} |
| if err != nil && err.Error() != expected.Error() { |
| t.Fatalf("Expected create fakeError: create error, got %v", err) |
| } |
| } |
| |
| func TestRemove(t *testing.T) { |
| t.Parallel() |
| |
| s, cleanup := setupTest(t) |
| defer cleanup() |
| |
| s.drivers.Register(volumetestutils.NewFakeDriver("fake"), "fake") |
| s.drivers.Register(volumetestutils.NewFakeDriver("noop"), "noop") |
| |
| ctx := context.Background() |
| |
| // doing string compare here since this error comes directly from the driver |
| expected := "no such volume" |
| var v volume.Volume = volumetestutils.NoopVolume{} |
| if err := s.Remove(ctx, v); err == nil || !strings.Contains(err.Error(), expected) { |
| t.Fatalf("Expected error %q, got %v", expected, err) |
| } |
| |
| v, err := s.Create(ctx, "fake1", "fake", opts.WithCreateReference("fake")) |
| if err != nil { |
| t.Fatal(err) |
| } |
| |
| if err := s.Remove(ctx, v); !IsInUse(err) { |
| t.Fatalf("Expected ErrVolumeInUse error, got %v", err) |
| } |
| s.Release(ctx, v.Name(), "fake") |
| if err := s.Remove(ctx, v); err != nil { |
| t.Fatal(err) |
| } |
| if l, _, _ := s.Find(ctx, nil); len(l) != 0 { |
| t.Fatalf("Expected 0 volumes in the store, got %v, %v", len(l), l) |
| } |
| } |
| |
| func TestList(t *testing.T) { |
| t.Parallel() |
| |
| dir, err := ioutil.TempDir("", "test-list") |
| assert.NilError(t, err) |
| defer os.RemoveAll(dir) |
| |
| drivers := volumedrivers.NewStore(nil) |
| drivers.Register(volumetestutils.NewFakeDriver("fake"), "fake") |
| drivers.Register(volumetestutils.NewFakeDriver("fake2"), "fake2") |
| |
| s, err := NewStore(dir, drivers) |
| assert.NilError(t, err) |
| |
| ctx := context.Background() |
| if _, err := s.Create(ctx, "test", "fake"); err != nil { |
| t.Fatal(err) |
| } |
| if _, err := s.Create(ctx, "test2", "fake2"); err != nil { |
| t.Fatal(err) |
| } |
| |
| ls, _, err := s.Find(ctx, nil) |
| if err != nil { |
| t.Fatal(err) |
| } |
| if len(ls) != 2 { |
| t.Fatalf("expected 2 volumes, got: %d", len(ls)) |
| } |
| if err := s.Shutdown(); err != nil { |
| t.Fatal(err) |
| } |
| |
| // and again with a new store |
| s, err = NewStore(dir, drivers) |
| if err != nil { |
| t.Fatal(err) |
| } |
| ls, _, err = s.Find(ctx, nil) |
| if err != nil { |
| t.Fatal(err) |
| } |
| if len(ls) != 2 { |
| t.Fatalf("expected 2 volumes, got: %d", len(ls)) |
| } |
| } |
| |
| func TestFindByDriver(t *testing.T) { |
| t.Parallel() |
| s, cleanup := setupTest(t) |
| defer cleanup() |
| |
| assert.Assert(t, s.drivers.Register(volumetestutils.NewFakeDriver("fake"), "fake")) |
| assert.Assert(t, s.drivers.Register(volumetestutils.NewFakeDriver("noop"), "noop")) |
| |
| ctx := context.Background() |
| _, err := s.Create(ctx, "fake1", "fake") |
| assert.NilError(t, err) |
| |
| _, err = s.Create(ctx, "fake2", "fake") |
| assert.NilError(t, err) |
| |
| _, err = s.Create(ctx, "fake3", "noop") |
| assert.NilError(t, err) |
| |
| l, _, err := s.Find(ctx, ByDriver("fake")) |
| assert.NilError(t, err) |
| assert.Equal(t, len(l), 2) |
| |
| l, _, err = s.Find(ctx, ByDriver("noop")) |
| assert.NilError(t, err) |
| assert.Equal(t, len(l), 1) |
| |
| l, _, err = s.Find(ctx, ByDriver("nosuchdriver")) |
| assert.NilError(t, err) |
| assert.Equal(t, len(l), 0) |
| } |
| |
| func TestFindByReferenced(t *testing.T) { |
| t.Parallel() |
| s, cleanup := setupTest(t) |
| defer cleanup() |
| |
| s.drivers.Register(volumetestutils.NewFakeDriver("fake"), "fake") |
| s.drivers.Register(volumetestutils.NewFakeDriver("noop"), "noop") |
| |
| ctx := context.Background() |
| if _, err := s.Create(ctx, "fake1", "fake", opts.WithCreateReference("volReference")); err != nil { |
| t.Fatal(err) |
| } |
| if _, err := s.Create(ctx, "fake2", "fake"); err != nil { |
| t.Fatal(err) |
| } |
| |
| dangling, _, err := s.Find(ctx, ByReferenced(false)) |
| assert.NilError(t, err) |
| assert.Assert(t, len(dangling) == 1) |
| assert.Check(t, dangling[0].Name() == "fake2") |
| |
| used, _, err := s.Find(ctx, ByReferenced(true)) |
| assert.NilError(t, err) |
| assert.Assert(t, len(used) == 1) |
| assert.Check(t, used[0].Name() == "fake1") |
| } |
| |
| func TestDerefMultipleOfSameRef(t *testing.T) { |
| t.Parallel() |
| s, cleanup := setupTest(t) |
| defer cleanup() |
| s.drivers.Register(volumetestutils.NewFakeDriver("fake"), "fake") |
| |
| ctx := context.Background() |
| v, err := s.Create(ctx, "fake1", "fake", opts.WithCreateReference("volReference")) |
| if err != nil { |
| t.Fatal(err) |
| } |
| |
| if _, err := s.Get(ctx, "fake1", opts.WithGetDriver("fake"), opts.WithGetReference("volReference")); err != nil { |
| t.Fatal(err) |
| } |
| |
| s.Release(ctx, v.Name(), "volReference") |
| if err := s.Remove(ctx, v); err != nil { |
| t.Fatal(err) |
| } |
| } |
| |
| func TestCreateKeepOptsLabelsWhenExistsRemotely(t *testing.T) { |
| t.Parallel() |
| s, cleanup := setupTest(t) |
| defer cleanup() |
| |
| vd := volumetestutils.NewFakeDriver("fake") |
| s.drivers.Register(vd, "fake") |
| |
| // Create a volume in the driver directly |
| if _, err := vd.Create("foo", nil); err != nil { |
| t.Fatal(err) |
| } |
| |
| ctx := context.Background() |
| v, err := s.Create(ctx, "foo", "fake", opts.WithCreateLabels(map[string]string{"hello": "world"})) |
| if err != nil { |
| t.Fatal(err) |
| } |
| |
| switch dv := v.(type) { |
| case volume.DetailedVolume: |
| if dv.Labels()["hello"] != "world" { |
| t.Fatalf("labels don't match") |
| } |
| default: |
| t.Fatalf("got unexpected type: %T", v) |
| } |
| } |
| |
| func TestDefererencePluginOnCreateError(t *testing.T) { |
| t.Parallel() |
| |
| var ( |
| l net.Listener |
| err error |
| ) |
| |
| for i := 32768; l == nil && i < 40000; i++ { |
| l, err = net.Listen("tcp", fmt.Sprintf("127.0.0.1:%d", i)) |
| } |
| if l == nil { |
| t.Fatalf("could not create listener: %v", err) |
| } |
| defer l.Close() |
| |
| s, cleanup := setupTest(t) |
| defer cleanup() |
| |
| d := volumetestutils.NewFakeDriver("TestDefererencePluginOnCreateError") |
| p, err := volumetestutils.MakeFakePlugin(d, l) |
| if err != nil { |
| t.Fatal(err) |
| } |
| |
| pg := volumetestutils.NewFakePluginGetter(p) |
| s.drivers = volumedrivers.NewStore(pg) |
| |
| ctx := context.Background() |
| // create a good volume so we have a plugin reference |
| _, err = s.Create(ctx, "fake1", d.Name()) |
| if err != nil { |
| t.Fatal(err) |
| } |
| |
| // Now create another one expecting an error |
| _, err = s.Create(ctx, "fake2", d.Name(), opts.WithCreateOptions(map[string]string{"error": "some error"})) |
| if err == nil || !strings.Contains(err.Error(), "some error") { |
| t.Fatalf("expected an error on create: %v", err) |
| } |
| |
| // There should be only 1 plugin reference |
| if refs := volumetestutils.FakeRefs(p); refs != 1 { |
| t.Fatalf("expected 1 plugin reference, got: %d", refs) |
| } |
| } |
| |
| func TestRefDerefRemove(t *testing.T) { |
| t.Parallel() |
| |
| driverName := "test-ref-deref-remove" |
| s, cleanup := setupTest(t) |
| defer cleanup() |
| s.drivers.Register(volumetestutils.NewFakeDriver(driverName), driverName) |
| |
| ctx := context.Background() |
| v, err := s.Create(ctx, "test", driverName, opts.WithCreateReference("test-ref")) |
| assert.NilError(t, err) |
| |
| err = s.Remove(ctx, v) |
| assert.Assert(t, is.ErrorContains(err, "")) |
| assert.Equal(t, errVolumeInUse, err.(*OpErr).Err) |
| |
| s.Release(ctx, v.Name(), "test-ref") |
| err = s.Remove(ctx, v) |
| assert.NilError(t, err) |
| } |
| |
| func TestGet(t *testing.T) { |
| t.Parallel() |
| |
| driverName := "test-get" |
| s, cleanup := setupTest(t) |
| defer cleanup() |
| s.drivers.Register(volumetestutils.NewFakeDriver(driverName), driverName) |
| |
| ctx := context.Background() |
| _, err := s.Get(ctx, "not-exist") |
| assert.Assert(t, is.ErrorContains(err, "")) |
| assert.Equal(t, errNoSuchVolume, err.(*OpErr).Err) |
| |
| v1, err := s.Create(ctx, "test", driverName, opts.WithCreateLabels(map[string]string{"a": "1"})) |
| assert.NilError(t, err) |
| |
| v2, err := s.Get(ctx, "test") |
| assert.NilError(t, err) |
| assert.DeepEqual(t, v1, v2, cmpVolume) |
| |
| dv := v2.(volume.DetailedVolume) |
| assert.Equal(t, "1", dv.Labels()["a"]) |
| |
| err = s.Remove(ctx, v1) |
| assert.NilError(t, err) |
| } |
| |
| func TestGetWithReference(t *testing.T) { |
| t.Parallel() |
| |
| driverName := "test-get-with-ref" |
| s, cleanup := setupTest(t) |
| defer cleanup() |
| s.drivers.Register(volumetestutils.NewFakeDriver(driverName), driverName) |
| |
| ctx := context.Background() |
| _, err := s.Get(ctx, "not-exist", opts.WithGetDriver(driverName), opts.WithGetReference("test-ref")) |
| assert.Assert(t, is.ErrorContains(err, "")) |
| |
| v1, err := s.Create(ctx, "test", driverName, opts.WithCreateLabels(map[string]string{"a": "1"})) |
| assert.NilError(t, err) |
| |
| v2, err := s.Get(ctx, "test", opts.WithGetDriver(driverName), opts.WithGetReference("test-ref")) |
| assert.NilError(t, err) |
| assert.DeepEqual(t, v1, v2, cmpVolume) |
| |
| err = s.Remove(ctx, v2) |
| assert.Assert(t, is.ErrorContains(err, "")) |
| assert.Equal(t, errVolumeInUse, err.(*OpErr).Err) |
| |
| s.Release(ctx, v2.Name(), "test-ref") |
| err = s.Remove(ctx, v2) |
| assert.NilError(t, err) |
| } |
| |
| var cmpVolume = cmp.AllowUnexported(volumetestutils.FakeVolume{}, volumeWrapper{}) |
| |
| func setupTest(t *testing.T) (*VolumeStore, func()) { |
| t.Helper() |
| |
| dirName := strings.Replace(t.Name(), string(os.PathSeparator), "_", -1) |
| dir, err := ioutil.TempDir("", dirName) |
| assert.NilError(t, err) |
| |
| cleanup := func() { |
| t.Helper() |
| err := os.RemoveAll(dir) |
| assert.Check(t, err) |
| } |
| |
| s, err := NewStore(dir, volumedrivers.NewStore(nil)) |
| assert.Check(t, err) |
| return s, func() { |
| s.Shutdown() |
| cleanup() |
| } |
| } |
| |
| func TestFilterFunc(t *testing.T) { |
| testDriver := volumetestutils.NewFakeDriver("test") |
| testVolume, err := testDriver.Create("test", nil) |
| assert.NilError(t, err) |
| testVolume2, err := testDriver.Create("test2", nil) |
| assert.NilError(t, err) |
| testVolume3, err := testDriver.Create("test3", nil) |
| assert.NilError(t, err) |
| |
| for _, test := range []struct { |
| vols []volume.Volume |
| fn filterFunc |
| desc string |
| expect []volume.Volume |
| }{ |
| {desc: "test nil list", vols: nil, expect: nil, fn: func(volume.Volume) bool { return true }}, |
| {desc: "test empty list", vols: []volume.Volume{}, expect: []volume.Volume{}, fn: func(volume.Volume) bool { return true }}, |
| {desc: "test filter non-empty to empty", vols: []volume.Volume{testVolume}, expect: []volume.Volume{}, fn: func(volume.Volume) bool { return false }}, |
| {desc: "test nothing to fitler non-empty list", vols: []volume.Volume{testVolume}, expect: []volume.Volume{testVolume}, fn: func(volume.Volume) bool { return true }}, |
| {desc: "test filter some", vols: []volume.Volume{testVolume, testVolume2}, expect: []volume.Volume{testVolume}, fn: func(v volume.Volume) bool { return v.Name() == testVolume.Name() }}, |
| {desc: "test filter middle", vols: []volume.Volume{testVolume, testVolume2, testVolume3}, expect: []volume.Volume{testVolume, testVolume3}, fn: func(v volume.Volume) bool { return v.Name() != testVolume2.Name() }}, |
| {desc: "test filter middle and last", vols: []volume.Volume{testVolume, testVolume2, testVolume3}, expect: []volume.Volume{testVolume}, fn: func(v volume.Volume) bool { return v.Name() != testVolume2.Name() && v.Name() != testVolume3.Name() }}, |
| {desc: "test filter first and last", vols: []volume.Volume{testVolume, testVolume2, testVolume3}, expect: []volume.Volume{testVolume2}, fn: func(v volume.Volume) bool { return v.Name() != testVolume.Name() && v.Name() != testVolume3.Name() }}, |
| } { |
| t.Run(test.desc, func(t *testing.T) { |
| test := test |
| t.Parallel() |
| |
| filter(&test.vols, test.fn) |
| assert.DeepEqual(t, test.vols, test.expect, cmpVolume) |
| }) |
| } |
| } |