0ct0pu5/moby
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

Merge pull request #44316 from thaJeztah/plugin_improve_test_errors

Browse source 
integration-cli: DockerPluginSuite: use gotest.tools compare utilities
This commit is contained in:
Brian Goff 2022-11-01 17:07:22 -07:00 • committed by GitHub
commit 9fa38435aa
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
1 changed files with 53 additions and 52 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

105
integration-cli/docker_cli_plugins_test.go
View file

@ -17,6 +17,7 @@ import (
"github.com/docker/docker/integration-cli/daemon"
"github.com/docker/docker/testutil/fixtures/plugin"
"gotest.tools/v3/assert"
is "gotest.tools/v3/assert/cmp"
"gotest.tools/v3/skip"
)
@ -48,21 +49,21 @@ func (ps *DockerPluginSuite) TestPluginBasicOps(c *testing.T) {
out, _, err := dockerCmdWithError("plugin", "ls")
assert.NilError(c, err)
assert.Assert(c, strings.Contains(out, plugin))
assert.Assert(c, strings.Contains(out, "true"))
assert.Check(c, is.Contains(out, plugin))
assert.Check(c, is.Contains(out, "true"))
id, _, err := dockerCmdWithError("plugin", "inspect", "-f", "{{.Id}}", plugin)
id = strings.TrimSpace(id)
assert.NilError(c, err)
out, _, err = dockerCmdWithError("plugin", "remove", plugin)
assert.ErrorContains(c, err, "")
assert.Assert(c, strings.Contains(out, "is enabled"))
assert.Check(c, is.Contains(out, "is enabled"))
_, _, err = dockerCmdWithError("plugin", "disable", plugin)
assert.NilError(c, err)
out, _, err = dockerCmdWithError("plugin", "remove", plugin)
assert.NilError(c, err)
assert.Assert(c, strings.Contains(out, plugin))
assert.Check(c, is.Contains(out, plugin))
_, err = os.Stat(filepath.Join(testEnv.DaemonInfo.DockerRootDir, "plugins", id))
if !os.IsNotExist(err) {
c.Fatal(err)
@ -76,10 +77,10 @@ func (ps *DockerPluginSuite) TestPluginForceRemove(c *testing.T) {
assert.NilError(c, err)
out, _, _ := dockerCmdWithError("plugin", "remove", pNameWithTag)
assert.Assert(c, strings.Contains(out, "is enabled"))
assert.Check(c, is.Contains(out, "is enabled"))
out, _, err = dockerCmdWithError("plugin", "remove", "--force", pNameWithTag)
assert.NilError(c, err)
assert.Assert(c, strings.Contains(out, pNameWithTag))
assert.Check(c, is.Contains(out, pNameWithTag))
}
func (s *DockerCLIPluginsSuite) TestPluginActive(c *testing.T) {
@ -92,7 +93,7 @@ func (s *DockerCLIPluginsSuite) TestPluginActive(c *testing.T) {
assert.NilError(c, err)
out, _, _ := dockerCmdWithError("plugin", "disable", pNameWithTag)
assert.Assert(c, strings.Contains(out, "in use"))
assert.Check(c, is.Contains(out, "in use"))
_, _, err = dockerCmdWithError("volume", "rm", "testvol1")
assert.NilError(c, err)
@ -101,7 +102,7 @@ func (s *DockerCLIPluginsSuite) TestPluginActive(c *testing.T) {
out, _, err = dockerCmdWithError("plugin", "remove", pNameWithTag)
assert.NilError(c, err)
assert.Assert(c, strings.Contains(out, pNameWithTag))
assert.Check(c, is.Contains(out, pNameWithTag))
}
func (s *DockerCLIPluginsSuite) TestPluginActiveNetwork(c *testing.T) {
@ -115,18 +116,18 @@ func (s *DockerCLIPluginsSuite) TestPluginActiveNetwork(c *testing.T) {
nID := strings.TrimSpace(out)
out, _, _ = dockerCmdWithError("plugin", "remove", npNameWithTag)
assert.Assert(c, strings.Contains(out, "is in use"))
assert.Check(c, is.Contains(out, "is in use"))
_, _, err = dockerCmdWithError("network", "rm", nID)
assert.NilError(c, err)
out, _, _ = dockerCmdWithError("plugin", "remove", npNameWithTag)
assert.Assert(c, strings.Contains(out, "is enabled"))
assert.Check(c, is.Contains(out, "is enabled"))
_, _, err = dockerCmdWithError("plugin", "disable", npNameWithTag)
assert.NilError(c, err)
out, _, err = dockerCmdWithError("plugin", "remove", npNameWithTag)
assert.NilError(c, err)
assert.Assert(c, strings.Contains(out, npNameWithTag))
assert.Check(c, is.Contains(out, npNameWithTag))
}
func (ps *DockerPluginSuite) TestPluginInstallDisable(c *testing.T) {
@ -134,26 +135,26 @@ func (ps *DockerPluginSuite) TestPluginInstallDisable(c *testing.T) {
out, _, err := dockerCmdWithError("plugin", "install", "--grant-all-permissions", "--disable", pName)
assert.NilError(c, err)
assert.Assert(c, strings.Contains(strings.TrimSpace(out), pName))
assert.Check(c, is.Contains(out, pName))
out, _, err = dockerCmdWithError("plugin", "ls")
assert.NilError(c, err)
assert.Assert(c, strings.Contains(out, "false"))
assert.Check(c, is.Contains(out, "false"))
out, _, err = dockerCmdWithError("plugin", "enable", pName)
assert.NilError(c, err)
assert.Assert(c, strings.Contains(strings.TrimSpace(out), pName))
assert.Check(c, is.Contains(out, pName))
out, _, err = dockerCmdWithError("plugin", "disable", pName)
assert.NilError(c, err)
assert.Assert(c, strings.Contains(strings.TrimSpace(out), pName))
assert.Check(c, is.Contains(out, pName))
out, _, err = dockerCmdWithError("plugin", "remove", pName)
assert.NilError(c, err)
assert.Assert(c, strings.Contains(strings.TrimSpace(out), pName))
assert.Check(c, is.Contains(out, pName))
}
func (s *DockerCLIPluginsSuite) TestPluginInstallDisableVolumeLs(c *testing.T) {
testRequires(c, DaemonIsLinux, IsAmd64, Network)
out, _, err := dockerCmdWithError("plugin", "install", "--grant-all-permissions", "--disable", pName)
assert.NilError(c, err)
assert.Assert(c, strings.Contains(strings.TrimSpace(out), pName))
assert.Check(c, is.Contains(out, pName))
dockerCmd(c, "volume", "ls")
}
@ -183,25 +184,25 @@ func (ps *DockerPluginSuite) TestPluginSet(c *testing.T) {
assert.Assert(c, err == nil, "failed to create test plugin")
env, _ := dockerCmd(c, "plugin", "inspect", "-f", "{{.Settings.Env}}", name)
assert.Equal(c, strings.TrimSpace(env), "[DEBUG=0]")
assert.Check(c, is.Equal(strings.TrimSpace(env), "[DEBUG=0]"))
dockerCmd(c, "plugin", "set", name, "DEBUG=1")
env, _ = dockerCmd(c, "plugin", "inspect", "-f", "{{.Settings.Env}}", name)
assert.Equal(c, strings.TrimSpace(env), "[DEBUG=1]")
assert.Check(c, is.Equal(strings.TrimSpace(env), "[DEBUG=1]"))
env, _ = dockerCmd(c, "plugin", "inspect", "-f", "{{with $mount := index .Settings.Mounts 0}}{{$mount.Source}}{{end}}", name)
assert.Assert(c, strings.Contains(strings.TrimSpace(env), mntSrc))
assert.Check(c, is.Contains(env, mntSrc))
dockerCmd(c, "plugin", "set", name, "pmount1.source=bar")
env, _ = dockerCmd(c, "plugin", "inspect", "-f", "{{with $mount := index .Settings.Mounts 0}}{{$mount.Source}}{{end}}", name)
assert.Assert(c, strings.Contains(strings.TrimSpace(env), "bar"))
assert.Check(c, is.Contains(env, "bar"))
out, _, err := dockerCmdWithError("plugin", "set", name, "pmount2.source=bar2")
assert.ErrorContains(c, err, "")
assert.Assert(c, strings.Contains(out, "Plugin config has no mount source"))
assert.Check(c, is.Contains(out, "Plugin config has no mount source"))
out, _, err = dockerCmdWithError("plugin", "set", name, "pdev2.path=/dev/bar2")
assert.ErrorContains(c, err, "")
assert.Assert(c, strings.Contains(out, "Plugin config has no device path"))
assert.Check(c, is.Contains(out, "Plugin config has no device path"))
}
func (ps *DockerPluginSuite) TestPluginInstallArgs(c *testing.T) {
@ -214,9 +215,9 @@ func (ps *DockerPluginSuite) TestPluginInstallArgs(c *testing.T) {
})
out, _ := dockerCmd(c, "plugin", "install", "--grant-all-permissions", "--disable", pName, "DEBUG=1")
assert.Assert(c, strings.Contains(strings.TrimSpace(out), pName))
assert.Check(c, is.Contains(out, pName))
env, _ := dockerCmd(c, "plugin", "inspect", "-f", "{{.Settings.Env}}", pName)
assert.Equal(c, strings.TrimSpace(env), "[DEBUG=1]")
assert.Check(c, is.Equal(strings.TrimSpace(env), "[DEBUG=1]"))
}
func (ps *DockerPluginSuite) TestPluginInstallImage(c *testing.T) {
@ -231,7 +232,7 @@ func (ps *DockerPluginSuite) TestPluginInstallImage(c *testing.T) {
out, _, err := dockerCmdWithError("plugin", "install", repoName)
assert.ErrorContains(c, err, "")
assert.Assert(c, strings.Contains(out, `Encountered remote "application/vnd.docker.container.image.v1+json"(image) when fetching`))
assert.Check(c, is.Contains(out, `Encountered remote "application/vnd.docker.container.image.v1+json"(image) when fetching`))
}
func (ps *DockerPluginSuite) TestPluginEnableDisableNegative(c *testing.T) {
@ -239,16 +240,16 @@ func (ps *DockerPluginSuite) TestPluginEnableDisableNegative(c *testing.T) {
out, _, err := dockerCmdWithError("plugin", "install", "--grant-all-permissions", pName)
assert.NilError(c, err)
assert.Assert(c, strings.Contains(strings.TrimSpace(out), pName))
assert.Check(c, is.Contains(out, pName))
out, _, err = dockerCmdWithError("plugin", "enable", pName)
assert.ErrorContains(c, err, "")
assert.Assert(c, strings.Contains(strings.TrimSpace(out), "already enabled"))
assert.Check(c, is.Contains(out, "already enabled"))
_, _, err = dockerCmdWithError("plugin", "disable", pName)
assert.NilError(c, err)
out, _, err = dockerCmdWithError("plugin", "disable", pName)
assert.ErrorContains(c, err, "")
assert.Assert(c, strings.Contains(strings.TrimSpace(out), "already disabled"))
assert.Check(c, is.Contains(out, "already disabled"))
_, _, err = dockerCmdWithError("plugin", "remove", pName)
assert.NilError(c, err)
}
@ -268,16 +269,16 @@ func (ps *DockerPluginSuite) TestPluginCreate(c *testing.T) {
out, _, err := dockerCmdWithError("plugin", "create", name, temp)
assert.NilError(c, err)
assert.Assert(c, strings.Contains(out, name))
assert.Check(c, is.Contains(out, name))
out, _, err = dockerCmdWithError("plugin", "ls")
assert.NilError(c, err)
assert.Assert(c, strings.Contains(out, name))
assert.Check(c, is.Contains(out, name))
out, _, err = dockerCmdWithError("plugin", "create", name, temp)
assert.ErrorContains(c, err, "")
assert.Assert(c, strings.Contains(out, "already exist"))
assert.Check(c, is.Contains(out, "already exist"))
out, _, err = dockerCmdWithError("plugin", "ls")
assert.NilError(c, err)
assert.Assert(c, strings.Contains(out, name))
assert.Check(c, is.Contains(out, name))
// The output will consists of one HEADER line and one line of foo/bar-driver
assert.Equal(c, len(strings.Split(strings.TrimSpace(out), "\n")), 2)
}
@ -290,8 +291,8 @@ func (ps *DockerPluginSuite) TestPluginInspect(c *testing.T) {
out, _, err := dockerCmdWithError("plugin", "ls")
assert.NilError(c, err)
assert.Assert(c, strings.Contains(out, pNameWithTag))
assert.Assert(c, strings.Contains(out, "true"))
assert.Check(c, is.Contains(out, pNameWithTag))
assert.Check(c, is.Contains(out, "true"))
// Find the ID first
out, _, err = dockerCmdWithError("plugin", "inspect", "-f", "{{.Id}}", pNameWithTag)
assert.NilError(c, err)
@ -301,29 +302,29 @@ func (ps *DockerPluginSuite) TestPluginInspect(c *testing.T) {
// Long form
out, _, err = dockerCmdWithError("plugin", "inspect", "-f", "{{.Id}}", id)
assert.NilError(c, err)
assert.Equal(c, strings.TrimSpace(out), id)
assert.Check(c, is.Equal(strings.TrimSpace(out), id))
// Short form
out, _, err = dockerCmdWithError("plugin", "inspect", "-f", "{{.Id}}", id[:5])
assert.NilError(c, err)
assert.Equal(c, strings.TrimSpace(out), id)
assert.Check(c, is.Equal(strings.TrimSpace(out), id))
// Name with tag form
out, _, err = dockerCmdWithError("plugin", "inspect", "-f", "{{.Id}}", pNameWithTag)
assert.NilError(c, err)
assert.Equal(c, strings.TrimSpace(out), id)
assert.Check(c, is.Equal(strings.TrimSpace(out), id))
// Name without tag form
out, _, err = dockerCmdWithError("plugin", "inspect", "-f", "{{.Id}}", ps.getPluginRepo())
assert.NilError(c, err)
assert.Equal(c, strings.TrimSpace(out), id)
assert.Check(c, is.Equal(strings.TrimSpace(out), id))
_, _, err = dockerCmdWithError("plugin", "disable", pNameWithTag)
assert.NilError(c, err)
out, _, err = dockerCmdWithError("plugin", "remove", pNameWithTag)
assert.NilError(c, err)
assert.Assert(c, strings.Contains(out, pNameWithTag))
assert.Check(c, is.Contains(out, pNameWithTag))
// After remove nothing should be found
_, _, err = dockerCmdWithError("plugin", "inspect", "-f", "{{.Id}}", id[:5])
assert.ErrorContains(c, err, "")
@ -336,7 +337,7 @@ func (s *DockerCLIPluginsSuite) TestPluginInspectOnWindows(c *testing.T) {
out, _, err := dockerCmdWithError("plugin", "inspect", "foobar")
assert.ErrorContains(c, err, "")
assert.Assert(c, strings.Contains(out, "plugins are not supported on this platform"))
assert.Check(c, is.Contains(out, "plugins are not supported on this platform"))
assert.ErrorContains(c, err, "plugins are not supported on this platform")
}
@ -361,30 +362,30 @@ func (ps *DockerPluginSuite) TestPluginIDPrefix(c *testing.T) {
// List current state
out, _, err := dockerCmdWithError("plugin", "ls")
assert.NilError(c, err)
assert.Assert(c, strings.Contains(out, name))
assert.Assert(c, strings.Contains(out, "false"))
assert.Check(c, is.Contains(out, name))
assert.Check(c, is.Contains(out, "false"))
env, _ := dockerCmd(c, "plugin", "inspect", "-f", "{{.Settings.Env}}", id[:5])
assert.Equal(c, strings.TrimSpace(env), "[DEBUG=0]")
assert.Check(c, is.Equal(strings.TrimSpace(env), "[DEBUG=0]"))
dockerCmd(c, "plugin", "set", id[:5], "DEBUG=1")
env, _ = dockerCmd(c, "plugin", "inspect", "-f", "{{.Settings.Env}}", id[:5])
assert.Equal(c, strings.TrimSpace(env), "[DEBUG=1]")
assert.Check(c, is.Equal(strings.TrimSpace(env), "[DEBUG=1]"))
// Enable
_, _, err = dockerCmdWithError("plugin", "enable", id[:5])
assert.NilError(c, err)
out, _, err = dockerCmdWithError("plugin", "ls")
assert.NilError(c, err)
assert.Assert(c, strings.Contains(out, name))
assert.Assert(c, strings.Contains(out, "true"))
assert.Check(c, is.Contains(out, name))
assert.Check(c, is.Contains(out, "true"))
// Disable
_, _, err = dockerCmdWithError("plugin", "disable", id[:5])
assert.NilError(c, err)
out, _, err = dockerCmdWithError("plugin", "ls")
assert.NilError(c, err)
assert.Assert(c, strings.Contains(out, name))
assert.Assert(c, strings.Contains(out, "false"))
assert.Check(c, is.Contains(out, name))
assert.Check(c, is.Contains(out, "false"))
// Remove
_, _, err = dockerCmdWithError("plugin", "remove", id[:5])
assert.NilError(c, err)
@ -422,7 +423,7 @@ description: test plugin
enabled: false`, id, name)
out, _ = dockerCmd(c, "--config", config, "plugin", "ls", "--no-trunc")
assert.Assert(c, strings.Contains(strings.TrimSpace(out), expectedOutput))
assert.Check(c, is.Contains(out, expectedOutput))
}
func (s *DockerCLIPluginsSuite) TestPluginUpgrade(c *testing.T) {
@ -436,7 +437,7 @@ func (s *DockerCLIPluginsSuite) TestPluginUpgrade(c *testing.T) {
out, _, err := dockerCmdWithError("plugin", "upgrade", "--grant-all-permissions", plugin, pluginV2)
assert.ErrorContains(c, err, "", out)
assert.Assert(c, strings.Contains(out, "disabled before upgrading"))
assert.Check(c, is.Contains(out, "disabled before upgrading"))
out, _ = dockerCmd(c, "plugin", "inspect", "--format={{.ID}}", plugin)
id := strings.TrimSpace(out)
@ -474,5 +475,5 @@ func (s *DockerCLIPluginsSuite) TestPluginMetricsCollector(c *testing.T) {
b, err := io.ReadAll(resp.Body)
assert.NilError(c, err)
// check that a known metric is there... don't expect this metric to change over time.. probably safe
assert.Assert(c, strings.Contains(string(b), "container_actions"))
assert.Check(c, is.Contains(string(b), "container_actions"))
}