| package runconfig |
| |
| import ( |
| "bytes" |
| "encoding/json" |
| "fmt" |
| "io/ioutil" |
| "runtime" |
| "strings" |
| "testing" |
| |
| "os" |
| |
| "github.com/docker/docker/api/types/container" |
| networktypes "github.com/docker/docker/api/types/network" |
| "github.com/docker/docker/api/types/strslice" |
| "github.com/gotestyourself/gotestyourself/skip" |
| "github.com/stretchr/testify/assert" |
| "github.com/stretchr/testify/require" |
| ) |
| |
| type f struct { |
| file string |
| entrypoint strslice.StrSlice |
| } |
| |
| func TestDecodeContainerConfig(t *testing.T) { |
| |
| var ( |
| fixtures []f |
| image string |
| ) |
| |
| //TODO: Should run for Solaris |
| if runtime.GOOS == "solaris" { |
| t.Skip() |
| } |
| |
| if runtime.GOOS != "windows" { |
| image = "ubuntu" |
| fixtures = []f{ |
| {"fixtures/unix/container_config_1_14.json", strslice.StrSlice{}}, |
| {"fixtures/unix/container_config_1_17.json", strslice.StrSlice{"bash"}}, |
| {"fixtures/unix/container_config_1_19.json", strslice.StrSlice{"bash"}}, |
| } |
| } else { |
| image = "windows" |
| fixtures = []f{ |
| {"fixtures/windows/container_config_1_19.json", strslice.StrSlice{"cmd"}}, |
| } |
| } |
| |
| for _, f := range fixtures { |
| b, err := ioutil.ReadFile(f.file) |
| if err != nil { |
| t.Fatal(err) |
| } |
| |
| c, h, _, err := decodeContainerConfig(bytes.NewReader(b)) |
| if err != nil { |
| t.Fatal(fmt.Errorf("Error parsing %s: %v", f, err)) |
| } |
| |
| if c.Image != image { |
| t.Fatalf("Expected %s image, found %s\n", image, c.Image) |
| } |
| |
| if len(c.Entrypoint) != len(f.entrypoint) { |
| t.Fatalf("Expected %v, found %v\n", f.entrypoint, c.Entrypoint) |
| } |
| |
| if h != nil && h.Memory != 1000 { |
| t.Fatalf("Expected memory to be 1000, found %d\n", h.Memory) |
| } |
| } |
| } |
| |
| // TestDecodeContainerConfigIsolation validates isolation passed |
| // to the daemon in the hostConfig structure. Note this is platform specific |
| // as to what level of container isolation is supported. |
| func TestDecodeContainerConfigIsolation(t *testing.T) { |
| |
| // An Invalid isolation level |
| if _, _, _, err := callDecodeContainerConfigIsolation("invalid"); err != nil { |
| if !strings.Contains(err.Error(), `Invalid isolation: "invalid"`) { |
| t.Fatal(err) |
| } |
| } |
| |
| // Blank isolation (== default) |
| if _, _, _, err := callDecodeContainerConfigIsolation(""); err != nil { |
| t.Fatal("Blank isolation should have succeeded") |
| } |
| |
| // Default isolation |
| if _, _, _, err := callDecodeContainerConfigIsolation("default"); err != nil { |
| t.Fatal("default isolation should have succeeded") |
| } |
| |
| // Process isolation (Valid on Windows only) |
| if runtime.GOOS == "windows" { |
| if _, _, _, err := callDecodeContainerConfigIsolation("process"); err != nil { |
| t.Fatal("process isolation should have succeeded") |
| } |
| } else { |
| if _, _, _, err := callDecodeContainerConfigIsolation("process"); err != nil { |
| if !strings.Contains(err.Error(), `Invalid isolation: "process"`) { |
| t.Fatal(err) |
| } |
| } |
| } |
| |
| // Hyper-V Containers isolation (Valid on Windows only) |
| if runtime.GOOS == "windows" { |
| if _, _, _, err := callDecodeContainerConfigIsolation("hyperv"); err != nil { |
| t.Fatal("hyperv isolation should have succeeded") |
| } |
| } else { |
| if _, _, _, err := callDecodeContainerConfigIsolation("hyperv"); err != nil { |
| if !strings.Contains(err.Error(), `Invalid isolation: "hyperv"`) { |
| t.Fatal(err) |
| } |
| } |
| } |
| } |
| |
| // callDecodeContainerConfigIsolation is a utility function to call |
| // DecodeContainerConfig for validating isolation |
| func callDecodeContainerConfigIsolation(isolation string) (*container.Config, *container.HostConfig, *networktypes.NetworkingConfig, error) { |
| var ( |
| b []byte |
| err error |
| ) |
| w := ContainerConfigWrapper{ |
| Config: &container.Config{}, |
| HostConfig: &container.HostConfig{ |
| NetworkMode: "none", |
| Isolation: container.Isolation(isolation)}, |
| } |
| if b, err = json.Marshal(w); err != nil { |
| return nil, nil, nil, fmt.Errorf("Error on marshal %s", err.Error()) |
| } |
| return decodeContainerConfig(bytes.NewReader(b)) |
| } |
| |
| func TestDecodeContainerConfigWithVolumes(t *testing.T) { |
| var testcases = []decodeConfigTestcase{ |
| { |
| doc: "no paths volume", |
| wrapper: containerWrapperWithVolume(":"), |
| expectedErr: `invalid volume specification: ':'`, |
| }, |
| { |
| doc: "no paths bind", |
| wrapper: containerWrapperWithBind(":"), |
| expectedErr: `invalid volume specification: ':'`, |
| }, |
| { |
| doc: "no paths or mode volume", |
| wrapper: containerWrapperWithVolume("::"), |
| expectedErr: `invalid volume specification: '::'`, |
| }, |
| { |
| doc: "no paths or mode bind", |
| wrapper: containerWrapperWithBind("::"), |
| expectedErr: `invalid volume specification: '::'`, |
| }, |
| } |
| for _, testcase := range testcases { |
| t.Run(testcase.doc, runDecodeContainerConfigTestCase(testcase)) |
| } |
| } |
| |
| func TestDecodeContainerConfigWithVolumesUnix(t *testing.T) { |
| skip.IfCondition(t, runtime.GOOS == "windows") |
| |
| baseErr := `invalid mount config for type "volume": invalid specification: ` |
| var testcases = []decodeConfigTestcase{ |
| { |
| doc: "root to root volume", |
| wrapper: containerWrapperWithVolume("/:/"), |
| expectedErr: `invalid volume specification: '/:/'`, |
| }, |
| { |
| doc: "root to root bind", |
| wrapper: containerWrapperWithBind("/:/"), |
| expectedErr: `invalid volume specification: '/:/'`, |
| }, |
| { |
| doc: "no destination path volume", |
| wrapper: containerWrapperWithVolume(`/tmp:`), |
| expectedErr: ` invalid volume specification: '/tmp:'`, |
| }, |
| { |
| doc: "no destination path bind", |
| wrapper: containerWrapperWithBind(`/tmp:`), |
| expectedErr: ` invalid volume specification: '/tmp:'`, |
| }, |
| { |
| doc: "no destination path or mode volume", |
| wrapper: containerWrapperWithVolume(`/tmp::`), |
| expectedErr: `invalid mount config for type "bind": field Target must not be empty`, |
| }, |
| { |
| doc: "no destination path or mode bind", |
| wrapper: containerWrapperWithBind(`/tmp::`), |
| expectedErr: `invalid mount config for type "bind": field Target must not be empty`, |
| }, |
| { |
| doc: "too many sections volume", |
| wrapper: containerWrapperWithVolume(`/tmp:/tmp:/tmp:/tmp`), |
| expectedErr: `invalid volume specification: '/tmp:/tmp:/tmp:/tmp'`, |
| }, |
| { |
| doc: "too many sections bind", |
| wrapper: containerWrapperWithBind(`/tmp:/tmp:/tmp:/tmp`), |
| expectedErr: `invalid volume specification: '/tmp:/tmp:/tmp:/tmp'`, |
| }, |
| { |
| doc: "just root volume", |
| wrapper: containerWrapperWithVolume("/"), |
| expectedErr: baseErr + `destination can't be '/'`, |
| }, |
| { |
| doc: "just root bind", |
| wrapper: containerWrapperWithBind("/"), |
| expectedErr: baseErr + `destination can't be '/'`, |
| }, |
| { |
| doc: "bind mount passed as a volume", |
| wrapper: containerWrapperWithVolume(`/foo:/bar`), |
| expectedConfig: &container.Config{ |
| Volumes: map[string]struct{}{`/foo:/bar`: {}}, |
| }, |
| expectedHostConfig: &container.HostConfig{NetworkMode: "default"}, |
| }, |
| } |
| for _, testcase := range testcases { |
| t.Run(testcase.doc, runDecodeContainerConfigTestCase(testcase)) |
| } |
| } |
| |
| type decodeConfigTestcase struct { |
| doc string |
| wrapper ContainerConfigWrapper |
| expectedErr string |
| expectedConfig *container.Config |
| expectedHostConfig *container.HostConfig |
| goos string |
| } |
| |
| func runDecodeContainerConfigTestCase(testcase decodeConfigTestcase) func(t *testing.T) { |
| return func(t *testing.T) { |
| raw := marshal(t, testcase.wrapper, testcase.doc) |
| config, hostConfig, _, err := decodeContainerConfig(bytes.NewReader(raw)) |
| if testcase.expectedErr != "" { |
| if !assert.Error(t, err) { |
| return |
| } |
| assert.Contains(t, err.Error(), testcase.expectedErr) |
| return |
| } |
| assert.NoError(t, err) |
| assert.Equal(t, testcase.expectedConfig, config) |
| assert.Equal(t, testcase.expectedHostConfig, hostConfig) |
| } |
| } |
| |
| func TestDecodeContainerConfigWithVolumesWindows(t *testing.T) { |
| skip.IfCondition(t, runtime.GOOS != "windows") |
| |
| tmpDir := os.Getenv("TEMP") |
| systemDrive := os.Getenv("SystemDrive") |
| var testcases = []decodeConfigTestcase{ |
| { |
| doc: "root to root volume", |
| wrapper: containerWrapperWithVolume(systemDrive + `\:c:\`), |
| expectedErr: `invalid volume specification: `, |
| }, |
| { |
| doc: "root to root bind", |
| wrapper: containerWrapperWithBind(systemDrive + `\:c:\`), |
| expectedErr: `invalid volume specification: `, |
| }, |
| { |
| doc: "no destination path volume", |
| wrapper: containerWrapperWithVolume(tmpDir + `\:`), |
| expectedErr: `invalid volume specification: `, |
| }, |
| { |
| doc: "no destination path bind", |
| wrapper: containerWrapperWithBind(tmpDir + `\:`), |
| expectedErr: `invalid volume specification: `, |
| }, |
| { |
| doc: "no destination path or mode volume", |
| wrapper: containerWrapperWithVolume(tmpDir + `\::`), |
| expectedErr: `invalid volume specification: `, |
| }, |
| { |
| doc: "no destination path or mode bind", |
| wrapper: containerWrapperWithBind(tmpDir + `\::`), |
| expectedErr: `invalid volume specification: `, |
| }, |
| { |
| doc: "too many sections volume", |
| wrapper: containerWrapperWithVolume(tmpDir + ":" + tmpDir + ":" + tmpDir + ":" + tmpDir), |
| expectedErr: `invalid volume specification: `, |
| }, |
| { |
| doc: "too many sections bind", |
| wrapper: containerWrapperWithBind(tmpDir + ":" + tmpDir + ":" + tmpDir + ":" + tmpDir), |
| expectedErr: `invalid volume specification: `, |
| }, |
| { |
| doc: "no drive letter volume", |
| wrapper: containerWrapperWithVolume(`\tmp`), |
| expectedErr: `invalid volume specification: `, |
| }, |
| { |
| doc: "no drive letter bind", |
| wrapper: containerWrapperWithBind(`\tmp`), |
| expectedErr: `invalid volume specification: `, |
| }, |
| { |
| doc: "root to c-drive volume", |
| wrapper: containerWrapperWithVolume(systemDrive + `\:c:`), |
| expectedErr: `invalid volume specification: `, |
| }, |
| { |
| doc: "root to c-drive bind", |
| wrapper: containerWrapperWithBind(systemDrive + `\:c:`), |
| expectedErr: `invalid volume specification: `, |
| }, |
| { |
| doc: "container path without driver letter volume", |
| wrapper: containerWrapperWithVolume(`c:\windows:\somewhere`), |
| expectedErr: `invalid volume specification: `, |
| }, |
| { |
| doc: "container path without driver letter bind", |
| wrapper: containerWrapperWithBind(`c:\windows:\somewhere`), |
| expectedErr: `invalid volume specification: `, |
| }, |
| } |
| |
| for _, testcase := range testcases { |
| t.Run(testcase.doc, runDecodeContainerConfigTestCase(testcase)) |
| } |
| } |
| |
| func marshal(t *testing.T, w ContainerConfigWrapper, doc string) []byte { |
| b, err := json.Marshal(w) |
| require.NoError(t, err, "%s: failed to encode config wrapper", doc) |
| return b |
| } |
| |
| func containerWrapperWithVolume(volume string) ContainerConfigWrapper { |
| return ContainerConfigWrapper{ |
| Config: &container.Config{ |
| Volumes: map[string]struct{}{ |
| volume: {}, |
| }, |
| }, |
| HostConfig: &container.HostConfig{}, |
| } |
| } |
| |
| func containerWrapperWithBind(bind string) ContainerConfigWrapper { |
| return ContainerConfigWrapper{ |
| Config: &container.Config{ |
| Volumes: map[string]struct{}{}, |
| }, |
| HostConfig: &container.HostConfig{ |
| Binds: []string{bind}, |
| }, |
| } |
| } |
