integration-cli/docker_api_inspect_test.go

   1 package main
   2
   3 import (
   4         "encoding/json"
   5         "net/http"
   6         "strings"
   7
   8         "github.com/docker/docker/api/types"
   9         "github.com/docker/docker/api/types/versions/v1p20"
  10         "github.com/docker/docker/integration-cli/checker"
  11         "github.com/docker/docker/integration-cli/request"
  12         "github.com/docker/docker/pkg/stringutils"
  13         "github.com/go-check/check"
  14 )
  15
  16 func (s *DockerSuite) TestInspectAPIContainerResponse(c *check.C) {
  17         out, _ := dockerCmd(c, "run", "-d", "busybox", "true")
  18
  19         cleanedContainerID := strings.TrimSpace(out)
  20         keysBase := []string{"Id", "State", "Created", "Path", "Args", "Config", "Image", "NetworkSettings",
  21                 "ResolvConfPath", "HostnamePath", "HostsPath", "LogPath", "Name", "Driver", "MountLabel", "ProcessLabel", "GraphDriver"}
  22
  23         type acase struct {
  24                 version string
  25                 keys    []string
  26         }
  27
  28         var cases []acase
  29
  30         if testEnv.DaemonPlatform() == "windows" {
  31                 cases = []acase{
  32                         {"v1.25", append(keysBase, "Mounts")},
  33                 }
  34
  35         } else {
  36                 cases = []acase{
  37                         {"v1.20", append(keysBase, "Mounts")},
  38                         {"v1.19", append(keysBase, "Volumes", "VolumesRW")},
  39                 }
  40         }
  41
  42         for _, cs := range cases {
  43                 body := getInspectBody(c, cs.version, cleanedContainerID)
  44
  45                 var inspectJSON map[string]interface{}
  46                 err := json.Unmarshal(body, &inspectJSON)
  47                 c.Assert(err, checker.IsNil, check.Commentf("Unable to unmarshal body for version %s", cs.version))
  48
  49                 for _, key := range cs.keys {
  50                         _, ok := inspectJSON[key]
  51                         c.Check(ok, checker.True, check.Commentf("%s does not exist in response for version %s", key, cs.version))
  52                 }
  53
  54                 //Issue #6830: type not properly converted to JSON/back
  55                 _, ok := inspectJSON["Path"].(bool)
  56                 c.Assert(ok, checker.False, check.Commentf("Path of `true` should not be converted to boolean `true` via JSON marshalling"))
  57         }
  58 }
  59
  60 func (s *DockerSuite) TestInspectAPIContainerVolumeDriverLegacy(c *check.C) {
  61         // No legacy implications for Windows
  62         testRequires(c, DaemonIsLinux)
  63         out, _ := dockerCmd(c, "run", "-d", "busybox", "true")
  64
  65         cleanedContainerID := strings.TrimSpace(out)
  66
  67         cases := []string{"v1.19", "v1.20"}
  68         for _, version := range cases {
  69                 body := getInspectBody(c, version, cleanedContainerID)
  70
  71                 var inspectJSON map[string]interface{}
  72                 err := json.Unmarshal(body, &inspectJSON)
  73                 c.Assert(err, checker.IsNil, check.Commentf("Unable to unmarshal body for version %s", version))
  74
  75                 config, ok := inspectJSON["Config"]
  76                 c.Assert(ok, checker.True, check.Commentf("Unable to find 'Config'"))
  77                 cfg := config.(map[string]interface{})
  78                 _, ok = cfg["VolumeDriver"]
  79                 c.Assert(ok, checker.True, check.Commentf("API version %s expected to include VolumeDriver in 'Config'", version))
  80         }
  81 }
  82
  83 func (s *DockerSuite) TestInspectAPIContainerVolumeDriver(c *check.C) {
  84         out, _ := dockerCmd(c, "run", "-d", "--volume-driver", "local", "busybox", "true")
  85
  86         cleanedContainerID := strings.TrimSpace(out)
  87
  88         body := getInspectBody(c, "v1.25", cleanedContainerID)
  89
  90         var inspectJSON map[string]interface{}
  91         err := json.Unmarshal(body, &inspectJSON)
  92         c.Assert(err, checker.IsNil, check.Commentf("Unable to unmarshal body for version 1.25"))
  93
  94         config, ok := inspectJSON["Config"]
  95         c.Assert(ok, checker.True, check.Commentf("Unable to find 'Config'"))
  96         cfg := config.(map[string]interface{})
  97         _, ok = cfg["VolumeDriver"]
  98         c.Assert(ok, checker.False, check.Commentf("API version 1.25 expected to not include VolumeDriver in 'Config'"))
  99
 100         config, ok = inspectJSON["HostConfig"]
 101         c.Assert(ok, checker.True, check.Commentf("Unable to find 'HostConfig'"))
 102         cfg = config.(map[string]interface{})
 103         _, ok = cfg["VolumeDriver"]
 104         c.Assert(ok, checker.True, check.Commentf("API version 1.25 expected to include VolumeDriver in 'HostConfig'"))
 105 }
 106
 107 func (s *DockerSuite) TestInspectAPIImageResponse(c *check.C) {
 108         dockerCmd(c, "tag", "busybox:latest", "busybox:mytag")
 109
 110         endpoint := "/images/busybox/json"
 111         status, body, err := request.SockRequest("GET", endpoint, nil, daemonHost())
 112
 113         c.Assert(err, checker.IsNil)
 114         c.Assert(status, checker.Equals, http.StatusOK)
 115
 116         var imageJSON types.ImageInspect
 117         err = json.Unmarshal(body, &imageJSON)
 118         c.Assert(err, checker.IsNil, check.Commentf("Unable to unmarshal body for latest version"))
 119         c.Assert(imageJSON.RepoTags, checker.HasLen, 2)
 120
 121         c.Assert(stringutils.InSlice(imageJSON.RepoTags, "busybox:latest"), checker.Equals, true)
 122         c.Assert(stringutils.InSlice(imageJSON.RepoTags, "busybox:mytag"), checker.Equals, true)
 123 }
 124
 125 // #17131, #17139, #17173
 126 func (s *DockerSuite) TestInspectAPIEmptyFieldsInConfigPre121(c *check.C) {
 127         // Not relevant on Windows
 128         testRequires(c, DaemonIsLinux)
 129         out, _ := dockerCmd(c, "run", "-d", "busybox", "true")
 130
 131         cleanedContainerID := strings.TrimSpace(out)
 132
 133         cases := []string{"v1.19", "v1.20"}
 134         for _, version := range cases {
 135                 body := getInspectBody(c, version, cleanedContainerID)
 136
 137                 var inspectJSON map[string]interface{}
 138                 err := json.Unmarshal(body, &inspectJSON)
 139                 c.Assert(err, checker.IsNil, check.Commentf("Unable to unmarshal body for version %s", version))
 140                 config, ok := inspectJSON["Config"]
 141                 c.Assert(ok, checker.True, check.Commentf("Unable to find 'Config'"))
 142                 cfg := config.(map[string]interface{})
 143                 for _, f := range []string{"MacAddress", "NetworkDisabled", "ExposedPorts"} {
 144                         _, ok := cfg[f]
 145                         c.Check(ok, checker.True, check.Commentf("API version %s expected to include %s in 'Config'", version, f))
 146                 }
 147         }
 148 }
 149
 150 func (s *DockerSuite) TestInspectAPIBridgeNetworkSettings120(c *check.C) {
 151         // Not relevant on Windows, and besides it doesn't have any bridge network settings
 152         testRequires(c, DaemonIsLinux)
 153         out, _ := dockerCmd(c, "run", "-d", "busybox", "top")
 154         containerID := strings.TrimSpace(out)
 155         waitRun(containerID)
 156
 157         body := getInspectBody(c, "v1.20", containerID)
 158
 159         var inspectJSON v1p20.ContainerJSON
 160         err := json.Unmarshal(body, &inspectJSON)
 161         c.Assert(err, checker.IsNil)
 162
 163         settings := inspectJSON.NetworkSettings
 164         c.Assert(settings.IPAddress, checker.Not(checker.HasLen), 0)
 165 }
 166
 167 func (s *DockerSuite) TestInspectAPIBridgeNetworkSettings121(c *check.C) {
 168         // Windows doesn't have any bridge network settings
 169         testRequires(c, DaemonIsLinux)
 170         out, _ := dockerCmd(c, "run", "-d", "busybox", "top")
 171         containerID := strings.TrimSpace(out)
 172         waitRun(containerID)
 173
 174         body := getInspectBody(c, "v1.21", containerID)
 175
 176         var inspectJSON types.ContainerJSON
 177         err := json.Unmarshal(body, &inspectJSON)
 178         c.Assert(err, checker.IsNil)
 179
 180         settings := inspectJSON.NetworkSettings
 181         c.Assert(settings.IPAddress, checker.Not(checker.HasLen), 0)
 182         c.Assert(settings.Networks["bridge"], checker.Not(checker.IsNil))
 183         c.Assert(settings.IPAddress, checker.Equals, settings.Networks["bridge"].IPAddress)
 184 }