volume_test.go 3.7 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133
  1. package convert
  2. import (
  3. "testing"
  4. "github.com/docker/docker/api/types/mount"
  5. composetypes "github.com/docker/docker/cli/compose/types"
  6. "github.com/docker/docker/pkg/testutil/assert"
  7. )
  8. func TestIsReadOnly(t *testing.T) {
  9. assert.Equal(t, isReadOnly([]string{"foo", "bar", "ro"}), true)
  10. assert.Equal(t, isReadOnly([]string{"ro"}), true)
  11. assert.Equal(t, isReadOnly([]string{}), false)
  12. assert.Equal(t, isReadOnly([]string{"foo", "rw"}), false)
  13. assert.Equal(t, isReadOnly([]string{"foo"}), false)
  14. }
  15. func TestIsNoCopy(t *testing.T) {
  16. assert.Equal(t, isNoCopy([]string{"foo", "bar", "nocopy"}), true)
  17. assert.Equal(t, isNoCopy([]string{"nocopy"}), true)
  18. assert.Equal(t, isNoCopy([]string{}), false)
  19. assert.Equal(t, isNoCopy([]string{"foo", "rw"}), false)
  20. }
  21. func TestGetBindOptions(t *testing.T) {
  22. opts := getBindOptions([]string{"slave"})
  23. expected := mount.BindOptions{Propagation: mount.PropagationSlave}
  24. assert.Equal(t, *opts, expected)
  25. }
  26. func TestGetBindOptionsNone(t *testing.T) {
  27. opts := getBindOptions([]string{"ro"})
  28. assert.Equal(t, opts, (*mount.BindOptions)(nil))
  29. }
  30. func TestConvertVolumeToMountAnonymousVolume(t *testing.T) {
  31. stackVolumes := volumes{}
  32. namespace := NewNamespace("foo")
  33. expected := mount.Mount{
  34. Type: mount.TypeVolume,
  35. Target: "/foo/bar",
  36. }
  37. mount, err := convertVolumeToMount("/foo/bar", stackVolumes, namespace)
  38. assert.NilError(t, err)
  39. assert.DeepEqual(t, mount, expected)
  40. }
  41. func TestConvertVolumeToMountInvalidFormat(t *testing.T) {
  42. namespace := NewNamespace("foo")
  43. invalids := []string{"::", "::cc", ":bb:", "aa::", "aa::cc", "aa:bb:", " : : ", " : :cc", " :bb: ", "aa: : ", "aa: :cc", "aa:bb: "}
  44. for _, vol := range invalids {
  45. _, err := convertVolumeToMount(vol, volumes{}, namespace)
  46. assert.Error(t, err, "invalid volume: "+vol)
  47. }
  48. }
  49. func TestConvertVolumeToMountNamedVolume(t *testing.T) {
  50. stackVolumes := volumes{
  51. "normal": composetypes.VolumeConfig{
  52. Driver: "glusterfs",
  53. DriverOpts: map[string]string{
  54. "opt": "value",
  55. },
  56. Labels: map[string]string{
  57. "something": "labeled",
  58. },
  59. },
  60. }
  61. namespace := NewNamespace("foo")
  62. expected := mount.Mount{
  63. Type: mount.TypeVolume,
  64. Source: "foo_normal",
  65. Target: "/foo",
  66. ReadOnly: true,
  67. VolumeOptions: &mount.VolumeOptions{
  68. Labels: map[string]string{
  69. LabelNamespace: "foo",
  70. "something": "labeled",
  71. },
  72. DriverConfig: &mount.Driver{
  73. Name: "glusterfs",
  74. Options: map[string]string{
  75. "opt": "value",
  76. },
  77. },
  78. },
  79. }
  80. mount, err := convertVolumeToMount("normal:/foo:ro", stackVolumes, namespace)
  81. assert.NilError(t, err)
  82. assert.DeepEqual(t, mount, expected)
  83. }
  84. func TestConvertVolumeToMountNamedVolumeExternal(t *testing.T) {
  85. stackVolumes := volumes{
  86. "outside": composetypes.VolumeConfig{
  87. External: composetypes.External{
  88. External: true,
  89. Name: "special",
  90. },
  91. },
  92. }
  93. namespace := NewNamespace("foo")
  94. expected := mount.Mount{
  95. Type: mount.TypeVolume,
  96. Source: "special",
  97. Target: "/foo",
  98. }
  99. mount, err := convertVolumeToMount("outside:/foo", stackVolumes, namespace)
  100. assert.NilError(t, err)
  101. assert.DeepEqual(t, mount, expected)
  102. }
  103. func TestConvertVolumeToMountBind(t *testing.T) {
  104. stackVolumes := volumes{}
  105. namespace := NewNamespace("foo")
  106. expected := mount.Mount{
  107. Type: mount.TypeBind,
  108. Source: "/bar",
  109. Target: "/foo",
  110. ReadOnly: true,
  111. BindOptions: &mount.BindOptions{Propagation: mount.PropagationShared},
  112. }
  113. mount, err := convertVolumeToMount("/bar:/foo:ro,shared", stackVolumes, namespace)
  114. assert.NilError(t, err)
  115. assert.DeepEqual(t, mount, expected)
  116. }
  117. func TestConvertVolumeToMountVolumeDoesNotExist(t *testing.T) {
  118. namespace := NewNamespace("foo")
  119. _, err := convertVolumeToMount("unknown:/foo:ro", volumes{}, namespace)
  120. assert.Error(t, err, "undefined volume: unknown")
  121. }