integration-cli: DockerCLIVolumeSuite: replace dockerCmd

Signed-off-by: Sebastiaan van Stijn <github@gone.nl>

integration-cli/docker_cli_volume_test.go

@@ -13,6 +13,7 @@ import (
 	"github.com/docker/docker/api/types/mount"
 	"github.com/docker/docker/api/types/network"
 	"github.com/docker/docker/client"
+	"github.com/docker/docker/integration-cli/cli"
 	"github.com/docker/docker/integration-cli/cli/build"
 	"github.com/docker/docker/testutil"
 	"gotest.tools/v3/assert"
@@ -32,37 +33,37 @@ func (s *DockerCLIVolumeSuite) OnTimeout(c *testing.T) {
 }
 
 func (s *DockerCLIVolumeSuite) TestVolumeCLICreate(c *testing.T) {
-	dockerCmd(c, "volume", "create")
+	cli.DockerCmd(c, "volume", "create")
 
 	_, _, err := dockerCmdWithError("volume", "create", "-d", "nosuchdriver")
 	assert.ErrorContains(c, err, "")
 
 	// test using hidden --name option
-	out, _ := dockerCmd(c, "volume", "create", "--name=test")
-	name := strings.TrimSpace(out)
+	name := cli.DockerCmd(c, "volume", "create", "--name=test").Stdout()
+	name = strings.TrimSpace(name)
 	assert.Equal(c, name, "test")
 
-	out, _ = dockerCmd(c, "volume", "create", "test2")
-	name = strings.TrimSpace(out)
+	name = cli.DockerCmd(c, "volume", "create", "test2").Stdout()
+	name = strings.TrimSpace(name)
 	assert.Equal(c, name, "test2")
 }
 
 func (s *DockerCLIVolumeSuite) TestVolumeCLIInspect(c *testing.T) {
 	assert.Assert(c, exec.Command(dockerBinary, "volume", "inspect", "doesnotexist").Run() != nil, "volume inspect should error on non-existent volume")
-	out, _ := dockerCmd(c, "volume", "create")
-	name := strings.TrimSpace(out)
-	out, _ = dockerCmd(c, "volume", "inspect", "--format={{ .Name }}", name)
+	name := cli.DockerCmd(c, "volume", "create").Stdout()
+	name = strings.TrimSpace(name)
+	out := cli.DockerCmd(c, "volume", "inspect", "--format={{ .Name }}", name).Stdout()
 	assert.Equal(c, strings.TrimSpace(out), name)
 
-	dockerCmd(c, "volume", "create", "test")
-	out, _ = dockerCmd(c, "volume", "inspect", "--format={{ .Name }}", "test")
+	cli.DockerCmd(c, "volume", "create", "test")
+	out = cli.DockerCmd(c, "volume", "inspect", "--format={{ .Name }}", "test").Stdout()
 	assert.Equal(c, strings.TrimSpace(out), "test")
 }
 
 func (s *DockerCLIVolumeSuite) TestVolumeCLIInspectMulti(c *testing.T) {
-	dockerCmd(c, "volume", "create", "test1")
-	dockerCmd(c, "volume", "create", "test2")
-	dockerCmd(c, "volume", "create", "test3")
+	cli.DockerCmd(c, "volume", "create", "test1")
+	cli.DockerCmd(c, "volume", "create", "test2")
+	cli.DockerCmd(c, "volume", "create", "test3")
 
 	result := dockerCmdWithResult("volume", "inspect", "--format={{ .Name }}", "test1", "test2", "doesnotexist", "test3")
 	result.Assert(c, icmd.Expected{
@@ -78,32 +79,32 @@ func (s *DockerCLIVolumeSuite) TestVolumeCLIInspectMulti(c *testing.T) {
 
 func (s *DockerCLIVolumeSuite) TestVolumeCLILs(c *testing.T) {
 	prefix, _ := getPrefixAndSlashFromDaemonPlatform()
-	dockerCmd(c, "volume", "create", "aaa")
+	cli.DockerCmd(c, "volume", "create", "aaa")
 
-	dockerCmd(c, "volume", "create", "test")
+	cli.DockerCmd(c, "volume", "create", "test")
 
-	dockerCmd(c, "volume", "create", "soo")
-	dockerCmd(c, "run", "-v", "soo:"+prefix+"/foo", "busybox", "ls", "/")
+	cli.DockerCmd(c, "volume", "create", "soo")
+	cli.DockerCmd(c, "run", "-v", "soo:"+prefix+"/foo", "busybox", "ls", "/")
 
-	out, _ := dockerCmd(c, "volume", "ls", "-q")
+	out := cli.DockerCmd(c, "volume", "ls", "-q").Stdout()
 	assertVolumesInList(c, out, []string{"aaa", "soo", "test"})
 }
 
 func (s *DockerCLIVolumeSuite) TestVolumeLsFormat(c *testing.T) {
-	dockerCmd(c, "volume", "create", "aaa")
-	dockerCmd(c, "volume", "create", "test")
-	dockerCmd(c, "volume", "create", "soo")
+	cli.DockerCmd(c, "volume", "create", "aaa")
+	cli.DockerCmd(c, "volume", "create", "test")
+	cli.DockerCmd(c, "volume", "create", "soo")
 
-	out, _ := dockerCmd(c, "volume", "ls", "--format", "{{.Name}}")
+	out := cli.DockerCmd(c, "volume", "ls", "--format", "{{.Name}}").Stdout()
 	assertVolumesInList(c, out, []string{"aaa", "soo", "test"})
 }
 
 func (s *DockerCLIVolumeSuite) TestVolumeLsFormatDefaultFormat(c *testing.T) {
-	dockerCmd(c, "volume", "create", "aaa")
-	dockerCmd(c, "volume", "create", "test")
-	dockerCmd(c, "volume", "create", "soo")
+	cli.DockerCmd(c, "volume", "create", "aaa")
+	cli.DockerCmd(c, "volume", "create", "test")
+	cli.DockerCmd(c, "volume", "create", "soo")
 
-	config := `{
+	const config = `{
 		"volumesFormat": "{{ .Name }} default"
 }`
 	d, err := os.MkdirTemp("", "integration-cli-")
@@ -113,7 +114,7 @@ func (s *DockerCLIVolumeSuite) TestVolumeLsFormatDefaultFormat(c *testing.T) {
 	err = os.WriteFile(filepath.Join(d, "config.json"), []byte(config), 0o644)
 	assert.NilError(c, err)
 
-	out, _ := dockerCmd(c, "--config", d, "volume", "ls")
+	out := cli.DockerCmd(c, "--config", d, "volume", "ls").Stdout()
 	assertVolumesInList(c, out, []string{"aaa default", "soo default", "test default"})
 }
 
@@ -133,44 +134,46 @@ func assertVolumesInList(c *testing.T, out string, expected []string) {
 
 func (s *DockerCLIVolumeSuite) TestVolumeCLILsFilterDangling(c *testing.T) {
 	prefix, _ := getPrefixAndSlashFromDaemonPlatform()
-	dockerCmd(c, "volume", "create", "testnotinuse1")
-	dockerCmd(c, "volume", "create", "testisinuse1")
-	dockerCmd(c, "volume", "create", "testisinuse2")
+	cli.DockerCmd(c, "volume", "create", "testnotinuse1")
+	cli.DockerCmd(c, "volume", "create", "testisinuse1")
+	cli.DockerCmd(c, "volume", "create", "testisinuse2")
 
 	// Make sure both "created" (but not started), and started
 	// containers are included in reference counting
-	dockerCmd(c, "run", "--name", "volume-test1", "-v", "testisinuse1:"+prefix+"/foo", "busybox", "true")
-	dockerCmd(c, "create", "--name", "volume-test2", "-v", "testisinuse2:"+prefix+"/foo", "busybox", "true")
-
-	out, _ := dockerCmd(c, "volume", "ls")
+	cli.DockerCmd(c, "run", "--name", "volume-test1", "-v", "testisinuse1:"+prefix+"/foo", "busybox", "true")
+	cli.DockerCmd(c, "create", "--name", "volume-test2", "-v", "testisinuse2:"+prefix+"/foo", "busybox", "true")
 
 	// No filter, all volumes should show
+	out := cli.DockerCmd(c, "volume", "ls").Stdout()
 	assert.Assert(c, strings.Contains(out, "testnotinuse1\n"), "expected volume 'testnotinuse1' in output")
 	assert.Assert(c, strings.Contains(out, "testisinuse1\n"), "expected volume 'testisinuse1' in output")
 	assert.Assert(c, strings.Contains(out, "testisinuse2\n"), "expected volume 'testisinuse2' in output")
-	out, _ = dockerCmd(c, "volume", "ls", "--filter", "dangling=false")
 
 	// Explicitly disabling dangling
+	out = cli.DockerCmd(c, "volume", "ls", "--filter", "dangling=false").Stdout()
 	assert.Assert(c, !strings.Contains(out, "testnotinuse1\n"), "expected volume 'testnotinuse1' in output")
 	assert.Assert(c, strings.Contains(out, "testisinuse1\n"), "expected volume 'testisinuse1' in output")
 	assert.Assert(c, strings.Contains(out, "testisinuse2\n"), "expected volume 'testisinuse2' in output")
-	out, _ = dockerCmd(c, "volume", "ls", "--filter", "dangling=true")
 
 	// Filter "dangling" volumes; only "dangling" (unused) volumes should be in the output
+	out = cli.DockerCmd(c, "volume", "ls", "--filter", "dangling=true").Stdout()
 	assert.Assert(c, strings.Contains(out, "testnotinuse1\n"), "expected volume 'testnotinuse1' in output")
 	assert.Assert(c, !strings.Contains(out, "testisinuse1\n"), "volume 'testisinuse1' in output, but not expected")
 	assert.Assert(c, !strings.Contains(out, "testisinuse2\n"), "volume 'testisinuse2' in output, but not expected")
-	out, _ = dockerCmd(c, "volume", "ls", "--filter", "dangling=1")
+
 	// Filter "dangling" volumes; only "dangling" (unused) volumes should be in the output, dangling also accept 1
+	out = cli.DockerCmd(c, "volume", "ls", "--filter", "dangling=1").Stdout()
 	assert.Assert(c, strings.Contains(out, "testnotinuse1\n"), "expected volume 'testnotinuse1' in output")
 	assert.Assert(c, !strings.Contains(out, "testisinuse1\n"), "volume 'testisinuse1' in output, but not expected")
 	assert.Assert(c, !strings.Contains(out, "testisinuse2\n"), "volume 'testisinuse2' in output, but not expected")
-	out, _ = dockerCmd(c, "volume", "ls", "--filter", "dangling=0")
+
 	// dangling=0 is same as dangling=false case
+	out = cli.DockerCmd(c, "volume", "ls", "--filter", "dangling=0").Stdout()
 	assert.Assert(c, !strings.Contains(out, "testnotinuse1\n"), "expected volume 'testnotinuse1' in output")
 	assert.Assert(c, strings.Contains(out, "testisinuse1\n"), "expected volume 'testisinuse1' in output")
 	assert.Assert(c, strings.Contains(out, "testisinuse2\n"), "expected volume 'testisinuse2' in output")
-	out, _ = dockerCmd(c, "volume", "ls", "--filter", "name=testisin")
+
+	out = cli.DockerCmd(c, "volume", "ls", "--filter", "name=testisin").Stdout()
 	assert.Assert(c, !strings.Contains(out, "testnotinuse1\n"), "expected volume 'testnotinuse1' in output")
 	assert.Assert(c, strings.Contains(out, "testisinuse1\n"), "expected volume 'testisinuse1' in output")
 	assert.Assert(c, strings.Contains(out, "testisinuse2\n"), "expected volume 'testisinuse2' in output")
@@ -190,38 +193,38 @@ func (s *DockerCLIVolumeSuite) TestVolumeCLILsWithIncorrectFilterValue(c *testin
 
 func (s *DockerCLIVolumeSuite) TestVolumeCLIRm(c *testing.T) {
 	prefix, _ := getPrefixAndSlashFromDaemonPlatform()
-	out, _ := dockerCmd(c, "volume", "create")
-	id := strings.TrimSpace(out)
+	id := cli.DockerCmd(c, "volume", "create").Stdout()
+	id = strings.TrimSpace(id)
 
-	dockerCmd(c, "volume", "create", "test")
-	dockerCmd(c, "volume", "rm", id)
-	dockerCmd(c, "volume", "rm", "test")
+	cli.DockerCmd(c, "volume", "create", "test")
+	cli.DockerCmd(c, "volume", "rm", id)
+	cli.DockerCmd(c, "volume", "rm", "test")
 
 	volumeID := "testing"
-	dockerCmd(c, "run", "-v", volumeID+":"+prefix+"/foo", "--name=test", "busybox", "sh", "-c", "echo hello > /foo/bar")
+	cli.DockerCmd(c, "run", "-v", volumeID+":"+prefix+"/foo", "--name=test", "busybox", "sh", "-c", "echo hello > /foo/bar")
 
 	icmd.RunCommand(dockerBinary, "volume", "rm", "testing").Assert(c, icmd.Expected{
 		ExitCode: 1,
 		Error:    "exit status 1",
 	})
 
-	out, _ = dockerCmd(c, "run", "--volumes-from=test", "--name=test2", "busybox", "sh", "-c", "cat /foo/bar")
+	out := cli.DockerCmd(c, "run", "--volumes-from=test", "--name=test2", "busybox", "sh", "-c", "cat /foo/bar").Combined()
 	assert.Equal(c, strings.TrimSpace(out), "hello")
-	dockerCmd(c, "rm", "-fv", "test2")
-	dockerCmd(c, "volume", "inspect", volumeID)
-	dockerCmd(c, "rm", "-f", "test")
+	cli.DockerCmd(c, "rm", "-fv", "test2")
+	cli.DockerCmd(c, "volume", "inspect", volumeID)
+	cli.DockerCmd(c, "rm", "-f", "test")
 
-	out, _ = dockerCmd(c, "run", "--name=test2", "-v", volumeID+":"+prefix+"/foo", "busybox", "sh", "-c", "cat /foo/bar")
+	out = cli.DockerCmd(c, "run", "--name=test2", "-v", volumeID+":"+prefix+"/foo", "busybox", "sh", "-c", "cat /foo/bar").Combined()
 	assert.Equal(c, strings.TrimSpace(out), "hello", "volume data was removed")
-	dockerCmd(c, "rm", "test2")
+	cli.DockerCmd(c, "rm", "test2")
 
-	dockerCmd(c, "volume", "rm", volumeID)
+	cli.DockerCmd(c, "volume", "rm", volumeID)
 	assert.Assert(c, exec.Command("volume", "rm", "doesnotexist").Run() != nil, "volume rm should fail with non-existent volume")
 }
 
 // FIXME(vdemeester) should be a unit test in cli/command/volume package
 func (s *DockerCLIVolumeSuite) TestVolumeCLINoArgs(c *testing.T) {
-	out, _ := dockerCmd(c, "volume")
+	out := cli.DockerCmd(c, "volume").Combined()
 	// no args should produce the cmd usage output
 	usage := "Usage:	docker volume COMMAND"
 	assert.Assert(c, strings.Contains(out, usage))
@@ -243,8 +246,8 @@ func (s *DockerCLIVolumeSuite) TestVolumeCLINoArgs(c *testing.T) {
 }
 
 func (s *DockerCLIVolumeSuite) TestVolumeCLIInspectTmplError(c *testing.T) {
-	out, _ := dockerCmd(c, "volume", "create")
-	name := strings.TrimSpace(out)
+	name := cli.DockerCmd(c, "volume", "create").Stdout()
+	name = strings.TrimSpace(name)
 
 	out, exitCode, err := dockerCmdWithError("volume", "inspect", "--format='{{ .FooBar }}'", name)
 	assert.Assert(c, err != nil, "Output: %s", out)
@@ -255,9 +258,9 @@ func (s *DockerCLIVolumeSuite) TestVolumeCLIInspectTmplError(c *testing.T) {
 func (s *DockerCLIVolumeSuite) TestVolumeCLICreateWithOpts(c *testing.T) {
 	testRequires(c, DaemonIsLinux)
 
-	dockerCmd(c, "volume", "create", "-d", "local", "test", "--opt=type=tmpfs", "--opt=device=tmpfs", "--opt=o=size=1m,uid=1000")
-	out, _ := dockerCmd(c, "run", "-v", "test:/foo", "busybox", "mount")
+	cli.DockerCmd(c, "volume", "create", "-d", "local", "test", "--opt=type=tmpfs", "--opt=device=tmpfs", "--opt=o=size=1m,uid=1000")
 
+	out := cli.DockerCmd(c, "run", "-v", "test:/foo", "busybox", "mount").Stdout()
 	mounts := strings.Split(out, "\n")
 	var found bool
 	for _, m := range mounts {
@@ -277,19 +280,19 @@ func (s *DockerCLIVolumeSuite) TestVolumeCLICreateWithOpts(c *testing.T) {
 }
 
 func (s *DockerCLIVolumeSuite) TestVolumeCLICreateLabel(c *testing.T) {
-	testVol := "testvolcreatelabel"
-	testLabel := "foo"
-	testValue := "bar"
+	const testVol = "testvolcreatelabel"
+	const testLabel = "foo"
+	const testValue = "bar"
 
 	_, _, err := dockerCmdWithError("volume", "create", "--label", testLabel+"="+testValue, testVol)
 	assert.NilError(c, err)
 
-	out, _ := dockerCmd(c, "volume", "inspect", "--format={{ .Labels."+testLabel+" }}", testVol)
+	out := cli.DockerCmd(c, "volume", "inspect", "--format={{ .Labels."+testLabel+" }}", testVol).Stdout()
 	assert.Equal(c, strings.TrimSpace(out), testValue)
 }
 
 func (s *DockerCLIVolumeSuite) TestVolumeCLICreateLabelMultiple(c *testing.T) {
-	testVol := "testvolcreatelabel"
+	const testVol = "testvolcreatelabel"
 
 	testLabels := map[string]string{
 		"foo": "bar",
@@ -310,7 +313,7 @@ func (s *DockerCLIVolumeSuite) TestVolumeCLICreateLabelMultiple(c *testing.T) {
 	assert.NilError(c, err)
 
 	for k, v := range testLabels {
-		out, _ := dockerCmd(c, "volume", "inspect", "--format={{ .Labels."+k+" }}", testVol)
+		out := cli.DockerCmd(c, "volume", "inspect", "--format={{ .Labels."+k+" }}", testVol).Stdout()
 		assert.Equal(c, strings.TrimSpace(out), v)
 	}
 }
@@ -324,21 +327,21 @@ func (s *DockerCLIVolumeSuite) TestVolumeCLILsFilterLabels(c *testing.T) {
 	_, _, err = dockerCmdWithError("volume", "create", "--label", "foo=bar2", testVol2)
 	assert.NilError(c, err)
 
-	out, _ := dockerCmd(c, "volume", "ls", "--filter", "label=foo")
-
 	// filter with label=key
+	out := cli.DockerCmd(c, "volume", "ls", "--filter", "label=foo").Stdout()
 	assert.Assert(c, strings.Contains(out, "testvolcreatelabel-1\n"), "expected volume 'testvolcreatelabel-1' in output")
 	assert.Assert(c, strings.Contains(out, "testvolcreatelabel-2\n"), "expected volume 'testvolcreatelabel-2' in output")
-	out, _ = dockerCmd(c, "volume", "ls", "--filter", "label=foo=bar1")
 
 	// filter with label=key=value
+	out = cli.DockerCmd(c, "volume", "ls", "--filter", "label=foo=bar1").Stdout()
 	assert.Assert(c, strings.Contains(out, "testvolcreatelabel-1\n"), "expected volume 'testvolcreatelabel-1' in output")
 	assert.Assert(c, !strings.Contains(out, "testvolcreatelabel-2\n"), "expected volume 'testvolcreatelabel-2 in output")
-	out, _ = dockerCmd(c, "volume", "ls", "--filter", "label=non-exist")
+
+	out = cli.DockerCmd(c, "volume", "ls", "--filter", "label=non-exist").Stdout()
 	outArr := strings.Split(strings.TrimSpace(out), "\n")
 	assert.Equal(c, len(outArr), 1, fmt.Sprintf("\n%s", out))
 
-	out, _ = dockerCmd(c, "volume", "ls", "--filter", "label=foo=non-exist")
+	out = cli.DockerCmd(c, "volume", "ls", "--filter", "label=foo=non-exist").Stdout()
 	outArr = strings.Split(strings.TrimSpace(out), "\n")
 	assert.Equal(c, len(outArr), 1, fmt.Sprintf("\n%s", out))
 }
@@ -354,71 +357,72 @@ func (s *DockerCLIVolumeSuite) TestVolumeCLILsFilterDrivers(c *testing.T) {
 	assert.NilError(c, err)
 
 	// filter with driver=local
-	out, _ := dockerCmd(c, "volume", "ls", "--filter", "driver=local")
+	out := cli.DockerCmd(c, "volume", "ls", "--filter", "driver=local").Stdout()
 	assert.Assert(c, strings.Contains(out, "testvol-1\n"), "expected volume 'testvol-1' in output")
 	assert.Assert(c, strings.Contains(out, "testvol-2\n"), "expected volume 'testvol-2' in output")
+
 	// filter with driver=invaliddriver
-	out, _ = dockerCmd(c, "volume", "ls", "--filter", "driver=invaliddriver")
+	out = cli.DockerCmd(c, "volume", "ls", "--filter", "driver=invaliddriver").Stdout()
 	outArr := strings.Split(strings.TrimSpace(out), "\n")
 	assert.Equal(c, len(outArr), 1, fmt.Sprintf("\n%s", out))
 
 	// filter with driver=loca
-	out, _ = dockerCmd(c, "volume", "ls", "--filter", "driver=loca")
+	out = cli.DockerCmd(c, "volume", "ls", "--filter", "driver=loca").Stdout()
 	outArr = strings.Split(strings.TrimSpace(out), "\n")
 	assert.Equal(c, len(outArr), 1, fmt.Sprintf("\n%s", out))
 
 	// filter with driver=
-	out, _ = dockerCmd(c, "volume", "ls", "--filter", "driver=")
+	out = cli.DockerCmd(c, "volume", "ls", "--filter", "driver=").Stdout()
 	outArr = strings.Split(strings.TrimSpace(out), "\n")
 	assert.Equal(c, len(outArr), 1, fmt.Sprintf("\n%s", out))
 }
 
 func (s *DockerCLIVolumeSuite) TestVolumeCLIRmForceUsage(c *testing.T) {
-	out, _ := dockerCmd(c, "volume", "create")
-	id := strings.TrimSpace(out)
+	id := cli.DockerCmd(c, "volume", "create").Stdout()
+	id = strings.TrimSpace(id)
 
-	dockerCmd(c, "volume", "rm", "-f", id)
-	dockerCmd(c, "volume", "rm", "--force", "nonexist")
+	cli.DockerCmd(c, "volume", "rm", "-f", id)
+	cli.DockerCmd(c, "volume", "rm", "--force", "nonexist")
 }
 
 func (s *DockerCLIVolumeSuite) TestVolumeCLIRmForce(c *testing.T) {
 	testRequires(c, testEnv.IsLocalDaemon, DaemonIsLinux)
 
-	name := "test"
-	out, _ := dockerCmd(c, "volume", "create", name)
-	id := strings.TrimSpace(out)
+	const name = "test"
+	id := cli.DockerCmd(c, "volume", "create", name).Stdout()
+	id = strings.TrimSpace(id)
 	assert.Equal(c, id, name)
 
-	out, _ = dockerCmd(c, "volume", "inspect", "--format", "{{.Mountpoint}}", name)
+	out := cli.DockerCmd(c, "volume", "inspect", "--format", "{{.Mountpoint}}", name).Stdout()
 	assert.Assert(c, strings.TrimSpace(out) != "")
 	// Mountpoint is in the form of "/var/lib/docker/volumes/.../_data", removing `/_data`
 	path := strings.TrimSuffix(strings.TrimSpace(out), "/_data")
 	icmd.RunCommand("rm", "-rf", path).Assert(c, icmd.Success)
 
-	dockerCmd(c, "volume", "rm", "-f", name)
-	out, _ = dockerCmd(c, "volume", "ls")
+	cli.DockerCmd(c, "volume", "rm", "-f", name)
+	out = cli.DockerCmd(c, "volume", "ls").Stdout()
 	assert.Assert(c, !strings.Contains(out, name))
-	dockerCmd(c, "volume", "create", name)
-	out, _ = dockerCmd(c, "volume", "ls")
+	cli.DockerCmd(c, "volume", "create", name)
+	out = cli.DockerCmd(c, "volume", "ls").Stdout()
 	assert.Assert(c, strings.Contains(out, name))
 }
 
 // TestVolumeCLIRmForceInUse verifies that repeated `docker volume rm -f` calls does not remove a volume
 // if it is in use. Test case for https://github.com/docker/docker/issues/31446
 func (s *DockerCLIVolumeSuite) TestVolumeCLIRmForceInUse(c *testing.T) {
-	name := "testvolume"
-	out, _ := dockerCmd(c, "volume", "create", name)
-	id := strings.TrimSpace(out)
+	const name = "testvolume"
+	id := cli.DockerCmd(c, "volume", "create", name).Stdout()
+	id = strings.TrimSpace(id)
 	assert.Equal(c, id, name)
 
 	prefix, slash := getPrefixAndSlashFromDaemonPlatform()
-	out, _ = dockerCmd(c, "create", "-v", "testvolume:"+prefix+slash+"foo", "busybox")
-	cid := strings.TrimSpace(out)
+	cid := cli.DockerCmd(c, "create", "-v", "testvolume:"+prefix+slash+"foo", "busybox").Stdout()
+	cid = strings.TrimSpace(cid)
 
 	_, _, err := dockerCmdWithError("volume", "rm", "-f", name)
 	assert.ErrorContains(c, err, "")
 	assert.ErrorContains(c, err, "volume is in use")
-	out, _ = dockerCmd(c, "volume", "ls")
+	out := cli.DockerCmd(c, "volume", "ls").Stdout()
 	assert.Assert(c, strings.Contains(out, name))
 	// The original issue did not _remove_ the volume from the list
 	// the first time. But a second call to `volume rm` removed it.
@@ -427,18 +431,18 @@ func (s *DockerCLIVolumeSuite) TestVolumeCLIRmForceInUse(c *testing.T) {
 	_, _, err = dockerCmdWithError("volume", "rm", "-f", name)
 	assert.ErrorContains(c, err, "")
 	assert.ErrorContains(c, err, "volume is in use")
-	out, _ = dockerCmd(c, "volume", "ls")
+	out = cli.DockerCmd(c, "volume", "ls").Stdout()
 	assert.Assert(c, strings.Contains(out, name))
 	// Verify removing the volume after the container is removed works
-	_, e := dockerCmd(c, "rm", cid)
+	e := cli.DockerCmd(c, "rm", cid).ExitCode
 	assert.Equal(c, e, 0)
 
-	_, e = dockerCmd(c, "volume", "rm", "-f", name)
+	e = cli.DockerCmd(c, "volume", "rm", "-f", name).ExitCode
 	assert.Equal(c, e, 0)
 
-	out, e = dockerCmd(c, "volume", "ls")
-	assert.Equal(c, e, 0)
-	assert.Assert(c, !strings.Contains(out, name))
+	result := cli.DockerCmd(c, "volume", "ls")
+	assert.Equal(c, result.ExitCode, 0)
+	assert.Assert(c, !strings.Contains(result.Stdout(), name))
 }
 
 func (s *DockerCLIVolumeSuite) TestVolumeCliInspectWithVolumeOpts(c *testing.T) {
@@ -446,16 +450,16 @@ func (s *DockerCLIVolumeSuite) TestVolumeCliInspectWithVolumeOpts(c *testing.T)
 
 	// Without options
 	name := "test1"
-	dockerCmd(c, "volume", "create", "-d", "local", name)
-	out, _ := dockerCmd(c, "volume", "inspect", "--format={{ .Options }}", name)
+	cli.DockerCmd(c, "volume", "create", "-d", "local", name)
+	out := cli.DockerCmd(c, "volume", "inspect", "--format={{ .Options }}", name).Stdout()
 	assert.Assert(c, strings.Contains(strings.TrimSpace(out), "map[]"))
 	// With options
 	name = "test2"
 	k1, v1 := "type", "tmpfs"
 	k2, v2 := "device", "tmpfs"
 	k3, v3 := "o", "size=1m,uid=1000"
-	dockerCmd(c, "volume", "create", "-d", "local", name, "--opt", fmt.Sprintf("%s=%s", k1, v1), "--opt", fmt.Sprintf("%s=%s", k2, v2), "--opt", fmt.Sprintf("%s=%s", k3, v3))
-	out, _ = dockerCmd(c, "volume", "inspect", "--format={{ .Options }}", name)
+	cli.DockerCmd(c, "volume", "create", "-d", "local", name, "--opt", fmt.Sprintf("%s=%s", k1, v1), "--opt", fmt.Sprintf("%s=%s", k2, v2), "--opt", fmt.Sprintf("%s=%s", k3, v3))
+	out = cli.DockerCmd(c, "volume", "inspect", "--format={{ .Options }}", name).Stdout()
 	assert.Assert(c, strings.Contains(strings.TrimSpace(out), fmt.Sprintf("%s:%s", k1, v1)))
 	assert.Assert(c, strings.Contains(strings.TrimSpace(out), fmt.Sprintf("%s:%s", k2, v2)))
 	assert.Assert(c, strings.Contains(strings.TrimSpace(out), fmt.Sprintf("%s:%s", k3, v3)))
@@ -465,39 +469,39 @@ func (s *DockerCLIVolumeSuite) TestVolumeCliInspectWithVolumeOpts(c *testing.T)
 func (s *DockerCLIVolumeSuite) TestDuplicateMountpointsForVolumesFrom(c *testing.T) {
 	testRequires(c, DaemonIsLinux)
 
-	image := "vimage"
+	const image = "vimage"
 	buildImageSuccessfully(c, image, build.WithDockerfile(`
 		FROM busybox
 		VOLUME ["/tmp/data"]`))
 
-	dockerCmd(c, "run", "--name=data1", image, "true")
-	dockerCmd(c, "run", "--name=data2", image, "true")
+	cli.DockerCmd(c, "run", "--name=data1", image, "true")
+	cli.DockerCmd(c, "run", "--name=data2", image, "true")
 
-	out, _ := dockerCmd(c, "inspect", "--format", "{{(index .Mounts 0).Name}}", "data1")
-	data1 := strings.TrimSpace(out)
+	data1 := cli.DockerCmd(c, "inspect", "--format", "{{(index .Mounts 0).Name}}", "data1").Stdout()
+	data1 = strings.TrimSpace(data1)
 	assert.Assert(c, data1 != "")
 
-	out, _ = dockerCmd(c, "inspect", "--format", "{{(index .Mounts 0).Name}}", "data2")
-	data2 := strings.TrimSpace(out)
+	data2 := cli.DockerCmd(c, "inspect", "--format", "{{(index .Mounts 0).Name}}", "data2").Stdout()
+	data2 = strings.TrimSpace(data2)
 	assert.Assert(c, data2 != "")
 
 	// Both volume should exist
-	out, _ = dockerCmd(c, "volume", "ls", "-q")
+	out := cli.DockerCmd(c, "volume", "ls", "-q").Stdout()
 	assert.Assert(c, strings.Contains(strings.TrimSpace(out), data1))
 	assert.Assert(c, strings.Contains(strings.TrimSpace(out), data2))
 	out, _, err := dockerCmdWithError("run", "--name=app", "--volumes-from=data1", "--volumes-from=data2", "-d", "busybox", "top")
 	assert.Assert(c, err == nil, "Out: %s", out)
 
 	// Only the second volume will be referenced, this is backward compatible
-	out, _ = dockerCmd(c, "inspect", "--format", "{{(index .Mounts 0).Name}}", "app")
+	out = cli.DockerCmd(c, "inspect", "--format", "{{(index .Mounts 0).Name}}", "app").Stdout()
 	assert.Equal(c, strings.TrimSpace(out), data2)
 
-	dockerCmd(c, "rm", "-f", "-v", "app")
-	dockerCmd(c, "rm", "-f", "-v", "data1")
-	dockerCmd(c, "rm", "-f", "-v", "data2")
+	cli.DockerCmd(c, "rm", "-f", "-v", "app")
+	cli.DockerCmd(c, "rm", "-f", "-v", "data1")
+	cli.DockerCmd(c, "rm", "-f", "-v", "data2")
 
 	// Both volume should not exist
-	out, _ = dockerCmd(c, "volume", "ls", "-q")
+	out = cli.DockerCmd(c, "volume", "ls", "-q").Stdout()
 	assert.Assert(c, !strings.Contains(strings.TrimSpace(out), data1))
 	assert.Assert(c, !strings.Contains(strings.TrimSpace(out), data2))
 }
@@ -506,24 +510,24 @@ func (s *DockerCLIVolumeSuite) TestDuplicateMountpointsForVolumesFrom(c *testing
 func (s *DockerCLIVolumeSuite) TestDuplicateMountpointsForVolumesFromAndBind(c *testing.T) {
 	testRequires(c, DaemonIsLinux)
 
-	image := "vimage"
+	const image = "vimage"
 	buildImageSuccessfully(c, image, build.WithDockerfile(`
                 FROM busybox
                 VOLUME ["/tmp/data"]`))
 
-	dockerCmd(c, "run", "--name=data1", image, "true")
-	dockerCmd(c, "run", "--name=data2", image, "true")
+	cli.DockerCmd(c, "run", "--name=data1", image, "true")
+	cli.DockerCmd(c, "run", "--name=data2", image, "true")
 
-	out, _ := dockerCmd(c, "inspect", "--format", "{{(index .Mounts 0).Name}}", "data1")
-	data1 := strings.TrimSpace(out)
+	data1 := cli.DockerCmd(c, "inspect", "--format", "{{(index .Mounts 0).Name}}", "data1").Stdout()
+	data1 = strings.TrimSpace(data1)
 	assert.Assert(c, data1 != "")
 
-	out, _ = dockerCmd(c, "inspect", "--format", "{{(index .Mounts 0).Name}}", "data2")
-	data2 := strings.TrimSpace(out)
+	data2 := cli.DockerCmd(c, "inspect", "--format", "{{(index .Mounts 0).Name}}", "data2").Stdout()
+	data2 = strings.TrimSpace(data2)
 	assert.Assert(c, data2 != "")
 
 	// Both volume should exist
-	out, _ = dockerCmd(c, "volume", "ls", "-q")
+	out := cli.DockerCmd(c, "volume", "ls", "-q").Stdout()
 	assert.Assert(c, strings.Contains(strings.TrimSpace(out), data1))
 	assert.Assert(c, strings.Contains(strings.TrimSpace(out), data2))
 	// /tmp/data is automatically created, because we are not using the modern mount API here
@@ -531,15 +535,15 @@ func (s *DockerCLIVolumeSuite) TestDuplicateMountpointsForVolumesFromAndBind(c *
 	assert.Assert(c, err == nil, "Out: %s", out)
 
 	// No volume will be referenced (mount is /tmp/data), this is backward compatible
-	out, _ = dockerCmd(c, "inspect", "--format", "{{(index .Mounts 0).Name}}", "app")
+	out = cli.DockerCmd(c, "inspect", "--format", "{{(index .Mounts 0).Name}}", "app").Stdout()
 	assert.Assert(c, !strings.Contains(strings.TrimSpace(out), data1))
 	assert.Assert(c, !strings.Contains(strings.TrimSpace(out), data2))
-	dockerCmd(c, "rm", "-f", "-v", "app")
-	dockerCmd(c, "rm", "-f", "-v", "data1")
-	dockerCmd(c, "rm", "-f", "-v", "data2")
+	cli.DockerCmd(c, "rm", "-f", "-v", "app")
+	cli.DockerCmd(c, "rm", "-f", "-v", "data1")
+	cli.DockerCmd(c, "rm", "-f", "-v", "data2")
 
 	// Both volume should not exist
-	out, _ = dockerCmd(c, "volume", "ls", "-q")
+	out = cli.DockerCmd(c, "volume", "ls", "-q").Stdout()
 	assert.Assert(c, !strings.Contains(strings.TrimSpace(out), data1))
 	assert.Assert(c, !strings.Contains(strings.TrimSpace(out), data2))
 }
@@ -548,28 +552,29 @@ func (s *DockerCLIVolumeSuite) TestDuplicateMountpointsForVolumesFromAndBind(c *
 func (s *DockerCLIVolumeSuite) TestDuplicateMountpointsForVolumesFromAndMounts(c *testing.T) {
 	testRequires(c, testEnv.IsLocalDaemon, DaemonIsLinux)
 
-	image := "vimage"
+	const image = "vimage"
 	buildImageSuccessfully(c, image, build.WithDockerfile(`
                 FROM busybox
                 VOLUME ["/tmp/data"]`))
 
-	dockerCmd(c, "run", "--name=data1", image, "true")
-	dockerCmd(c, "run", "--name=data2", image, "true")
+	cli.DockerCmd(c, "run", "--name=data1", image, "true")
+	cli.DockerCmd(c, "run", "--name=data2", image, "true")
 
-	out, _ := dockerCmd(c, "inspect", "--format", "{{(index .Mounts 0).Name}}", "data1")
-	data1 := strings.TrimSpace(out)
+	data1 := cli.DockerCmd(c, "inspect", "--format", "{{(index .Mounts 0).Name}}", "data1").Stdout()
+	data1 = strings.TrimSpace(data1)
 	assert.Assert(c, data1 != "")
 
-	out, _ = dockerCmd(c, "inspect", "--format", "{{(index .Mounts 0).Name}}", "data2")
-	data2 := strings.TrimSpace(out)
+	data2 := cli.DockerCmd(c, "inspect", "--format", "{{(index .Mounts 0).Name}}", "data2").Stdout()
+	data2 = strings.TrimSpace(data2)
 	assert.Assert(c, data2 != "")
 
 	// Both volume should exist
-	out, _ = dockerCmd(c, "volume", "ls", "-q")
+	out := cli.DockerCmd(c, "volume", "ls", "-q").Stdout()
 	assert.Assert(c, strings.Contains(strings.TrimSpace(out), data1))
 	assert.Assert(c, strings.Contains(strings.TrimSpace(out), data2))
 	err := os.MkdirAll("/tmp/data", 0o755)
 	assert.NilError(c, err)
+
 	// Mounts is available in API
 	apiClient, err := client.NewClientWithOpts(client.FromEnv)
 	assert.NilError(c, err)
@@ -595,15 +600,15 @@ func (s *DockerCLIVolumeSuite) TestDuplicateMountpointsForVolumesFromAndMounts(c
 	assert.NilError(c, err)
 
 	// No volume will be referenced (mount is /tmp/data), this is backward compatible
-	out, _ = dockerCmd(c, "inspect", "--format", "{{(index .Mounts 0).Name}}", "app")
+	out = cli.DockerCmd(c, "inspect", "--format", "{{(index .Mounts 0).Name}}", "app").Stdout()
 	assert.Assert(c, !strings.Contains(strings.TrimSpace(out), data1))
 	assert.Assert(c, !strings.Contains(strings.TrimSpace(out), data2))
-	dockerCmd(c, "rm", "-f", "-v", "app")
-	dockerCmd(c, "rm", "-f", "-v", "data1")
-	dockerCmd(c, "rm", "-f", "-v", "data2")
+	cli.DockerCmd(c, "rm", "-f", "-v", "app")
+	cli.DockerCmd(c, "rm", "-f", "-v", "data1")
+	cli.DockerCmd(c, "rm", "-f", "-v", "data2")
 
 	// Both volume should not exist
-	out, _ = dockerCmd(c, "volume", "ls", "-q")
+	out = cli.DockerCmd(c, "volume", "ls", "-q").Stdout()
 	assert.Assert(c, !strings.Contains(strings.TrimSpace(out), data1))
 	assert.Assert(c, !strings.Contains(strings.TrimSpace(out), data2))
 }