github.com/devdivbcp/moby@v17.12.0-ce-rc1.0.20200726071732-2d4bfdc789ad+incompatible/integration-cli/docker_cli_external_volume_driver_test.go (about) 1 package main 2 3 import ( 4 "encoding/json" 5 "fmt" 6 "io" 7 "io/ioutil" 8 "net/http" 9 "net/http/httptest" 10 "os" 11 "os/exec" 12 "path/filepath" 13 "strings" 14 "testing" 15 "time" 16 17 "github.com/docker/docker/api/types" 18 "github.com/docker/docker/integration-cli/daemon" 19 testdaemon "github.com/docker/docker/internal/test/daemon" 20 "github.com/docker/docker/pkg/stringid" 21 "github.com/docker/docker/volume" 22 "gotest.tools/assert" 23 ) 24 25 const volumePluginName = "test-external-volume-driver" 26 27 type eventCounter struct { 28 activations int 29 creations int 30 removals int 31 mounts int 32 unmounts int 33 paths int 34 lists int 35 gets int 36 caps int 37 } 38 39 type DockerExternalVolumeSuite struct { 40 ds *DockerSuite 41 d *daemon.Daemon 42 *volumePlugin 43 } 44 45 func (s *DockerExternalVolumeSuite) SetUpTest(c *testing.T) { 46 testRequires(c, testEnv.IsLocalDaemon) 47 s.d = daemon.New(c, dockerBinary, dockerdBinary, testdaemon.WithEnvironment(testEnv.Execution)) 48 s.ec = &eventCounter{} 49 } 50 51 func (s *DockerExternalVolumeSuite) TearDownTest(c *testing.T) { 52 if s.d != nil { 53 s.d.Stop(c) 54 s.ds.TearDownTest(c) 55 } 56 } 57 58 func (s *DockerExternalVolumeSuite) SetUpSuite(c *testing.T) { 59 s.volumePlugin = newVolumePlugin(c, volumePluginName) 60 } 61 62 type volumePlugin struct { 63 ec *eventCounter 64 *httptest.Server 65 vols map[string]vol 66 } 67 68 type vol struct { 69 Name string 70 Mountpoint string 71 Ninja bool // hack used to trigger a null volume return on `Get` 72 Status map[string]interface{} 73 Options map[string]string 74 } 75 76 func (p *volumePlugin) Close() { 77 p.Server.Close() 78 } 79 80 func newVolumePlugin(c *testing.T, name string) *volumePlugin { 81 mux := http.NewServeMux() 82 s := &volumePlugin{Server: httptest.NewServer(mux), ec: &eventCounter{}, vols: make(map[string]vol)} 83 84 type pluginRequest struct { 85 Name string 86 Opts map[string]string 87 ID string 88 } 89 90 type pluginResp struct { 91 Mountpoint string `json:",omitempty"` 92 Err string `json:",omitempty"` 93 } 94 95 read := func(b io.ReadCloser) (pluginRequest, error) { 96 defer b.Close() 97 var pr pluginRequest 98 err := json.NewDecoder(b).Decode(&pr) 99 return pr, err 100 } 101 102 send := func(w http.ResponseWriter, data interface{}) { 103 switch t := data.(type) { 104 case error: 105 http.Error(w, t.Error(), 500) 106 case string: 107 w.Header().Set("Content-Type", "application/vnd.docker.plugins.v1+json") 108 fmt.Fprintln(w, t) 109 default: 110 w.Header().Set("Content-Type", "application/vnd.docker.plugins.v1+json") 111 json.NewEncoder(w).Encode(&data) 112 } 113 } 114 115 mux.HandleFunc("/Plugin.Activate", func(w http.ResponseWriter, r *http.Request) { 116 s.ec.activations++ 117 send(w, `{"Implements": ["VolumeDriver"]}`) 118 }) 119 120 mux.HandleFunc("/VolumeDriver.Create", func(w http.ResponseWriter, r *http.Request) { 121 s.ec.creations++ 122 pr, err := read(r.Body) 123 if err != nil { 124 send(w, err) 125 return 126 } 127 _, isNinja := pr.Opts["ninja"] 128 status := map[string]interface{}{"Hello": "world"} 129 s.vols[pr.Name] = vol{Name: pr.Name, Ninja: isNinja, Status: status, Options: pr.Opts} 130 send(w, nil) 131 }) 132 133 mux.HandleFunc("/VolumeDriver.List", func(w http.ResponseWriter, r *http.Request) { 134 s.ec.lists++ 135 vols := make([]vol, 0, len(s.vols)) 136 for _, v := range s.vols { 137 if v.Ninja { 138 continue 139 } 140 vols = append(vols, v) 141 } 142 send(w, map[string][]vol{"Volumes": vols}) 143 }) 144 145 mux.HandleFunc("/VolumeDriver.Get", func(w http.ResponseWriter, r *http.Request) { 146 s.ec.gets++ 147 pr, err := read(r.Body) 148 if err != nil { 149 send(w, err) 150 return 151 } 152 153 v, exists := s.vols[pr.Name] 154 if !exists { 155 send(w, `{"Err": "no such volume"}`) 156 } 157 158 if v.Ninja { 159 send(w, map[string]vol{}) 160 return 161 } 162 163 v.Mountpoint = hostVolumePath(pr.Name) 164 send(w, map[string]vol{"Volume": v}) 165 return 166 }) 167 168 mux.HandleFunc("/VolumeDriver.Remove", func(w http.ResponseWriter, r *http.Request) { 169 s.ec.removals++ 170 pr, err := read(r.Body) 171 if err != nil { 172 send(w, err) 173 return 174 } 175 176 v, ok := s.vols[pr.Name] 177 if !ok { 178 send(w, nil) 179 return 180 } 181 182 if err := os.RemoveAll(hostVolumePath(v.Name)); err != nil { 183 send(w, &pluginResp{Err: err.Error()}) 184 return 185 } 186 delete(s.vols, v.Name) 187 send(w, nil) 188 }) 189 190 mux.HandleFunc("/VolumeDriver.Path", func(w http.ResponseWriter, r *http.Request) { 191 s.ec.paths++ 192 193 pr, err := read(r.Body) 194 if err != nil { 195 send(w, err) 196 return 197 } 198 p := hostVolumePath(pr.Name) 199 send(w, &pluginResp{Mountpoint: p}) 200 }) 201 202 mux.HandleFunc("/VolumeDriver.Mount", func(w http.ResponseWriter, r *http.Request) { 203 s.ec.mounts++ 204 205 pr, err := read(r.Body) 206 if err != nil { 207 send(w, err) 208 return 209 } 210 211 if v, exists := s.vols[pr.Name]; exists { 212 // Use this to simulate a mount failure 213 if _, exists := v.Options["invalidOption"]; exists { 214 send(w, fmt.Errorf("invalid argument")) 215 return 216 } 217 } 218 219 p := hostVolumePath(pr.Name) 220 if err := os.MkdirAll(p, 0755); err != nil { 221 send(w, &pluginResp{Err: err.Error()}) 222 return 223 } 224 225 if err := ioutil.WriteFile(filepath.Join(p, "test"), []byte(s.Server.URL), 0644); err != nil { 226 send(w, err) 227 return 228 } 229 230 if err := ioutil.WriteFile(filepath.Join(p, "mountID"), []byte(pr.ID), 0644); err != nil { 231 send(w, err) 232 return 233 } 234 235 send(w, &pluginResp{Mountpoint: p}) 236 }) 237 238 mux.HandleFunc("/VolumeDriver.Unmount", func(w http.ResponseWriter, r *http.Request) { 239 s.ec.unmounts++ 240 241 _, err := read(r.Body) 242 if err != nil { 243 send(w, err) 244 return 245 } 246 247 send(w, nil) 248 }) 249 250 mux.HandleFunc("/VolumeDriver.Capabilities", func(w http.ResponseWriter, r *http.Request) { 251 s.ec.caps++ 252 253 _, err := read(r.Body) 254 if err != nil { 255 send(w, err) 256 return 257 } 258 259 send(w, `{"Capabilities": { "Scope": "global" }}`) 260 }) 261 262 err := os.MkdirAll("/etc/docker/plugins", 0755) 263 assert.NilError(c, err) 264 265 err = ioutil.WriteFile("/etc/docker/plugins/"+name+".spec", []byte(s.Server.URL), 0644) 266 assert.NilError(c, err) 267 return s 268 } 269 270 func (s *DockerExternalVolumeSuite) TearDownSuite(c *testing.T) { 271 s.volumePlugin.Close() 272 273 err := os.RemoveAll("/etc/docker/plugins") 274 assert.NilError(c, err) 275 } 276 277 func (s *DockerExternalVolumeSuite) TestVolumeCLICreateOptionConflict(c *testing.T) { 278 dockerCmd(c, "volume", "create", "test") 279 280 out, _, err := dockerCmdWithError("volume", "create", "test", "--driver", volumePluginName) 281 assert.Assert(c, err != nil, "volume create exception name already in use with another driver") 282 assert.Assert(c, strings.Contains(out, "must be unique")) 283 out, _ = dockerCmd(c, "volume", "inspect", "--format={{ .Driver }}", "test") 284 _, _, err = dockerCmdWithError("volume", "create", "test", "--driver", strings.TrimSpace(out)) 285 assert.NilError(c, err) 286 } 287 288 func (s *DockerExternalVolumeSuite) TestExternalVolumeDriverNamed(c *testing.T) { 289 s.d.StartWithBusybox(c) 290 291 out, err := s.d.Cmd("run", "--rm", "--name", "test-data", "-v", "external-volume-test:/tmp/external-volume-test", "--volume-driver", volumePluginName, "busybox:latest", "cat", "/tmp/external-volume-test/test") 292 assert.NilError(c, err, out) 293 assert.Assert(c, strings.Contains(out, s.Server.URL)) 294 _, err = s.d.Cmd("volume", "rm", "external-volume-test") 295 assert.NilError(c, err) 296 297 p := hostVolumePath("external-volume-test") 298 _, err = os.Lstat(p) 299 assert.ErrorContains(c, err, "") 300 assert.Assert(c, os.IsNotExist(err), "Expected volume path in host to not exist: %s, %v\n", p, err) 301 302 assert.Equal(c, s.ec.activations, 1) 303 assert.Equal(c, s.ec.creations, 1) 304 assert.Equal(c, s.ec.removals, 1) 305 assert.Equal(c, s.ec.mounts, 1) 306 assert.Equal(c, s.ec.unmounts, 1) 307 } 308 309 func (s *DockerExternalVolumeSuite) TestExternalVolumeDriverUnnamed(c *testing.T) { 310 s.d.StartWithBusybox(c) 311 312 out, err := s.d.Cmd("run", "--rm", "--name", "test-data", "-v", "/tmp/external-volume-test", "--volume-driver", volumePluginName, "busybox:latest", "cat", "/tmp/external-volume-test/test") 313 assert.NilError(c, err, out) 314 assert.Assert(c, strings.Contains(out, s.Server.URL)) 315 assert.Equal(c, s.ec.activations, 1) 316 assert.Equal(c, s.ec.creations, 1) 317 assert.Equal(c, s.ec.removals, 1) 318 assert.Equal(c, s.ec.mounts, 1) 319 assert.Equal(c, s.ec.unmounts, 1) 320 } 321 322 func (s *DockerExternalVolumeSuite) TestExternalVolumeDriverVolumesFrom(c *testing.T) { 323 s.d.StartWithBusybox(c) 324 325 out, err := s.d.Cmd("run", "--name", "vol-test1", "-v", "/foo", "--volume-driver", volumePluginName, "busybox:latest") 326 assert.NilError(c, err, out) 327 328 out, err = s.d.Cmd("run", "--rm", "--volumes-from", "vol-test1", "--name", "vol-test2", "busybox", "ls", "/tmp") 329 assert.NilError(c, err, out) 330 331 out, err = s.d.Cmd("rm", "-fv", "vol-test1") 332 assert.NilError(c, err, out) 333 334 assert.Equal(c, s.ec.activations, 1) 335 assert.Equal(c, s.ec.creations, 1) 336 assert.Equal(c, s.ec.removals, 1) 337 assert.Equal(c, s.ec.mounts, 2) 338 assert.Equal(c, s.ec.unmounts, 2) 339 } 340 341 func (s *DockerExternalVolumeSuite) TestExternalVolumeDriverDeleteContainer(c *testing.T) { 342 s.d.StartWithBusybox(c) 343 344 out, err := s.d.Cmd("run", "--name", "vol-test1", "-v", "/foo", "--volume-driver", volumePluginName, "busybox:latest") 345 assert.NilError(c, err, out) 346 347 out, err = s.d.Cmd("rm", "-fv", "vol-test1") 348 assert.NilError(c, err, out) 349 350 assert.Equal(c, s.ec.activations, 1) 351 assert.Equal(c, s.ec.creations, 1) 352 assert.Equal(c, s.ec.removals, 1) 353 assert.Equal(c, s.ec.mounts, 1) 354 assert.Equal(c, s.ec.unmounts, 1) 355 } 356 357 func hostVolumePath(name string) string { 358 return fmt.Sprintf("/var/lib/docker/volumes/%s", name) 359 } 360 361 // Make sure a request to use a down driver doesn't block other requests 362 func (s *DockerExternalVolumeSuite) TestExternalVolumeDriverLookupNotBlocked(c *testing.T) { 363 specPath := "/etc/docker/plugins/down-driver.spec" 364 err := ioutil.WriteFile(specPath, []byte("tcp://127.0.0.7:9999"), 0644) 365 assert.NilError(c, err) 366 defer os.RemoveAll(specPath) 367 368 chCmd1 := make(chan struct{}) 369 chCmd2 := make(chan error) 370 cmd1 := exec.Command(dockerBinary, "volume", "create", "-d", "down-driver") 371 cmd2 := exec.Command(dockerBinary, "volume", "create") 372 373 assert.Assert(c, cmd1.Start() == nil) 374 defer cmd1.Process.Kill() 375 time.Sleep(100 * time.Millisecond) // ensure API has been called 376 assert.Assert(c, cmd2.Start() == nil) 377 378 go func() { 379 cmd1.Wait() 380 close(chCmd1) 381 }() 382 go func() { 383 chCmd2 <- cmd2.Wait() 384 }() 385 386 select { 387 case <-chCmd1: 388 cmd2.Process.Kill() 389 c.Fatalf("volume create with down driver finished unexpectedly") 390 case err := <-chCmd2: 391 assert.NilError(c, err) 392 case <-time.After(5 * time.Second): 393 cmd2.Process.Kill() 394 c.Fatal("volume creates are blocked by previous create requests when previous driver is down") 395 } 396 } 397 398 func (s *DockerExternalVolumeSuite) TestExternalVolumeDriverRetryNotImmediatelyExists(c *testing.T) { 399 s.d.StartWithBusybox(c) 400 driverName := "test-external-volume-driver-retry" 401 402 errchan := make(chan error) 403 started := make(chan struct{}) 404 go func() { 405 close(started) 406 if out, err := s.d.Cmd("run", "--rm", "--name", "test-data-retry", "-v", "external-volume-test:/tmp/external-volume-test", "--volume-driver", driverName, "busybox:latest"); err != nil { 407 errchan <- fmt.Errorf("%v:\n%s", err, out) 408 } 409 close(errchan) 410 }() 411 412 <-started 413 // wait for a retry to occur, then create spec to allow plugin to register 414 time.Sleep(2 * time.Second) 415 p := newVolumePlugin(c, driverName) 416 defer p.Close() 417 418 select { 419 case err := <-errchan: 420 assert.NilError(c, err) 421 case <-time.After(8 * time.Second): 422 c.Fatal("volume creates fail when plugin not immediately available") 423 } 424 425 _, err := s.d.Cmd("volume", "rm", "external-volume-test") 426 assert.NilError(c, err) 427 428 assert.Equal(c, p.ec.activations, 1) 429 assert.Equal(c, p.ec.creations, 1) 430 assert.Equal(c, p.ec.removals, 1) 431 assert.Equal(c, p.ec.mounts, 1) 432 assert.Equal(c, p.ec.unmounts, 1) 433 } 434 435 func (s *DockerExternalVolumeSuite) TestExternalVolumeDriverBindExternalVolume(c *testing.T) { 436 dockerCmd(c, "volume", "create", "-d", volumePluginName, "foo") 437 dockerCmd(c, "run", "-d", "--name", "testing", "-v", "foo:/bar", "busybox", "top") 438 439 var mounts []struct { 440 Name string 441 Driver string 442 } 443 out := inspectFieldJSON(c, "testing", "Mounts") 444 assert.Assert(c, json.NewDecoder(strings.NewReader(out)).Decode(&mounts) == nil) 445 assert.Equal(c, len(mounts), 1, fmt.Sprintf("%s", out)) 446 assert.Equal(c, mounts[0].Name, "foo") 447 assert.Equal(c, mounts[0].Driver, volumePluginName) 448 } 449 450 func (s *DockerExternalVolumeSuite) TestExternalVolumeDriverList(c *testing.T) { 451 dockerCmd(c, "volume", "create", "-d", volumePluginName, "abc3") 452 out, _ := dockerCmd(c, "volume", "ls") 453 ls := strings.Split(strings.TrimSpace(out), "\n") 454 assert.Equal(c, len(ls), 2, fmt.Sprintf("\n%s", out)) 455 456 vol := strings.Fields(ls[len(ls)-1]) 457 assert.Equal(c, len(vol), 2, fmt.Sprintf("%v", vol)) 458 assert.Equal(c, vol[0], volumePluginName) 459 assert.Equal(c, vol[1], "abc3") 460 461 assert.Equal(c, s.ec.lists, 1) 462 } 463 464 func (s *DockerExternalVolumeSuite) TestExternalVolumeDriverGet(c *testing.T) { 465 out, _, err := dockerCmdWithError("volume", "inspect", "dummy") 466 assert.ErrorContains(c, err, "", out) 467 assert.Assert(c, strings.Contains(out, "No such volume")) 468 assert.Equal(c, s.ec.gets, 1) 469 470 dockerCmd(c, "volume", "create", "test", "-d", volumePluginName) 471 out, _ = dockerCmd(c, "volume", "inspect", "test") 472 473 type vol struct { 474 Status map[string]string 475 } 476 var st []vol 477 478 assert.Assert(c, json.Unmarshal([]byte(out), &st) == nil) 479 assert.Equal(c, len(st), 1) 480 assert.Equal(c, len(st[0].Status), 1, fmt.Sprintf("%v", st[0])) 481 assert.Equal(c, st[0].Status["Hello"], "world", fmt.Sprintf("%v", st[0].Status)) 482 } 483 484 func (s *DockerExternalVolumeSuite) TestExternalVolumeDriverWithDaemonRestart(c *testing.T) { 485 dockerCmd(c, "volume", "create", "-d", volumePluginName, "abc1") 486 s.d.Restart(c) 487 488 dockerCmd(c, "run", "--name=test", "-v", "abc1:/foo", "busybox", "true") 489 var mounts []types.MountPoint 490 inspectFieldAndUnmarshall(c, "test", "Mounts", &mounts) 491 assert.Equal(c, len(mounts), 1) 492 assert.Equal(c, mounts[0].Driver, volumePluginName) 493 } 494 495 // Ensures that the daemon handles when the plugin responds to a `Get` request with a null volume and a null error. 496 // Prior the daemon would panic in this scenario. 497 func (s *DockerExternalVolumeSuite) TestExternalVolumeDriverGetEmptyResponse(c *testing.T) { 498 s.d.Start(c) 499 500 out, err := s.d.Cmd("volume", "create", "-d", volumePluginName, "abc2", "--opt", "ninja=1") 501 assert.NilError(c, err, out) 502 503 out, err = s.d.Cmd("volume", "inspect", "abc2") 504 assert.ErrorContains(c, err, "", out) 505 assert.Assert(c, strings.Contains(out, "No such volume")) 506 } 507 508 // Ensure only cached paths are used in volume list to prevent N+1 calls to `VolumeDriver.Path` 509 // 510 // TODO(@cpuguy83): This test is testing internal implementation. In all the cases here, there may not even be a path 511 // available because the volume is not even mounted. Consider removing this test. 512 func (s *DockerExternalVolumeSuite) TestExternalVolumeDriverPathCalls(c *testing.T) { 513 s.d.Start(c) 514 assert.Equal(c, s.ec.paths, 0) 515 516 out, err := s.d.Cmd("volume", "create", "test", "--driver=test-external-volume-driver") 517 assert.NilError(c, err, out) 518 assert.Equal(c, s.ec.paths, 0) 519 520 out, err = s.d.Cmd("volume", "ls") 521 assert.NilError(c, err, out) 522 assert.Equal(c, s.ec.paths, 0) 523 } 524 525 func (s *DockerExternalVolumeSuite) TestExternalVolumeDriverMountID(c *testing.T) { 526 s.d.StartWithBusybox(c) 527 528 out, err := s.d.Cmd("run", "--rm", "-v", "external-volume-test:/tmp/external-volume-test", "--volume-driver", volumePluginName, "busybox:latest", "cat", "/tmp/external-volume-test/test") 529 assert.NilError(c, err, out) 530 assert.Assert(c, strings.TrimSpace(out) != "") 531 } 532 533 // Check that VolumeDriver.Capabilities gets called, and only called once 534 func (s *DockerExternalVolumeSuite) TestExternalVolumeDriverCapabilities(c *testing.T) { 535 s.d.Start(c) 536 assert.Equal(c, s.ec.caps, 0) 537 538 for i := 0; i < 3; i++ { 539 out, err := s.d.Cmd("volume", "create", "-d", volumePluginName, fmt.Sprintf("test%d", i)) 540 assert.NilError(c, err, out) 541 assert.Equal(c, s.ec.caps, 1) 542 out, err = s.d.Cmd("volume", "inspect", "--format={{.Scope}}", fmt.Sprintf("test%d", i)) 543 assert.NilError(c, err) 544 assert.Equal(c, strings.TrimSpace(out), volume.GlobalScope) 545 } 546 } 547 548 func (s *DockerExternalVolumeSuite) TestExternalVolumeDriverOutOfBandDelete(c *testing.T) { 549 driverName := stringid.GenerateRandomID() 550 p := newVolumePlugin(c, driverName) 551 defer p.Close() 552 553 s.d.StartWithBusybox(c) 554 555 out, err := s.d.Cmd("volume", "create", "-d", driverName, "--name", "test") 556 assert.NilError(c, err, out) 557 558 out, err = s.d.Cmd("volume", "create", "-d", "local", "--name", "test") 559 assert.ErrorContains(c, err, "", out) 560 assert.Assert(c, strings.Contains(out, "must be unique")) 561 // simulate out of band volume deletion on plugin level 562 delete(p.vols, "test") 563 564 // test re-create with same driver 565 out, err = s.d.Cmd("volume", "create", "-d", driverName, "--opt", "foo=bar", "--name", "test") 566 assert.NilError(c, err, out) 567 out, err = s.d.Cmd("volume", "inspect", "test") 568 assert.NilError(c, err, out) 569 570 var vs []types.Volume 571 err = json.Unmarshal([]byte(out), &vs) 572 assert.NilError(c, err) 573 assert.Equal(c, len(vs), 1) 574 assert.Equal(c, vs[0].Driver, driverName) 575 assert.Assert(c, vs[0].Options != nil) 576 assert.Equal(c, vs[0].Options["foo"], "bar") 577 assert.Equal(c, vs[0].Driver, driverName) 578 579 // simulate out of band volume deletion on plugin level 580 delete(p.vols, "test") 581 582 // test create with different driver 583 out, err = s.d.Cmd("volume", "create", "-d", "local", "--name", "test") 584 assert.NilError(c, err, out) 585 586 out, err = s.d.Cmd("volume", "inspect", "test") 587 assert.NilError(c, err, out) 588 vs = nil 589 err = json.Unmarshal([]byte(out), &vs) 590 assert.NilError(c, err) 591 assert.Equal(c, len(vs), 1) 592 assert.Equal(c, len(vs[0].Options), 0) 593 assert.Equal(c, vs[0].Driver, "local") 594 } 595 596 func (s *DockerExternalVolumeSuite) TestExternalVolumeDriverUnmountOnMountFail(c *testing.T) { 597 s.d.StartWithBusybox(c) 598 s.d.Cmd("volume", "create", "-d", "test-external-volume-driver", "--opt=invalidOption=1", "--name=testumount") 599 600 out, _ := s.d.Cmd("run", "-v", "testumount:/foo", "busybox", "true") 601 assert.Equal(c, s.ec.unmounts, 0, fmt.Sprintf("%s", out)) 602 out, _ = s.d.Cmd("run", "-w", "/foo", "-v", "testumount:/foo", "busybox", "true") 603 assert.Equal(c, s.ec.unmounts, 0, fmt.Sprintf("%s", out)) 604 } 605 606 func (s *DockerExternalVolumeSuite) TestExternalVolumeDriverUnmountOnCp(c *testing.T) { 607 s.d.StartWithBusybox(c) 608 s.d.Cmd("volume", "create", "-d", "test-external-volume-driver", "--name=test") 609 610 out, _ := s.d.Cmd("run", "-d", "--name=test", "-v", "test:/foo", "busybox", "/bin/sh", "-c", "touch /test && top") 611 assert.Equal(c, s.ec.mounts, 1, fmt.Sprintf("%s", out)) 612 613 out, _ = s.d.Cmd("cp", "test:/test", "/tmp/test") 614 assert.Equal(c, s.ec.mounts, 2, fmt.Sprintf("%s", out)) 615 assert.Equal(c, s.ec.unmounts, 1, fmt.Sprintf("%s", out)) 616 617 out, _ = s.d.Cmd("kill", "test") 618 assert.Equal(c, s.ec.unmounts, 2, fmt.Sprintf("%s", out)) 619 }