docker_cli_plugins_test.go 18 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478
  1. package main
  2. import (
  3. "context"
  4. "fmt"
  5. "io"
  6. "net/http"
  7. "os"
  8. "path"
  9. "path/filepath"
  10. "strings"
  11. "testing"
  12. "time"
  13. "github.com/docker/docker/api/types"
  14. "github.com/docker/docker/integration-cli/cli"
  15. "github.com/docker/docker/integration-cli/daemon"
  16. "github.com/docker/docker/testutil/fixtures/plugin"
  17. "gotest.tools/v3/assert"
  18. "gotest.tools/v3/skip"
  19. )
  20. var (
  21. pluginProcessName = "sample-volume-plugin"
  22. pName = "tiborvass/sample-volume-plugin"
  23. npName = "tiborvass/test-docker-netplugin"
  24. pTag = "latest"
  25. pNameWithTag = pName + ":" + pTag
  26. npNameWithTag = npName + ":" + pTag
  27. )
  28. type DockerCLIPluginsSuite struct {
  29. ds *DockerSuite
  30. }
  31. func (s *DockerCLIPluginsSuite) TearDownTest(c *testing.T) {
  32. s.ds.TearDownTest(c)
  33. }
  34. func (s *DockerCLIPluginsSuite) OnTimeout(c *testing.T) {
  35. s.ds.OnTimeout(c)
  36. }
  37. func (ps *DockerPluginSuite) TestPluginBasicOps(c *testing.T) {
  38. plugin := ps.getPluginRepoWithTag()
  39. _, _, err := dockerCmdWithError("plugin", "install", "--grant-all-permissions", plugin)
  40. assert.NilError(c, err)
  41. out, _, err := dockerCmdWithError("plugin", "ls")
  42. assert.NilError(c, err)
  43. assert.Assert(c, strings.Contains(out, plugin))
  44. assert.Assert(c, strings.Contains(out, "true"))
  45. id, _, err := dockerCmdWithError("plugin", "inspect", "-f", "{{.Id}}", plugin)
  46. id = strings.TrimSpace(id)
  47. assert.NilError(c, err)
  48. out, _, err = dockerCmdWithError("plugin", "remove", plugin)
  49. assert.ErrorContains(c, err, "")
  50. assert.Assert(c, strings.Contains(out, "is enabled"))
  51. _, _, err = dockerCmdWithError("plugin", "disable", plugin)
  52. assert.NilError(c, err)
  53. out, _, err = dockerCmdWithError("plugin", "remove", plugin)
  54. assert.NilError(c, err)
  55. assert.Assert(c, strings.Contains(out, plugin))
  56. _, err = os.Stat(filepath.Join(testEnv.DaemonInfo.DockerRootDir, "plugins", id))
  57. if !os.IsNotExist(err) {
  58. c.Fatal(err)
  59. }
  60. }
  61. func (ps *DockerPluginSuite) TestPluginForceRemove(c *testing.T) {
  62. pNameWithTag := ps.getPluginRepoWithTag()
  63. _, _, err := dockerCmdWithError("plugin", "install", "--grant-all-permissions", pNameWithTag)
  64. assert.NilError(c, err)
  65. out, _, _ := dockerCmdWithError("plugin", "remove", pNameWithTag)
  66. assert.Assert(c, strings.Contains(out, "is enabled"))
  67. out, _, err = dockerCmdWithError("plugin", "remove", "--force", pNameWithTag)
  68. assert.NilError(c, err)
  69. assert.Assert(c, strings.Contains(out, pNameWithTag))
  70. }
  71. func (s *DockerCLIPluginsSuite) TestPluginActive(c *testing.T) {
  72. testRequires(c, DaemonIsLinux, IsAmd64, Network)
  73. _, _, err := dockerCmdWithError("plugin", "install", "--grant-all-permissions", pNameWithTag)
  74. assert.NilError(c, err)
  75. _, _, err = dockerCmdWithError("volume", "create", "-d", pNameWithTag, "--name", "testvol1")
  76. assert.NilError(c, err)
  77. out, _, _ := dockerCmdWithError("plugin", "disable", pNameWithTag)
  78. assert.Assert(c, strings.Contains(out, "in use"))
  79. _, _, err = dockerCmdWithError("volume", "rm", "testvol1")
  80. assert.NilError(c, err)
  81. _, _, err = dockerCmdWithError("plugin", "disable", pNameWithTag)
  82. assert.NilError(c, err)
  83. out, _, err = dockerCmdWithError("plugin", "remove", pNameWithTag)
  84. assert.NilError(c, err)
  85. assert.Assert(c, strings.Contains(out, pNameWithTag))
  86. }
  87. func (s *DockerCLIPluginsSuite) TestPluginActiveNetwork(c *testing.T) {
  88. testRequires(c, DaemonIsLinux, IsAmd64, Network)
  89. _, _, err := dockerCmdWithError("plugin", "install", "--grant-all-permissions", npNameWithTag)
  90. assert.NilError(c, err)
  91. out, _, err := dockerCmdWithError("network", "create", "-d", npNameWithTag, "test")
  92. assert.NilError(c, err)
  93. nID := strings.TrimSpace(out)
  94. out, _, _ = dockerCmdWithError("plugin", "remove", npNameWithTag)
  95. assert.Assert(c, strings.Contains(out, "is in use"))
  96. _, _, err = dockerCmdWithError("network", "rm", nID)
  97. assert.NilError(c, err)
  98. out, _, _ = dockerCmdWithError("plugin", "remove", npNameWithTag)
  99. assert.Assert(c, strings.Contains(out, "is enabled"))
  100. _, _, err = dockerCmdWithError("plugin", "disable", npNameWithTag)
  101. assert.NilError(c, err)
  102. out, _, err = dockerCmdWithError("plugin", "remove", npNameWithTag)
  103. assert.NilError(c, err)
  104. assert.Assert(c, strings.Contains(out, npNameWithTag))
  105. }
  106. func (ps *DockerPluginSuite) TestPluginInstallDisable(c *testing.T) {
  107. pName := ps.getPluginRepoWithTag()
  108. out, _, err := dockerCmdWithError("plugin", "install", "--grant-all-permissions", "--disable", pName)
  109. assert.NilError(c, err)
  110. assert.Assert(c, strings.Contains(strings.TrimSpace(out), pName))
  111. out, _, err = dockerCmdWithError("plugin", "ls")
  112. assert.NilError(c, err)
  113. assert.Assert(c, strings.Contains(out, "false"))
  114. out, _, err = dockerCmdWithError("plugin", "enable", pName)
  115. assert.NilError(c, err)
  116. assert.Assert(c, strings.Contains(strings.TrimSpace(out), pName))
  117. out, _, err = dockerCmdWithError("plugin", "disable", pName)
  118. assert.NilError(c, err)
  119. assert.Assert(c, strings.Contains(strings.TrimSpace(out), pName))
  120. out, _, err = dockerCmdWithError("plugin", "remove", pName)
  121. assert.NilError(c, err)
  122. assert.Assert(c, strings.Contains(strings.TrimSpace(out), pName))
  123. }
  124. func (s *DockerCLIPluginsSuite) TestPluginInstallDisableVolumeLs(c *testing.T) {
  125. testRequires(c, DaemonIsLinux, IsAmd64, Network)
  126. out, _, err := dockerCmdWithError("plugin", "install", "--grant-all-permissions", "--disable", pName)
  127. assert.NilError(c, err)
  128. assert.Assert(c, strings.Contains(strings.TrimSpace(out), pName))
  129. dockerCmd(c, "volume", "ls")
  130. }
  131. func (ps *DockerPluginSuite) TestPluginSet(c *testing.T) {
  132. client := testEnv.APIClient()
  133. name := "test"
  134. ctx, cancel := context.WithTimeout(context.Background(), 60*time.Second)
  135. defer cancel()
  136. initialValue := "0"
  137. mntSrc := "foo"
  138. devPath := "/dev/bar"
  139. // Create a new plugin with extra settings
  140. err := plugin.Create(ctx, client, name, func(cfg *plugin.Config) {
  141. cfg.Env = []types.PluginEnv{{Name: "DEBUG", Value: &initialValue, Settable: []string{"value"}}}
  142. cfg.Mounts = []types.PluginMount{
  143. {Name: "pmount1", Settable: []string{"source"}, Type: "none", Source: &mntSrc},
  144. {Name: "pmount2", Settable: []string{"source"}, Type: "none"}, // Mount without source is invalid.
  145. }
  146. cfg.Linux.Devices = []types.PluginDevice{
  147. {Name: "pdev1", Path: &devPath, Settable: []string{"path"}},
  148. {Name: "pdev2", Settable: []string{"path"}}, // Device without Path is invalid.
  149. }
  150. })
  151. assert.Assert(c, err == nil, "failed to create test plugin")
  152. env, _ := dockerCmd(c, "plugin", "inspect", "-f", "{{.Settings.Env}}", name)
  153. assert.Equal(c, strings.TrimSpace(env), "[DEBUG=0]")
  154. dockerCmd(c, "plugin", "set", name, "DEBUG=1")
  155. env, _ = dockerCmd(c, "plugin", "inspect", "-f", "{{.Settings.Env}}", name)
  156. assert.Equal(c, strings.TrimSpace(env), "[DEBUG=1]")
  157. env, _ = dockerCmd(c, "plugin", "inspect", "-f", "{{with $mount := index .Settings.Mounts 0}}{{$mount.Source}}{{end}}", name)
  158. assert.Assert(c, strings.Contains(strings.TrimSpace(env), mntSrc))
  159. dockerCmd(c, "plugin", "set", name, "pmount1.source=bar")
  160. env, _ = dockerCmd(c, "plugin", "inspect", "-f", "{{with $mount := index .Settings.Mounts 0}}{{$mount.Source}}{{end}}", name)
  161. assert.Assert(c, strings.Contains(strings.TrimSpace(env), "bar"))
  162. out, _, err := dockerCmdWithError("plugin", "set", name, "pmount2.source=bar2")
  163. assert.ErrorContains(c, err, "")
  164. assert.Assert(c, strings.Contains(out, "Plugin config has no mount source"))
  165. out, _, err = dockerCmdWithError("plugin", "set", name, "pdev2.path=/dev/bar2")
  166. assert.ErrorContains(c, err, "")
  167. assert.Assert(c, strings.Contains(out, "Plugin config has no device path"))
  168. }
  169. func (ps *DockerPluginSuite) TestPluginInstallArgs(c *testing.T) {
  170. pName := path.Join(ps.registryHost(), "plugin", "testplugininstallwithargs")
  171. ctx, cancel := context.WithTimeout(context.Background(), 60*time.Second)
  172. defer cancel()
  173. plugin.CreateInRegistry(ctx, pName, nil, func(cfg *plugin.Config) {
  174. cfg.Env = []types.PluginEnv{{Name: "DEBUG", Settable: []string{"value"}}}
  175. })
  176. out, _ := dockerCmd(c, "plugin", "install", "--grant-all-permissions", "--disable", pName, "DEBUG=1")
  177. assert.Assert(c, strings.Contains(strings.TrimSpace(out), pName))
  178. env, _ := dockerCmd(c, "plugin", "inspect", "-f", "{{.Settings.Env}}", pName)
  179. assert.Equal(c, strings.TrimSpace(env), "[DEBUG=1]")
  180. }
  181. func (ps *DockerPluginSuite) TestPluginInstallImage(c *testing.T) {
  182. testRequires(c, IsAmd64)
  183. skip.If(c, GitHubActions, "FIXME: https://github.com/moby/moby/issues/43996")
  184. repoName := fmt.Sprintf("%v/dockercli/busybox", privateRegistryURL)
  185. // tag the image to upload it to the private registry
  186. dockerCmd(c, "tag", "busybox", repoName)
  187. // push the image to the registry
  188. dockerCmd(c, "push", repoName)
  189. out, _, err := dockerCmdWithError("plugin", "install", repoName)
  190. assert.ErrorContains(c, err, "")
  191. assert.Assert(c, strings.Contains(out, `Encountered remote "application/vnd.docker.container.image.v1+json"(image) when fetching`))
  192. }
  193. func (ps *DockerPluginSuite) TestPluginEnableDisableNegative(c *testing.T) {
  194. pName := ps.getPluginRepoWithTag()
  195. out, _, err := dockerCmdWithError("plugin", "install", "--grant-all-permissions", pName)
  196. assert.NilError(c, err)
  197. assert.Assert(c, strings.Contains(strings.TrimSpace(out), pName))
  198. out, _, err = dockerCmdWithError("plugin", "enable", pName)
  199. assert.ErrorContains(c, err, "")
  200. assert.Assert(c, strings.Contains(strings.TrimSpace(out), "already enabled"))
  201. _, _, err = dockerCmdWithError("plugin", "disable", pName)
  202. assert.NilError(c, err)
  203. out, _, err = dockerCmdWithError("plugin", "disable", pName)
  204. assert.ErrorContains(c, err, "")
  205. assert.Assert(c, strings.Contains(strings.TrimSpace(out), "already disabled"))
  206. _, _, err = dockerCmdWithError("plugin", "remove", pName)
  207. assert.NilError(c, err)
  208. }
  209. func (ps *DockerPluginSuite) TestPluginCreate(c *testing.T) {
  210. name := "foo/bar-driver"
  211. temp, err := os.MkdirTemp("", "foo")
  212. assert.NilError(c, err)
  213. defer os.RemoveAll(temp)
  214. data := `{"description": "foo plugin"}`
  215. err = os.WriteFile(filepath.Join(temp, "config.json"), []byte(data), 0644)
  216. assert.NilError(c, err)
  217. err = os.MkdirAll(filepath.Join(temp, "rootfs"), 0700)
  218. assert.NilError(c, err)
  219. out, _, err := dockerCmdWithError("plugin", "create", name, temp)
  220. assert.NilError(c, err)
  221. assert.Assert(c, strings.Contains(out, name))
  222. out, _, err = dockerCmdWithError("plugin", "ls")
  223. assert.NilError(c, err)
  224. assert.Assert(c, strings.Contains(out, name))
  225. out, _, err = dockerCmdWithError("plugin", "create", name, temp)
  226. assert.ErrorContains(c, err, "")
  227. assert.Assert(c, strings.Contains(out, "already exist"))
  228. out, _, err = dockerCmdWithError("plugin", "ls")
  229. assert.NilError(c, err)
  230. assert.Assert(c, strings.Contains(out, name))
  231. // The output will consists of one HEADER line and one line of foo/bar-driver
  232. assert.Equal(c, len(strings.Split(strings.TrimSpace(out), "\n")), 2)
  233. }
  234. func (ps *DockerPluginSuite) TestPluginInspect(c *testing.T) {
  235. pNameWithTag := ps.getPluginRepoWithTag()
  236. _, _, err := dockerCmdWithError("plugin", "install", "--grant-all-permissions", pNameWithTag)
  237. assert.NilError(c, err)
  238. out, _, err := dockerCmdWithError("plugin", "ls")
  239. assert.NilError(c, err)
  240. assert.Assert(c, strings.Contains(out, pNameWithTag))
  241. assert.Assert(c, strings.Contains(out, "true"))
  242. // Find the ID first
  243. out, _, err = dockerCmdWithError("plugin", "inspect", "-f", "{{.Id}}", pNameWithTag)
  244. assert.NilError(c, err)
  245. id := strings.TrimSpace(out)
  246. assert.Assert(c, id != "")
  247. // Long form
  248. out, _, err = dockerCmdWithError("plugin", "inspect", "-f", "{{.Id}}", id)
  249. assert.NilError(c, err)
  250. assert.Equal(c, strings.TrimSpace(out), id)
  251. // Short form
  252. out, _, err = dockerCmdWithError("plugin", "inspect", "-f", "{{.Id}}", id[:5])
  253. assert.NilError(c, err)
  254. assert.Equal(c, strings.TrimSpace(out), id)
  255. // Name with tag form
  256. out, _, err = dockerCmdWithError("plugin", "inspect", "-f", "{{.Id}}", pNameWithTag)
  257. assert.NilError(c, err)
  258. assert.Equal(c, strings.TrimSpace(out), id)
  259. // Name without tag form
  260. out, _, err = dockerCmdWithError("plugin", "inspect", "-f", "{{.Id}}", ps.getPluginRepo())
  261. assert.NilError(c, err)
  262. assert.Equal(c, strings.TrimSpace(out), id)
  263. _, _, err = dockerCmdWithError("plugin", "disable", pNameWithTag)
  264. assert.NilError(c, err)
  265. out, _, err = dockerCmdWithError("plugin", "remove", pNameWithTag)
  266. assert.NilError(c, err)
  267. assert.Assert(c, strings.Contains(out, pNameWithTag))
  268. // After remove nothing should be found
  269. _, _, err = dockerCmdWithError("plugin", "inspect", "-f", "{{.Id}}", id[:5])
  270. assert.ErrorContains(c, err, "")
  271. }
  272. // Test case for https://github.com/docker/docker/pull/29186#discussion_r91277345
  273. func (s *DockerCLIPluginsSuite) TestPluginInspectOnWindows(c *testing.T) {
  274. // This test should work on Windows only
  275. testRequires(c, DaemonIsWindows)
  276. out, _, err := dockerCmdWithError("plugin", "inspect", "foobar")
  277. assert.ErrorContains(c, err, "")
  278. assert.Assert(c, strings.Contains(out, "plugins are not supported on this platform"))
  279. assert.ErrorContains(c, err, "plugins are not supported on this platform")
  280. }
  281. func (ps *DockerPluginSuite) TestPluginIDPrefix(c *testing.T) {
  282. name := "test"
  283. client := testEnv.APIClient()
  284. ctx, cancel := context.WithTimeout(context.Background(), 60*time.Second)
  285. initialValue := "0"
  286. err := plugin.Create(ctx, client, name, func(cfg *plugin.Config) {
  287. cfg.Env = []types.PluginEnv{{Name: "DEBUG", Value: &initialValue, Settable: []string{"value"}}}
  288. })
  289. cancel()
  290. assert.Assert(c, err == nil, "failed to create test plugin")
  291. // Find ID first
  292. id, _, err := dockerCmdWithError("plugin", "inspect", "-f", "{{.Id}}", name)
  293. id = strings.TrimSpace(id)
  294. assert.NilError(c, err)
  295. // List current state
  296. out, _, err := dockerCmdWithError("plugin", "ls")
  297. assert.NilError(c, err)
  298. assert.Assert(c, strings.Contains(out, name))
  299. assert.Assert(c, strings.Contains(out, "false"))
  300. env, _ := dockerCmd(c, "plugin", "inspect", "-f", "{{.Settings.Env}}", id[:5])
  301. assert.Equal(c, strings.TrimSpace(env), "[DEBUG=0]")
  302. dockerCmd(c, "plugin", "set", id[:5], "DEBUG=1")
  303. env, _ = dockerCmd(c, "plugin", "inspect", "-f", "{{.Settings.Env}}", id[:5])
  304. assert.Equal(c, strings.TrimSpace(env), "[DEBUG=1]")
  305. // Enable
  306. _, _, err = dockerCmdWithError("plugin", "enable", id[:5])
  307. assert.NilError(c, err)
  308. out, _, err = dockerCmdWithError("plugin", "ls")
  309. assert.NilError(c, err)
  310. assert.Assert(c, strings.Contains(out, name))
  311. assert.Assert(c, strings.Contains(out, "true"))
  312. // Disable
  313. _, _, err = dockerCmdWithError("plugin", "disable", id[:5])
  314. assert.NilError(c, err)
  315. out, _, err = dockerCmdWithError("plugin", "ls")
  316. assert.NilError(c, err)
  317. assert.Assert(c, strings.Contains(out, name))
  318. assert.Assert(c, strings.Contains(out, "false"))
  319. // Remove
  320. _, _, err = dockerCmdWithError("plugin", "remove", id[:5])
  321. assert.NilError(c, err)
  322. // List returns none
  323. out, _, err = dockerCmdWithError("plugin", "ls")
  324. assert.NilError(c, err)
  325. assert.Assert(c, !strings.Contains(out, name))
  326. }
  327. func (ps *DockerPluginSuite) TestPluginListDefaultFormat(c *testing.T) {
  328. config, err := os.MkdirTemp("", "config-file-")
  329. assert.NilError(c, err)
  330. defer os.RemoveAll(config)
  331. err = os.WriteFile(filepath.Join(config, "config.json"), []byte(`{"pluginsFormat": "raw"}`), 0644)
  332. assert.NilError(c, err)
  333. name := "test:latest"
  334. client := testEnv.APIClient()
  335. ctx, cancel := context.WithTimeout(context.Background(), 60*time.Second)
  336. defer cancel()
  337. err = plugin.Create(ctx, client, name, func(cfg *plugin.Config) {
  338. cfg.Description = "test plugin"
  339. })
  340. assert.Assert(c, err == nil, "failed to create test plugin")
  341. out, _ := dockerCmd(c, "plugin", "inspect", "--format", "{{.ID}}", name)
  342. id := strings.TrimSpace(out)
  343. // We expect the format to be in `raw + --no-trunc`
  344. expectedOutput := fmt.Sprintf(`plugin_id: %s
  345. name: %s
  346. description: test plugin
  347. enabled: false`, id, name)
  348. out, _ = dockerCmd(c, "--config", config, "plugin", "ls", "--no-trunc")
  349. assert.Assert(c, strings.Contains(strings.TrimSpace(out), expectedOutput))
  350. }
  351. func (s *DockerCLIPluginsSuite) TestPluginUpgrade(c *testing.T) {
  352. testRequires(c, DaemonIsLinux, Network, testEnv.IsLocalDaemon, IsAmd64, NotUserNamespace)
  353. plugin := "cpuguy83/docker-volume-driver-plugin-local:latest"
  354. pluginV2 := "cpuguy83/docker-volume-driver-plugin-local:v2"
  355. dockerCmd(c, "plugin", "install", "--grant-all-permissions", plugin)
  356. dockerCmd(c, "volume", "create", "--driver", plugin, "bananas")
  357. dockerCmd(c, "run", "--rm", "-v", "bananas:/apple", "busybox", "sh", "-c", "touch /apple/core")
  358. out, _, err := dockerCmdWithError("plugin", "upgrade", "--grant-all-permissions", plugin, pluginV2)
  359. assert.ErrorContains(c, err, "", out)
  360. assert.Assert(c, strings.Contains(out, "disabled before upgrading"))
  361. out, _ = dockerCmd(c, "plugin", "inspect", "--format={{.ID}}", plugin)
  362. id := strings.TrimSpace(out)
  363. // make sure "v2" does not exists
  364. _, err = os.Stat(filepath.Join(testEnv.DaemonInfo.DockerRootDir, "plugins", id, "rootfs", "v2"))
  365. assert.Assert(c, os.IsNotExist(err), out)
  366. dockerCmd(c, "plugin", "disable", "-f", plugin)
  367. dockerCmd(c, "plugin", "upgrade", "--grant-all-permissions", "--skip-remote-check", plugin, pluginV2)
  368. // make sure "v2" file exists
  369. _, err = os.Stat(filepath.Join(testEnv.DaemonInfo.DockerRootDir, "plugins", id, "rootfs", "v2"))
  370. assert.NilError(c, err)
  371. dockerCmd(c, "plugin", "enable", plugin)
  372. dockerCmd(c, "volume", "inspect", "bananas")
  373. dockerCmd(c, "run", "--rm", "-v", "bananas:/apple", "busybox", "sh", "-c", "ls -lh /apple/core")
  374. }
  375. func (s *DockerCLIPluginsSuite) TestPluginMetricsCollector(c *testing.T) {
  376. testRequires(c, DaemonIsLinux, Network, testEnv.IsLocalDaemon, IsAmd64)
  377. d := daemon.New(c, dockerBinary, dockerdBinary)
  378. d.Start(c)
  379. defer d.Stop(c)
  380. name := "cpuguy83/docker-metrics-plugin-test:latest"
  381. r := cli.Docker(cli.Args("plugin", "install", "--grant-all-permissions", name), cli.Daemon(d))
  382. assert.Assert(c, r.Error == nil, r.Combined())
  383. // plugin lisens on localhost:19393 and proxies the metrics
  384. resp, err := http.Get("http://localhost:19393/metrics")
  385. assert.NilError(c, err)
  386. defer resp.Body.Close()
  387. b, err := io.ReadAll(resp.Body)
  388. assert.NilError(c, err)
  389. // check that a known metric is there... don't expect this metric to change over time.. probably safe
  390. assert.Assert(c, strings.Contains(string(b), "container_actions"))
  391. }