package main

import (
	"context"
	"fmt"
	"os"
	"os/exec"
	"path/filepath"
	"strings"
	"testing"

	"github.com/docker/docker/api/types/container"
	"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"
	"gotest.tools/v3/icmd"
)

type DockerCLIVolumeSuite struct {
	ds *DockerSuite
}

func (s *DockerCLIVolumeSuite) TearDownTest(ctx context.Context, c *testing.T) {
	s.ds.TearDownTest(ctx, c)
}

func (s *DockerCLIVolumeSuite) OnTimeout(c *testing.T) {
	s.ds.OnTimeout(c)
}

func (s *DockerCLIVolumeSuite) TestVolumeCLICreate(c *testing.T) {
	cli.DockerCmd(c, "volume", "create")

	_, _, err := dockerCmdWithError("volume", "create", "-d", "nosuchdriver")
	assert.ErrorContains(c, err, "")

	// test using hidden --name option
	name := cli.DockerCmd(c, "volume", "create", "--name=test").Stdout()
	name = strings.TrimSpace(name)
	assert.Equal(c, name, "test")

	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")
	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)

	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) {
	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{
		ExitCode: 1,
		Err:      "No such volume: doesnotexist",
	})

	out := result.Stdout()
	assert.Assert(c, strings.Contains(out, "test1"))
	assert.Assert(c, strings.Contains(out, "test2"))
	assert.Assert(c, strings.Contains(out, "test3"))
}

func (s *DockerCLIVolumeSuite) TestVolumeCLILs(c *testing.T) {
	prefix, _ := getPrefixAndSlashFromDaemonPlatform()
	cli.DockerCmd(c, "volume", "create", "aaa")

	cli.DockerCmd(c, "volume", "create", "test")

	cli.DockerCmd(c, "volume", "create", "soo")
	cli.DockerCmd(c, "run", "-v", "soo:"+prefix+"/foo", "busybox", "ls", "/")

	out := cli.DockerCmd(c, "volume", "ls", "-q").Stdout()
	assertVolumesInList(c, out, []string{"aaa", "soo", "test"})
}

func (s *DockerCLIVolumeSuite) TestVolumeLsFormat(c *testing.T) {
	cli.DockerCmd(c, "volume", "create", "aaa")
	cli.DockerCmd(c, "volume", "create", "test")
	cli.DockerCmd(c, "volume", "create", "soo")

	out := cli.DockerCmd(c, "volume", "ls", "--format", "{{.Name}}").Stdout()
	assertVolumesInList(c, out, []string{"aaa", "soo", "test"})
}

func (s *DockerCLIVolumeSuite) TestVolumeLsFormatDefaultFormat(c *testing.T) {
	cli.DockerCmd(c, "volume", "create", "aaa")
	cli.DockerCmd(c, "volume", "create", "test")
	cli.DockerCmd(c, "volume", "create", "soo")

	const config = `{
		"volumesFormat": "{{ .Name }} default"
}`
	d, err := os.MkdirTemp("", "integration-cli-")
	assert.NilError(c, err)
	defer os.RemoveAll(d)

	err = os.WriteFile(filepath.Join(d, "config.json"), []byte(config), 0o644)
	assert.NilError(c, err)

	out := cli.DockerCmd(c, "--config", d, "volume", "ls").Stdout()
	assertVolumesInList(c, out, []string{"aaa default", "soo default", "test default"})
}

func assertVolumesInList(c *testing.T, out string, expected []string) {
	lines := strings.Split(strings.TrimSpace(out), "\n")
	for _, expect := range expected {
		found := false
		for _, v := range lines {
			found = v == expect
			if found {
				break
			}
		}
		assert.Assert(c, found, "Expected volume not found: %v, got: %v", expect, lines)
	}
}

func (s *DockerCLIVolumeSuite) TestVolumeCLILsFilterDangling(c *testing.T) {
	prefix, _ := getPrefixAndSlashFromDaemonPlatform()
	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
	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")

	// 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")

	// 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")

	// 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")

	// 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 = 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")
}

func (s *DockerCLIVolumeSuite) TestVolumeCLILsErrorWithInvalidFilterName(c *testing.T) {
	out, _, err := dockerCmdWithError("volume", "ls", "-f", "FOO=123")
	assert.ErrorContains(c, err, "")
	assert.Assert(c, strings.Contains(out, "invalid filter"))
}

func (s *DockerCLIVolumeSuite) TestVolumeCLILsWithIncorrectFilterValue(c *testing.T) {
	out, _, err := dockerCmdWithError("volume", "ls", "-f", "dangling=invalid")
	assert.ErrorContains(c, err, "")
	assert.Assert(c, strings.Contains(out, "invalid filter"))
}

func (s *DockerCLIVolumeSuite) TestVolumeCLIRm(c *testing.T) {
	prefix, _ := getPrefixAndSlashFromDaemonPlatform()
	id := cli.DockerCmd(c, "volume", "create").Stdout()
	id = strings.TrimSpace(id)

	cli.DockerCmd(c, "volume", "create", "test")
	cli.DockerCmd(c, "volume", "rm", id)
	cli.DockerCmd(c, "volume", "rm", "test")

	volumeID := "testing"
	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 := cli.DockerCmd(c, "run", "--volumes-from=test", "--name=test2", "busybox", "sh", "-c", "cat /foo/bar").Combined()
	assert.Equal(c, strings.TrimSpace(out), "hello")
	cli.DockerCmd(c, "rm", "-fv", "test2")
	cli.DockerCmd(c, "volume", "inspect", volumeID)
	cli.DockerCmd(c, "rm", "-f", "test")

	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")
	cli.DockerCmd(c, "rm", "test2")

	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 := 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))
	// invalid arg should error and show the command usage on stderr
	icmd.RunCommand(dockerBinary, "volume", "somearg").Assert(c, icmd.Expected{
		ExitCode: 1,
		Error:    "exit status 1",
		Err:      usage,
	})

	// invalid flag should error and show the flag error and cmd usage
	result := icmd.RunCommand(dockerBinary, "volume", "--no-such-flag")
	result.Assert(c, icmd.Expected{
		ExitCode: 125,
		Error:    "exit status 125",
		Err:      usage,
	})
	assert.Assert(c, strings.Contains(result.Stderr(), "unknown flag: --no-such-flag"))
}

func (s *DockerCLIVolumeSuite) TestVolumeCLIInspectTmplError(c *testing.T) {
	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)
	assert.Equal(c, exitCode, 1, fmt.Sprintf("Output: %s", out))
	assert.Assert(c, strings.Contains(out, "Template parsing error"))
}

func (s *DockerCLIVolumeSuite) TestVolumeCLICreateWithOpts(c *testing.T) {
	testRequires(c, DaemonIsLinux)

	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 {
		if strings.Contains(m, "/foo") {
			found = true
			info := strings.Fields(m)
			// tmpfs on <path> type tmpfs (rw,relatime,size=1024k,uid=1000)
			assert.Equal(c, info[0], "tmpfs")
			assert.Equal(c, info[2], "/foo")
			assert.Equal(c, info[4], "tmpfs")
			assert.Assert(c, strings.Contains(info[5], "uid=1000"))
			assert.Assert(c, strings.Contains(info[5], "size=1024k"))
			break
		}
	}
	assert.Equal(c, found, true)
}

func (s *DockerCLIVolumeSuite) TestVolumeCLICreateLabel(c *testing.T) {
	const testVol = "testvolcreatelabel"
	const testLabel = "foo"
	const testValue = "bar"

	_, _, err := dockerCmdWithError("volume", "create", "--label", testLabel+"="+testValue, testVol)
	assert.NilError(c, err)

	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) {
	const testVol = "testvolcreatelabel"

	testLabels := map[string]string{
		"foo": "bar",
		"baz": "foo",
	}

	args := []string{
		"volume",
		"create",
		testVol,
	}

	for k, v := range testLabels {
		args = append(args, "--label", k+"="+v)
	}

	_, _, err := dockerCmdWithError(args...)
	assert.NilError(c, err)

	for k, v := range testLabels {
		out := cli.DockerCmd(c, "volume", "inspect", "--format={{ .Labels."+k+" }}", testVol).Stdout()
		assert.Equal(c, strings.TrimSpace(out), v)
	}
}

func (s *DockerCLIVolumeSuite) TestVolumeCLILsFilterLabels(c *testing.T) {
	testVol1 := "testvolcreatelabel-1"
	_, _, err := dockerCmdWithError("volume", "create", "--label", "foo=bar1", testVol1)
	assert.NilError(c, err)

	testVol2 := "testvolcreatelabel-2"
	_, _, err = dockerCmdWithError("volume", "create", "--label", "foo=bar2", testVol2)
	assert.NilError(c, err)

	// 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")

	// 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 = 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 = 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))
}

func (s *DockerCLIVolumeSuite) TestVolumeCLILsFilterDrivers(c *testing.T) {
	// using default volume driver local to create volumes
	testVol1 := "testvol-1"
	_, _, err := dockerCmdWithError("volume", "create", testVol1)
	assert.NilError(c, err)

	testVol2 := "testvol-2"
	_, _, err = dockerCmdWithError("volume", "create", testVol2)
	assert.NilError(c, err)

	// filter with 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 = 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 = 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 = 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) {
	id := cli.DockerCmd(c, "volume", "create").Stdout()
	id = strings.TrimSpace(id)

	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)

	const name = "test"
	id := cli.DockerCmd(c, "volume", "create", name).Stdout()
	id = strings.TrimSpace(id)
	assert.Equal(c, id, 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)

	cli.DockerCmd(c, "volume", "rm", "-f", name)
	out = cli.DockerCmd(c, "volume", "ls").Stdout()
	assert.Assert(c, !strings.Contains(out, name))
	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) {
	const name = "testvolume"
	id := cli.DockerCmd(c, "volume", "create", name).Stdout()
	id = strings.TrimSpace(id)
	assert.Equal(c, id, name)

	prefix, slash := getPrefixAndSlashFromDaemonPlatform()
	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 := 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.
	// Calling `volume rm` a second time to confirm it's not removed
	// when calling twice.
	_, _, err = dockerCmdWithError("volume", "rm", "-f", name)
	assert.ErrorContains(c, err, "")
	assert.ErrorContains(c, err, "volume is in use")
	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 := cli.DockerCmd(c, "rm", cid).ExitCode
	assert.Equal(c, e, 0)

	e = cli.DockerCmd(c, "volume", "rm", "-f", name).ExitCode
	assert.Equal(c, e, 0)

	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) {
	testRequires(c, DaemonIsLinux)

	// Without options
	name := "test1"
	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"
	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)))
}

// Test case (1) for 21845: duplicate targets for --volumes-from
func (s *DockerCLIVolumeSuite) TestDuplicateMountpointsForVolumesFrom(c *testing.T) {
	testRequires(c, DaemonIsLinux)

	const imgName = "vimage"
	buildImageSuccessfully(c, imgName, build.WithDockerfile(`
		FROM busybox
		VOLUME ["/tmp/data"]`))

	cli.DockerCmd(c, "run", "--name=data1", imgName, "true")
	cli.DockerCmd(c, "run", "--name=data2", imgName, "true")

	data1 := cli.DockerCmd(c, "inspect", "--format", "{{(index .Mounts 0).Name}}", "data1").Stdout()
	data1 = strings.TrimSpace(data1)
	assert.Assert(c, data1 != "")

	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 := 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 = cli.DockerCmd(c, "inspect", "--format", "{{(index .Mounts 0).Name}}", "app").Stdout()
	assert.Equal(c, strings.TrimSpace(out), 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 = 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))
}

// Test case (2) for 21845: duplicate targets for --volumes-from and -v (bind)
func (s *DockerCLIVolumeSuite) TestDuplicateMountpointsForVolumesFromAndBind(c *testing.T) {
	testRequires(c, DaemonIsLinux)

	const imgName = "vimage"
	buildImageSuccessfully(c, imgName, build.WithDockerfile(`
                FROM busybox
                VOLUME ["/tmp/data"]`))

	cli.DockerCmd(c, "run", "--name=data1", imgName, "true")
	cli.DockerCmd(c, "run", "--name=data2", imgName, "true")

	data1 := cli.DockerCmd(c, "inspect", "--format", "{{(index .Mounts 0).Name}}", "data1").Stdout()
	data1 = strings.TrimSpace(data1)
	assert.Assert(c, data1 != "")

	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 := 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
	out, _, err := dockerCmdWithError("run", "--name=app", "--volumes-from=data1", "--volumes-from=data2", "-v", "/tmp/data:/tmp/data", "-d", "busybox", "top")
	assert.Assert(c, err == nil, "Out: %s", out)

	// No volume will be referenced (mount is /tmp/data), this is backward compatible
	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))
	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 = 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))
}

// Test case (3) for 21845: duplicate targets for --volumes-from and `Mounts` (API only)
func (s *DockerCLIVolumeSuite) TestDuplicateMountpointsForVolumesFromAndMounts(c *testing.T) {
	testRequires(c, testEnv.IsLocalDaemon, DaemonIsLinux)

	const imgName = "vimage"
	buildImageSuccessfully(c, imgName, build.WithDockerfile(`
                FROM busybox
                VOLUME ["/tmp/data"]`))

	cli.DockerCmd(c, "run", "--name=data1", imgName, "true")
	cli.DockerCmd(c, "run", "--name=data2", imgName, "true")

	data1 := cli.DockerCmd(c, "inspect", "--format", "{{(index .Mounts 0).Name}}", "data1").Stdout()
	data1 = strings.TrimSpace(data1)
	assert.Assert(c, data1 != "")

	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 := 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)
	defer apiClient.Close()

	config := container.Config{
		Cmd:   []string{"top"},
		Image: "busybox",
	}

	hostConfig := container.HostConfig{
		VolumesFrom: []string{"data1", "data2"},
		Mounts: []mount.Mount{
			{
				Type:   "bind",
				Source: "/tmp/data",
				Target: "/tmp/data",
			},
		},
	}
	_, err = apiClient.ContainerCreate(testutil.GetContext(c), &config, &hostConfig, &network.NetworkingConfig{}, nil, "app")

	assert.NilError(c, err)

	// No volume will be referenced (mount is /tmp/data), this is backward compatible
	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))
	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 = 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))
}
