github.com/devdivbcp/moby@v17.12.0-ce-rc1.0.20200726071732-2d4bfdc789ad+incompatible/integration-cli/docker_cli_info_test.go (about) 1 package main 2 3 import ( 4 "encoding/json" 5 "fmt" 6 "net" 7 "strings" 8 "testing" 9 10 "github.com/docker/docker/integration-cli/daemon" 11 testdaemon "github.com/docker/docker/internal/test/daemon" 12 "gotest.tools/assert" 13 ) 14 15 // ensure docker info succeeds 16 func (s *DockerSuite) TestInfoEnsureSucceeds(c *testing.T) { 17 out, _ := dockerCmd(c, "info") 18 19 // always shown fields 20 stringsToCheck := []string{ 21 "ID:", 22 "Containers:", 23 " Running:", 24 " Paused:", 25 " Stopped:", 26 "Images:", 27 "OSType:", 28 "Architecture:", 29 "Logging Driver:", 30 "Operating System:", 31 "CPUs:", 32 "Total Memory:", 33 "Kernel Version:", 34 "Storage Driver:", 35 "Volume:", 36 "Network:", 37 "Live Restore Enabled:", 38 } 39 40 if testEnv.OSType == "linux" { 41 stringsToCheck = append(stringsToCheck, "Init Binary:", "Security Options:", "containerd version:", "runc version:", "init version:") 42 } 43 44 if DaemonIsLinux() { 45 stringsToCheck = append(stringsToCheck, "Runtimes:", "Default Runtime: runc") 46 } 47 48 if testEnv.DaemonInfo.ExperimentalBuild { 49 stringsToCheck = append(stringsToCheck, "Experimental: true") 50 } else { 51 stringsToCheck = append(stringsToCheck, "Experimental: false") 52 } 53 54 for _, linePrefix := range stringsToCheck { 55 assert.Assert(c, strings.Contains(out, linePrefix), "couldn't find string %v in output", linePrefix) 56 } 57 } 58 59 // TestInfoFormat tests `docker info --format` 60 func (s *DockerSuite) TestInfoFormat(c *testing.T) { 61 out, status := dockerCmd(c, "info", "--format", "{{json .}}") 62 assert.Equal(c, status, 0) 63 var m map[string]interface{} 64 err := json.Unmarshal([]byte(out), &m) 65 assert.NilError(c, err) 66 _, _, err = dockerCmdWithError("info", "--format", "{{.badString}}") 67 assert.ErrorContains(c, err, "") 68 } 69 70 // TestInfoDiscoveryBackend verifies that a daemon run with `--cluster-advertise` and 71 // `--cluster-store` properly show the backend's endpoint in info output. 72 func (s *DockerSuite) TestInfoDiscoveryBackend(c *testing.T) { 73 testRequires(c, testEnv.IsLocalDaemon, DaemonIsLinux) 74 75 d := daemon.New(c, dockerBinary, dockerdBinary, testdaemon.WithEnvironment(testEnv.Execution)) 76 discoveryBackend := "consul://consuladdr:consulport/some/path" 77 discoveryAdvertise := "1.1.1.1:2375" 78 d.Start(c, fmt.Sprintf("--cluster-store=%s", discoveryBackend), fmt.Sprintf("--cluster-advertise=%s", discoveryAdvertise)) 79 defer d.Stop(c) 80 81 out, err := d.Cmd("info") 82 assert.NilError(c, err) 83 assert.Assert(c, strings.Contains(out, fmt.Sprintf("Cluster Store: %s\n", discoveryBackend))) 84 assert.Assert(c, strings.Contains(out, fmt.Sprintf("Cluster Advertise: %s\n", discoveryAdvertise))) 85 } 86 87 // TestInfoDiscoveryInvalidAdvertise verifies that a daemon run with 88 // an invalid `--cluster-advertise` configuration 89 func (s *DockerSuite) TestInfoDiscoveryInvalidAdvertise(c *testing.T) { 90 testRequires(c, testEnv.IsLocalDaemon, DaemonIsLinux) 91 92 d := daemon.New(c, dockerBinary, dockerdBinary, testdaemon.WithEnvironment(testEnv.Execution)) 93 discoveryBackend := "consul://consuladdr:consulport/some/path" 94 95 // --cluster-advertise with an invalid string is an error 96 err := d.StartWithError(fmt.Sprintf("--cluster-store=%s", discoveryBackend), "--cluster-advertise=invalid") 97 assert.ErrorContains(c, err, "") 98 99 // --cluster-advertise without --cluster-store is also an error 100 err = d.StartWithError("--cluster-advertise=1.1.1.1:2375") 101 assert.ErrorContains(c, err, "") 102 } 103 104 // TestInfoDiscoveryAdvertiseInterfaceName verifies that a daemon run with `--cluster-advertise` 105 // configured with interface name properly show the advertise ip-address in info output. 106 func (s *DockerSuite) TestInfoDiscoveryAdvertiseInterfaceName(c *testing.T) { 107 testRequires(c, testEnv.IsLocalDaemon, Network, DaemonIsLinux) 108 109 d := daemon.New(c, dockerBinary, dockerdBinary, testdaemon.WithEnvironment(testEnv.Execution)) 110 discoveryBackend := "consul://consuladdr:consulport/some/path" 111 discoveryAdvertise := "eth0" 112 113 d.Start(c, fmt.Sprintf("--cluster-store=%s", discoveryBackend), fmt.Sprintf("--cluster-advertise=%s:2375", discoveryAdvertise)) 114 defer d.Stop(c) 115 116 iface, err := net.InterfaceByName(discoveryAdvertise) 117 assert.NilError(c, err) 118 addrs, err := iface.Addrs() 119 assert.NilError(c, err) 120 assert.Assert(c, len(addrs) > 0) 121 ip, _, err := net.ParseCIDR(addrs[0].String()) 122 assert.NilError(c, err) 123 124 out, err := d.Cmd("info") 125 assert.NilError(c, err) 126 assert.Assert(c, strings.Contains(out, fmt.Sprintf("Cluster Store: %s\n", discoveryBackend))) 127 assert.Assert(c, strings.Contains(out, fmt.Sprintf("Cluster Advertise: %s:2375\n", ip.String()))) 128 } 129 130 func (s *DockerSuite) TestInfoDisplaysRunningContainers(c *testing.T) { 131 testRequires(c, DaemonIsLinux) 132 133 existing := existingContainerStates(c) 134 135 dockerCmd(c, "run", "-d", "busybox", "top") 136 out, _ := dockerCmd(c, "info") 137 assert.Assert(c, strings.Contains(out, fmt.Sprintf("Containers: %d\n", existing["Containers"]+1))) 138 assert.Assert(c, strings.Contains(out, fmt.Sprintf(" Running: %d\n", existing["ContainersRunning"]+1))) 139 assert.Assert(c, strings.Contains(out, fmt.Sprintf(" Paused: %d\n", existing["ContainersPaused"]))) 140 assert.Assert(c, strings.Contains(out, fmt.Sprintf(" Stopped: %d\n", existing["ContainersStopped"]))) 141 } 142 143 func (s *DockerSuite) TestInfoDisplaysPausedContainers(c *testing.T) { 144 testRequires(c, IsPausable) 145 146 existing := existingContainerStates(c) 147 148 out := runSleepingContainer(c, "-d") 149 cleanedContainerID := strings.TrimSpace(out) 150 151 dockerCmd(c, "pause", cleanedContainerID) 152 153 out, _ = dockerCmd(c, "info") 154 assert.Assert(c, strings.Contains(out, fmt.Sprintf("Containers: %d\n", existing["Containers"]+1))) 155 assert.Assert(c, strings.Contains(out, fmt.Sprintf(" Running: %d\n", existing["ContainersRunning"]))) 156 assert.Assert(c, strings.Contains(out, fmt.Sprintf(" Paused: %d\n", existing["ContainersPaused"]+1))) 157 assert.Assert(c, strings.Contains(out, fmt.Sprintf(" Stopped: %d\n", existing["ContainersStopped"]))) 158 } 159 160 func (s *DockerSuite) TestInfoDisplaysStoppedContainers(c *testing.T) { 161 testRequires(c, DaemonIsLinux) 162 163 existing := existingContainerStates(c) 164 165 out, _ := dockerCmd(c, "run", "-d", "busybox", "top") 166 cleanedContainerID := strings.TrimSpace(out) 167 168 dockerCmd(c, "stop", cleanedContainerID) 169 170 out, _ = dockerCmd(c, "info") 171 assert.Assert(c, strings.Contains(out, fmt.Sprintf("Containers: %d\n", existing["Containers"]+1))) 172 assert.Assert(c, strings.Contains(out, fmt.Sprintf(" Running: %d\n", existing["ContainersRunning"]))) 173 assert.Assert(c, strings.Contains(out, fmt.Sprintf(" Paused: %d\n", existing["ContainersPaused"]))) 174 assert.Assert(c, strings.Contains(out, fmt.Sprintf(" Stopped: %d\n", existing["ContainersStopped"]+1))) 175 } 176 177 func (s *DockerSuite) TestInfoDebug(c *testing.T) { 178 testRequires(c, testEnv.IsLocalDaemon, DaemonIsLinux) 179 180 d := daemon.New(c, dockerBinary, dockerdBinary, testdaemon.WithEnvironment(testEnv.Execution)) 181 d.Start(c, "--debug") 182 defer d.Stop(c) 183 184 out, err := d.Cmd("--debug", "info") 185 assert.NilError(c, err) 186 assert.Assert(c, strings.Contains(out, "Debug Mode (client): true\n")) 187 assert.Assert(c, strings.Contains(out, "Debug Mode (server): true\n")) 188 assert.Assert(c, strings.Contains(out, "File Descriptors")) 189 assert.Assert(c, strings.Contains(out, "Goroutines")) 190 assert.Assert(c, strings.Contains(out, "System Time")) 191 assert.Assert(c, strings.Contains(out, "EventsListeners")) 192 assert.Assert(c, strings.Contains(out, "Docker Root Dir")) 193 } 194 195 func (s *DockerSuite) TestInsecureRegistries(c *testing.T) { 196 testRequires(c, testEnv.IsLocalDaemon, DaemonIsLinux) 197 198 registryCIDR := "192.168.1.0/24" 199 registryHost := "insecurehost.com:5000" 200 201 d := daemon.New(c, dockerBinary, dockerdBinary, testdaemon.WithEnvironment(testEnv.Execution)) 202 d.Start(c, "--insecure-registry="+registryCIDR, "--insecure-registry="+registryHost) 203 defer d.Stop(c) 204 205 out, err := d.Cmd("info") 206 assert.NilError(c, err) 207 assert.Assert(c, strings.Contains(out, "Insecure Registries:\n")) 208 assert.Assert(c, strings.Contains(out, fmt.Sprintf(" %s\n", registryHost))) 209 assert.Assert(c, strings.Contains(out, fmt.Sprintf(" %s\n", registryCIDR))) 210 } 211 212 func (s *DockerDaemonSuite) TestRegistryMirrors(c *testing.T) { 213 214 registryMirror1 := "https://192.168.1.2" 215 registryMirror2 := "http://registry.mirror.com:5000" 216 217 s.d.Start(c, "--registry-mirror="+registryMirror1, "--registry-mirror="+registryMirror2) 218 219 out, err := s.d.Cmd("info") 220 assert.NilError(c, err) 221 assert.Assert(c, strings.Contains(out, "Registry Mirrors:\n")) 222 assert.Assert(c, strings.Contains(out, fmt.Sprintf(" %s", registryMirror1))) 223 assert.Assert(c, strings.Contains(out, fmt.Sprintf(" %s", registryMirror2))) 224 } 225 226 func existingContainerStates(c *testing.T) map[string]int { 227 out, _ := dockerCmd(c, "info", "--format", "{{json .}}") 228 var m map[string]interface{} 229 err := json.Unmarshal([]byte(out), &m) 230 assert.NilError(c, err) 231 res := map[string]int{} 232 res["Containers"] = int(m["Containers"].(float64)) 233 res["ContainersRunning"] = int(m["ContainersRunning"].(float64)) 234 res["ContainersPaused"] = int(m["ContainersPaused"].(float64)) 235 res["ContainersStopped"] = int(m["ContainersStopped"].(float64)) 236 return res 237 }