github.com/olljanat/moby@v1.13.1/cli/compose/convert/volume_test.go (about)

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